feat: stub agent file structure

crates/nxmesh-agent/src/cache/config_cache.rs

@@ -0,0 +1,36 @@
+//! Configuration cache for offline operation
+
+use std::path::PathBuf;
+
+/// Configuration cache
+pub struct ConfigCache {
+    cache_dir: PathBuf,
+}
+
+impl ConfigCache {
+    /// Create a new config cache
+    pub fn new(cache_dir: &str) -> Self {
+        Self {
+            cache_dir: PathBuf::from(cache_dir),
+        }
+    }
+
+    /// Store configuration
+    pub async fn store(&self, config: &str) -> Result<(), Box<dyn std::error::Error>> {
+        let cache_file = self.cache_dir.join("config.json");
+        tokio::fs::create_dir_all(&self.cache_dir).await?;
+        tokio::fs::write(&cache_file, config).await?;
+        Ok(())
+    }
+
+    /// Load configuration
+    pub async fn load(&self) -> Result<Option<String>, Box<dyn std::error::Error>> {
+        let cache_file = self.cache_dir.join("config.json");
+        if cache_file.exists() {
+            let content = tokio::fs::read_to_string(&cache_file).await?;
+            Ok(Some(content))
+        } else {
+            Ok(None)
+        }
+    }
+}

crates/nxmesh-agent/src/cache/mod.rs

@@ -0,0 +1,3 @@
+//! Local caching
+
+pub mod config_cache;

crates/nxmesh-agent/src/config/mod.rs

@@ -0,0 +1,5 @@
+//! Agent configuration
+
+pub mod settings;
+
+pub use settings::Settings;

crates/nxmesh-agent/src/config/settings.rs

@@ -0,0 +1,80 @@
+//! Agent configuration settings
+
+use config::{Config, ConfigError, Environment, File};
+use serde::{Deserialize, Serialize};
+
+/// Agent settings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Settings {
+    pub agent: AgentSettings,
+    pub master: MasterSettings,
+    pub nginx: NginxSettings,
+}
+
+/// Agent-specific settings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentSettings {
+    pub id: Option<String>,
+    pub name: String,
+    pub labels: std::collections::HashMap<String, String>,
+    pub data_dir: String,
+}
+
+/// Master connection settings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MasterSettings {
+    pub url: String,
+    pub token: String,
+    pub reconnect_interval_seconds: u64,
+}
+
+/// Nginx settings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NginxSettings {
+    pub config_dir: String,
+    pub pid_file: String,
+    pub binary_path: String,
+    pub deployment_mode: String,
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            agent: AgentSettings {
+                id: None,
+                name: hostname::get()
+                    .ok()
+                    .and_then(|h| h.into_string().ok())
+                    .unwrap_or_else(|| "unknown".to_string()),
+                labels: std::collections::HashMap::new(),
+                data_dir: "/var/lib/nxmesh".to_string(),
+            },
+            master: MasterSettings {
+                url: "wss://localhost:8443".to_string(),
+                token: String::new(),
+                reconnect_interval_seconds: 5,
+            },
+            nginx: NginxSettings {
+                config_dir: "/etc/nginx".to_string(),
+                pid_file: "/var/run/nginx.pid".to_string(),
+                binary_path: "/usr/sbin/nginx".to_string(),
+                deployment_mode: "docker_sidecar".to_string(),
+            },
+        }
+    }
+}
+
+impl Settings {
+    /// Load settings from config files and environment
+    pub fn load() -> Result<Self, ConfigError> {
+        let run_mode = std::env::var("RUN_MODE").unwrap_or_else(|_| "development".into());
+
+        let settings = Config::builder()
+            .add_source(File::with_name("/etc/nxmesh/agent").required(false))
+            .add_source(File::with_name(&format!("/etc/nxmesh/agent.{}", run_mode)).required(false))
+            .add_source(Environment::with_prefix("NXMESH_AGENT").separator("__"))
+            .build()?;
+
+        settings.try_deserialize()
+    }
+}

crates/nxmesh-agent/src/health/mod.rs

@@ -0,0 +1,5 @@
+//! Health monitoring
+
+pub mod monitor;
+pub mod nginx;
+pub mod system;

crates/nxmesh-agent/src/health/monitor.rs

@@ -0,0 +1,34 @@
+//! Health monitor
+
+use std::time::Duration;
+use tokio::time::interval;
+
+/// Health monitor
+pub struct HealthMonitor {
+    interval: Duration,
+}
+
+impl HealthMonitor {
+    /// Create a new health monitor
+    pub fn new(interval_secs: u64) -> Self {
+        Self {
+            interval: Duration::from_secs(interval_secs),
+        }
+    }
+
+    /// Start monitoring
+    pub async fn start(&self) {
+        let mut ticker = interval(self.interval);
+
+        loop {
+            ticker.tick().await;
+            self.check_health().await;
+        }
+    }
+
+    /// Check health
+    async fn check_health(&self) {
+        // TODO: Implement health checks
+        tracing::debug!("Checking health status");
+    }
+}

crates/nxmesh-agent/src/health/nginx.rs

@@ -0,0 +1,23 @@
+//! Nginx health checker
+
+/// Nginx health checker
+pub struct NginxHealthChecker;
+
+impl NginxHealthChecker {
+    /// Create a new health checker
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Check nginx health
+    pub async fn check(&self) -> Result<(), String> {
+        // TODO: Implement health check
+        Ok(())
+    }
+}
+
+impl Default for NginxHealthChecker {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/health/system.rs

@@ -0,0 +1,23 @@
+//! System health checker
+
+/// System health checker
+pub struct SystemHealthChecker;
+
+impl SystemHealthChecker {
+    /// Create a new health checker
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Check system health
+    pub async fn check(&self) -> Result<(), String> {
+        // TODO: Implement health check
+        Ok(())
+    }
+}
+
+impl Default for SystemHealthChecker {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/lib.rs

@@ -0,0 +1,30 @@
+//! NxMesh Agent Library
+//!
+//! This crate implements the data plane for NxMesh.
+
+pub mod cache;
+pub mod config;
+pub mod health;
+pub mod master;
+pub mod metrics;
+pub mod nginx;
+pub mod watch;
+
+use config::Settings;
+use tracing::info;
+
+/// Start the agent
+pub async fn start(settings: Settings) -> Result<(), Box<dyn std::error::Error>> {
+    info!("Starting agent with ID: {:?}", settings.agent.id);
+    
+    // TODO: Initialize master client connection
+    // TODO: Start health monitoring
+    // TODO: Start metrics collection
+    // TODO: Initialize nginx controller
+    
+    // For now, just keep running
+    tokio::signal::ctrl_c().await?;
+    info!("Shutting down agent");
+    
+    Ok(())
+}

crates/nxmesh-agent/src/main.rs

@@ -0,0 +1,36 @@
+//! NxMesh Agent - Data Plane
+//!
+//! The agent is a lightweight sidecar that manages local nginx instances
+//! and communicates with the master control plane.
+
+use tracing::{info, error};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize tracing
+    tracing_subscriber::fmt()
+        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+        .init();
+
+    info!("Starting NxMesh Agent v{}", env!("CARGO_PKG_VERSION"));
+
+    // Load configuration
+    let config = match nxmesh_agent::config::Settings::load() {
+        Ok(cfg) => cfg,
+        Err(e) => {
+            error!("Failed to load configuration: {}", e);
+            std::process::exit(1);
+        }
+    };
+
+    info!("Configuration loaded successfully");
+    info!("Master URL: {}", config.master.url);
+
+    // Start the agent
+    if let Err(e) = nxmesh_agent::start(config).await {
+        error!("Agent error: {}", e);
+        std::process::exit(1);
+    }
+
+    Ok(())
+}

crates/nxmesh-agent/src/master/client.rs

@@ -0,0 +1,36 @@
+//! Master gRPC client
+
+use nxmesh_proto::{
+    agent_service_client::AgentServiceClient, AgentMessage, MasterMessage,
+};
+use tonic::transport::Channel;
+
+/// Master client
+pub struct MasterClient {
+    client: AgentServiceClient<Channel>,
+}
+
+impl MasterClient {
+    /// Connect to master
+    pub async fn connect(url: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        let client = AgentServiceClient::connect(url.to_string()).await?;
+        Ok(Self { client })
+    }
+
+    /// Send registration request
+    pub async fn register(
+        &mut self,
+        token: &str,
+    ) -> Result<String, Box<dyn std::error::Error>> {
+        // TODO: Implement registration
+        tracing::info!("Registering with token: {}", token);
+        Ok("agent_id_placeholder".to_string())
+    }
+
+    /// Start bidirectional streaming
+    pub async fn start_stream(&mut self) -> Result<(), Box<dyn std::error::Error>> {
+        // TODO: Implement streaming
+        tracing::info!("Starting bidirectional stream");
+        Ok(())
+    }
+}

crates/nxmesh-agent/src/master/mod.rs

@@ -0,0 +1,5 @@
+//! Master communication
+
+pub mod client;
+pub mod reconnect;
+pub mod stream;

crates/nxmesh-agent/src/master/reconnect.rs

@@ -0,0 +1,79 @@
+//! Reconnection logic
+
+use std::time::Duration;
+use tokio::time::sleep;
+
+/// Reconnection strategy
+pub struct ReconnectStrategy {
+    attempts: u32,
+    max_attempts: u32,
+    base_delay: Duration,
+    max_delay: Duration,
+}
+
+impl Default for ReconnectStrategy {
+    fn default() -> Self {
+        Self {
+            attempts: 0,
+            max_attempts: 10,
+            base_delay: Duration::from_secs(1),
+            max_delay: Duration::from_secs(60),
+        }
+    }
+}
+
+impl ReconnectStrategy {
+    /// Create a new reconnection strategy
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Get next delay before reconnection attempt
+    pub fn next_delay(&mut self) -> Option<Duration> {
+        if self.attempts >= self.max_attempts {
+            return None;
+        }
+
+        let delay = self
+            .base_delay
+            .saturating_mul(2_u32.saturating_pow(self.attempts));
+        let delay = std::cmp::min(delay, self.max_delay);
+
+        self.attempts += 1;
+        Some(delay)
+    }
+
+    /// Reset the strategy after successful connection
+    pub fn reset(&mut self) {
+        self.attempts = 0;
+    }
+}
+
+/// Reconnect with exponential backoff
+pub async fn reconnect_with_backoff<F, Fut>(mut f: F)
+where
+    F: FnMut() -> Fut,
+    Fut: std::future::Future<Output = Result<(), Box<dyn std::error::Error>>>,
+{
+    let mut strategy = ReconnectStrategy::new();
+
+    loop {
+        match f().await {
+            Ok(()) => {
+                strategy.reset();
+                break;
+            }
+            Err(e) => {
+                tracing::error!("Connection failed: {}", e);
+                
+                if let Some(delay) = strategy.next_delay() {
+                    tracing::info!("Retrying in {:?}...", delay);
+                    sleep(delay).await;
+                } else {
+                    tracing::error!("Max reconnection attempts exceeded");
+                    break;
+                }
+            }
+        }
+    }
+}

crates/nxmesh-agent/src/master/stream.rs

@@ -0,0 +1,31 @@
+//! Bidirectional stream handling
+
+use nxmesh_proto::{AgentMessage, MasterMessage};
+
+/// Stream handler
+pub struct StreamHandler;
+
+impl StreamHandler {
+    /// Create a new stream handler
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Handle incoming message from master
+    pub async fn handle_message(&self, msg: MasterMessage) {
+        tracing::info!("Received message from master: {:?}", msg);
+        // TODO: Handle different message types
+    }
+
+    /// Send message to master
+    pub async fn send_message(&self, msg: AgentMessage) {
+        tracing::info!("Sending message to master: {:?}", msg);
+        // TODO: Implement sending
+    }
+}
+
+impl Default for StreamHandler {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/metrics/collector.rs

@@ -0,0 +1,23 @@
+//! Metrics collector
+
+/// Metrics collector
+pub struct MetricsCollector;
+
+impl MetricsCollector {
+    /// Create a new collector
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Collect metrics
+    pub async fn collect(&self) {
+        // TODO: Implement metrics collection
+        tracing::debug!("Collecting metrics");
+    }
+}
+
+impl Default for MetricsCollector {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/metrics/exporter.rs

@@ -0,0 +1,35 @@
+//! Prometheus metrics exporter
+
+use axum::{
+    routing::get,
+    Router,
+};
+
+/// Metrics exporter
+pub struct MetricsExporter;
+
+impl MetricsExporter {
+    /// Create a new exporter
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Get metrics
+    pub async fn get_metrics(&self) -> String {
+        // TODO: Implement metrics export
+        "# HELP nxmesh_agent_uptime_seconds Agent uptime\n".to_string()
+    }
+
+    /// Create router
+    pub fn router(&self) -> Router {
+        Router::new().route("/metrics", get(|| async move {
+            "# HELP nxmesh_agent_uptime_seconds Agent uptime\n"
+        }))
+    }
+}
+
+impl Default for MetricsExporter {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/metrics/mod.rs

@@ -0,0 +1,4 @@
+//! Metrics collection and export
+
+pub mod collector;
+pub mod exporter;

crates/nxmesh-agent/src/nginx/config_manager.rs

@@ -0,0 +1,57 @@
+//! Configuration management with atomic symlink swaps
+
+use std::path::PathBuf;
+
+/// Configuration manager
+pub struct ConfigManager {
+    config_dir: PathBuf,
+}
+
+impl ConfigManager {
+    /// Create a new config manager
+    pub fn new(config_dir: &str) -> Self {
+        Self {
+            config_dir: PathBuf::from(config_dir),
+        }
+    }
+
+    /// Apply new configuration using atomic symlink swap
+    pub async fn apply_config(&self, _config: &str) -> Result<(), Box<dyn std::error::Error>> {
+        let timestamp = chrono::Utc::now().format("%Y%m%d%H%M%S").to_string();
+        let deploy_dir = self.config_dir.join(&timestamp);
+        let symlink_path = self.config_dir.join("current");
+        
+        tracing::info!("Applying configuration to {:?}", deploy_dir);
+        
+        // 1. Create deployment directory
+        tokio::fs::create_dir_all(&deploy_dir).await?;
+        
+        // 2. Write configuration files
+        // TODO: Implement config rendering
+        
+        // 3. Validate configuration
+        // TODO: Run nginx -t
+        
+        // 4. Atomic symlink swap
+        let temp_link = self.config_dir.join("current.tmp");
+        tokio::fs::symlink(&deploy_dir, &temp_link).await?;
+        tokio::fs::rename(&temp_link, &symlink_path).await?;
+        
+        tracing::info!("Configuration applied successfully");
+        Ok(())
+    }
+
+    /// Rollback to previous configuration
+    pub async fn rollback(&self, _target_timestamp: &str) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Rolling back configuration");
+        // TODO: Implement rollback
+        Ok(())
+    }
+
+    /// Clean up old deployment directories
+    pub async fn cleanup(&self, keep_count: usize) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Cleaning up old deployments, keeping {}", keep_count);
+        // TODO: Implement cleanup
+        Ok(())
+    }
+}

crates/nxmesh-agent/src/nginx/config_renderer.rs

@@ -0,0 +1,50 @@
+//! Nginx configuration renderer
+
+use handlebars::Handlebars;
+use serde_json::json;
+
+/// Configuration renderer
+pub struct ConfigRenderer {
+    handlebars: Handlebars<'static>,
+}
+
+impl ConfigRenderer {
+    /// Create a new config renderer
+    pub fn new() -> Self {
+        let mut handlebars = Handlebars::new();
+        
+        // Register built-in templates
+        Self::register_templates(&mut handlebars);
+        
+        Self { handlebars }
+    }
+
+    /// Register built-in templates
+    fn register_templates(handlebars: &mut Handlebars) {
+        // Default reverse proxy template
+        handlebars.register_template_string("default", include_str!("templates/default.hbs")).ok();
+    }
+
+    /// Render configuration
+    pub fn render(&self, template_name: &str, data: &serde_json::Value) -> Result<String, Box<dyn std::error::Error>> {
+        let rendered = self.handlebars.render(template_name, data)?;
+        Ok(rendered)
+    }
+
+    /// Render virtual host
+    pub fn render_virtual_host(&self, vh: &nxmesh_core::models::VirtualHost) -> Result<String, Box<dyn std::error::Error>> {
+        let data = json!({
+            "server_name": vh.server_name,
+            "listen_port": vh.listen_port,
+            "ssl_enabled": vh.ssl_enabled,
+            "locations": vh.locations,
+        });
+        self.render("default", &data)
+    }
+}
+
+impl Default for ConfigRenderer {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/nginx/controller.rs

@@ -0,0 +1,49 @@
+//! Nginx process controller
+
+use super::config_manager::ConfigManager;
+
+/// Nginx controller
+pub struct NginxController {
+    config_manager: ConfigManager,
+    binary_path: String,
+    pid_file: String,
+}
+
+impl NginxController {
+    /// Create a new nginx controller
+    pub fn new(config_dir: &str, binary_path: &str, pid_file: &str) -> Self {
+        Self {
+            config_manager: ConfigManager::new(config_dir),
+            binary_path: binary_path.to_string(),
+            pid_file: pid_file.to_string(),
+        }
+    }
+
+    /// Start nginx
+    pub async fn start(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Starting nginx");
+        // TODO: Implement
+        Ok(())
+    }
+
+    /// Stop nginx
+    pub async fn stop(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Stopping nginx");
+        // TODO: Implement
+        Ok(())
+    }
+
+    /// Reload nginx configuration
+    pub async fn reload(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Reloading nginx configuration");
+        // TODO: Implement
+        Ok(())
+    }
+
+    /// Test nginx configuration
+    pub async fn test_config(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Testing nginx configuration");
+        // TODO: Implement
+        Ok(())
+    }
+}

crates/nxmesh-agent/src/nginx/docker_sidecar.rs

@@ -0,0 +1,25 @@
+//! Docker sidecar mode implementation
+
+/// Docker sidecar controller
+pub struct DockerSidecar;
+
+impl DockerSidecar {
+    /// Create a new docker sidecar controller
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Signal nginx process
+    pub async fn signal_nginx(&self, _signal: &str) -> Result<(), Box<dyn std::error::Error>> {
+        // In Docker sidecar mode, we share PID namespace with nginx container
+        // and can directly signal the nginx process
+        tracing::info!("Sending signal to nginx process");
+        Ok(())
+    }
+}
+
+impl Default for DockerSidecar {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/nginx/mod.rs

@@ -0,0 +1,9 @@
+//! Nginx management
+
+pub mod config_manager;
+pub mod config_renderer;
+pub mod controller;
+pub mod docker_sidecar;
+pub mod parser;
+pub mod systemd;
+pub mod validator;

crates/nxmesh-agent/src/nginx/parser.rs

@@ -0,0 +1,23 @@
+//! Nginx configuration parser
+
+/// Nginx config parser
+pub struct ConfigParser;
+
+impl ConfigParser {
+    /// Create a new parser
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Parse nginx configuration
+    pub fn parse(&self, _content: &str) -> Result<(), String> {
+        // TODO: Implement nginx config parsing
+        Ok(())
+    }
+}
+
+impl Default for ConfigParser {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/nginx/systemd.rs

@@ -0,0 +1,35 @@
+//! Systemd mode implementation
+
+/// Systemd controller
+pub struct SystemdController;
+
+impl SystemdController {
+    /// Create a new systemd controller
+    pub fn new() -> Self {
+        Self
+    }
+
+    /// Start nginx service
+    pub async fn start(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Starting nginx via systemd");
+        Ok(())
+    }
+
+    /// Stop nginx service
+    pub async fn stop(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Stopping nginx via systemd");
+        Ok(())
+    }
+
+    /// Reload nginx service
+    pub async fn reload(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Reloading nginx via systemd");
+        Ok(())
+    }
+}
+
+impl Default for SystemdController {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/nxmesh-agent/src/nginx/templates/default.hbs

@@ -0,0 +1,33 @@
+server {
+    listen {{listen_port}}{{#if ssl_enabled}} ssl{{/if}};
+    server_name {{server_name}};
+
+    {{#if ssl_enabled}}
+    ssl_certificate {{ssl_certificate_path}};
+    ssl_certificate_key {{ssl_certificate_key_path}};
+    {{/if}}
+
+    {{#each locations}}
+    location {{path}} {
+        {{#if proxy_pass}}
+        proxy_pass {{proxy_pass}};
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        {{/if}}
+
+        {{#if root}}
+        root {{root}};
+        {{/if}}
+
+        {{#if index}}
+        index {{index}};
+        {{/if}}
+
+        {{#each custom_headers}}
+        add_header {{name}} "{{value}}"{{#if always}} always{{/if}};
+        {{/each}}
+    }
+    {{/each}}
+}

crates/nxmesh-agent/src/nginx/validator.rs

@@ -0,0 +1,32 @@
+//! Nginx configuration validator
+
+use std::process::Command;
+
+/// Configuration validator
+pub struct ConfigValidator {
+    binary_path: String,
+}
+
+impl ConfigValidator {
+    /// Create a new validator
+    pub fn new(binary_path: &str) -> Self {
+        Self {
+            binary_path: binary_path.to_string(),
+        }
+    }
+
+    /// Validate nginx configuration
+    pub fn validate(&self, config_path: &str) -> Result<(), String> {
+        let output = Command::new(&self.binary_path)
+            .args(&["-t", "-c", config_path])
+            .output()
+            .map_err(|e| format!("Failed to run nginx -t: {}", e))?;
+
+        if output.status.success() {
+            Ok(())
+        } else {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            Err(format!("Configuration validation failed: {}", stderr))
+        }
+    }
+}

crates/nxmesh-agent/src/watch/config_watch.rs

@@ -0,0 +1,24 @@
+//! Configuration file watcher
+
+use std::path::PathBuf;
+
+/// Configuration file watcher
+pub struct ConfigWatcher {
+    watch_path: PathBuf,
+}
+
+impl ConfigWatcher {
+    /// Create a new config watcher
+    pub fn new(watch_path: &str) -> Self {
+        Self {
+            watch_path: PathBuf::from(watch_path),
+        }
+    }
+
+    /// Start watching
+    pub async fn watch(&self) -> Result<(), Box<dyn std::error::Error>> {
+        tracing::info!("Watching configuration at {:?}", self.watch_path);
+        // TODO: Implement file watching
+        Ok(())
+    }
+}

crates/nxmesh-agent/src/watch/mod.rs

@@ -0,0 +1,3 @@
+//! File watchers
+
+pub mod config_watch;