Add VPN configuration tools and agent documentation

Created comprehensive VPN setup tooling for Peaceful Spirit L2TP/IPsec connection
and enhanced agent documentation framework.

VPN Configuration (PST-NW-VPN):
- Setup-PST-L2TP-VPN.ps1: Automated L2TP/IPsec setup with split-tunnel and DNS
- Connect-PST-VPN.ps1: Connection helper with PPP adapter detection, DNS (192.168.0.2), and route config (192.168.0.0/24)
- Connect-PST-VPN-Standalone.ps1: Self-contained connection script for remote deployment
- Fix-PST-VPN-Auth.ps1: Authentication troubleshooting for CHAP/MSChapv2
- Diagnose-VPN-Interface.ps1: Comprehensive VPN interface and routing diagnostic
- Quick-Test-VPN.ps1: Fast connectivity verification (DNS/router/routes)
- Add-PST-VPN-Route-Manual.ps1: Manual route configuration helper
- vpn-connect.bat, vpn-disconnect.bat: Simple batch file shortcuts
- OpenVPN config files (Windows-compatible, abandoned for L2TP)

Key VPN Implementation Details:
- L2TP creates PPP adapter with connection name as interface description
- UniFi auto-configures DNS (192.168.0.2) but requires manual route to 192.168.0.0/24
- Split-tunnel enabled (only remote traffic through VPN)
- All-user connection for pre-login auto-connect via scheduled task
- Authentication: CHAP + MSChapv2 for UniFi compatibility

Agent Documentation:
- AGENT_QUICK_REFERENCE.md: Quick reference for all specialized agents
- documentation-squire.md: Documentation and task management specialist agent
- Updated all agent markdown files with standardized formatting

Project Organization:
- Moved conversation logs to dedicated directories (guru-connect-conversation-logs, guru-rmm-conversation-logs)
- Cleaned up old session JSONL files from projects/msp-tools/
- Added guru-connect infrastructure (agent, dashboard, proto, scripts, .gitea workflows)
- Added guru-rmm server components and deployment configs

Technical Notes:
- VPN IP pool: 192.168.4.x (client gets 192.168.4.6)
- Remote network: 192.168.0.0/24 (router at 192.168.0.10)
- PSK: rrClvnmUeXEFo90Ol+z7tfsAZHeSK6w7
- Credentials: pst-admin / 24Hearts$

Files: 15 VPN scripts, 2 agent docs, conversation log reorganization,
guru-connect/guru-rmm infrastructure additions

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

projects/msp-tools/guru-rmm/agent/src/device_id.rs

@@ -0,0 +1,213 @@
+//! Device ID generation
+//!
+//! Provides a stable, unique identifier for each machine that:
+//! - Survives agent reinstalls
+//! - Is hardware-derived when possible
+//! - Falls back to a persisted UUID if hardware IDs are unavailable
+
+use anyhow::Result;
+use std::fs;
+use std::path::PathBuf;
+use tracing::{debug, info, warn};
+
+/// Get the device ID for this machine
+///
+/// Priority:
+/// 1. Hardware-based ID (MachineGuid on Windows, machine-id on Linux)
+/// 2. Previously persisted ID
+/// 3. Generate and persist a new UUID
+pub fn get_device_id() -> String {
+    // Try hardware-based ID first
+    if let Some(id) = get_hardware_device_id() {
+        debug!("Using hardware-based device ID");
+        return id;
+    }
+
+    // Try to read a persisted ID
+    let persist_path = get_persist_path();
+    if let Some(id) = read_persisted_id(&persist_path) {
+        debug!("Using persisted device ID from {:?}", persist_path);
+        return id;
+    }
+
+    // Generate and persist a new ID
+    let new_id = generate_device_id();
+    info!("Generated new device ID, persisting to {:?}", persist_path);
+    if let Err(e) = persist_device_id(&persist_path, &new_id) {
+        warn!("Failed to persist device ID: {}", e);
+    }
+
+    new_id
+}
+
+/// Generate a new device ID (UUID v4)
+fn generate_device_id() -> String {
+    uuid::Uuid::new_v4().to_string()
+}
+
+/// Get the path where device ID should be persisted
+fn get_persist_path() -> PathBuf {
+    #[cfg(target_os = "windows")]
+    {
+        // %ProgramData%\GuruRMM\.device-id
+        let program_data = std::env::var("ProgramData")
+            .unwrap_or_else(|_| "C:\\ProgramData".to_string());
+        PathBuf::from(program_data).join("GuruRMM").join(".device-id")
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    {
+        // /var/lib/gururmm/.device-id
+        PathBuf::from("/var/lib/gururmm/.device-id")
+    }
+}
+
+/// Read a persisted device ID from disk
+fn read_persisted_id(path: &PathBuf) -> Option<String> {
+    fs::read_to_string(path)
+        .ok()
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty() && s.len() < 100)
+}
+
+/// Persist device ID to disk
+fn persist_device_id(path: &PathBuf, id: &str) -> Result<()> {
+    // Create parent directory if needed
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent)?;
+    }
+    fs::write(path, id)?;
+    Ok(())
+}
+
+/// Get hardware-based device ID
+#[cfg(target_os = "windows")]
+fn get_hardware_device_id() -> Option<String> {
+    // Try MachineGuid from registry
+    // HKLM\SOFTWARE\Microsoft\Cryptography\MachineGuid
+    use std::process::Command;
+
+    let output = Command::new("reg")
+        .args([
+            "query",
+            "HKLM\\SOFTWARE\\Microsoft\\Cryptography",
+            "/v",
+            "MachineGuid",
+        ])
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        return None;
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Parse the output: "MachineGuid    REG_SZ    <guid>"
+    for line in stdout.lines() {
+        if line.contains("MachineGuid") {
+            let parts: Vec<&str> = line.split_whitespace().collect();
+            if parts.len() >= 3 {
+                let guid = parts.last()?.trim();
+                if !guid.is_empty() && guid.len() > 20 {
+                    return Some(format!("win-{}", guid));
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Get hardware-based device ID
+#[cfg(target_os = "linux")]
+fn get_hardware_device_id() -> Option<String> {
+    // Try /etc/machine-id first (systemd)
+    if let Ok(id) = fs::read_to_string("/etc/machine-id") {
+        let id = id.trim();
+        if !id.is_empty() && id.len() >= 32 {
+            return Some(format!("linux-{}", id));
+        }
+    }
+
+    // Try /var/lib/dbus/machine-id (older systems)
+    if let Ok(id) = fs::read_to_string("/var/lib/dbus/machine-id") {
+        let id = id.trim();
+        if !id.is_empty() && id.len() >= 32 {
+            return Some(format!("linux-{}", id));
+        }
+    }
+
+    // Try SMBIOS product UUID (requires root usually)
+    if let Ok(id) = fs::read_to_string("/sys/class/dmi/id/product_uuid") {
+        let id = id.trim();
+        if !id.is_empty() && id.len() > 20 {
+            return Some(format!("hw-{}", id));
+        }
+    }
+
+    None
+}
+
+/// Get hardware-based device ID
+#[cfg(target_os = "macos")]
+fn get_hardware_device_id() -> Option<String> {
+    use std::process::Command;
+
+    // Try IOPlatformUUID
+    let output = Command::new("ioreg")
+        .args(["-rd1", "-c", "IOPlatformExpertDevice"])
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        return None;
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Parse: "IOPlatformUUID" = "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX"
+    for line in stdout.lines() {
+        if line.contains("IOPlatformUUID") {
+            if let Some(start) = line.find('"') {
+                let rest = &line[start + 1..];
+                if let Some(end) = rest.find('"') {
+                    let uuid = &rest[..end];
+                    // Skip the first quote if double-quoted
+                    let uuid = uuid.trim_start_matches('"');
+                    if !uuid.is_empty() && uuid.len() > 20 {
+                        return Some(format!("mac-{}", uuid));
+                    }
+                }
+            }
+        }
+    }
+
+    None
+}
+
+/// Fallback for unsupported platforms
+#[cfg(not(any(target_os = "windows", target_os = "linux", target_os = "macos")))]
+fn get_hardware_device_id() -> Option<String> {
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_device_id() {
+        let id = get_device_id();
+        assert!(!id.is_empty());
+        println!("Device ID: {}", id);
+    }
+
+    #[test]
+    fn test_generate_device_id() {
+        let id1 = generate_device_id();
+        let id2 = generate_device_id();
+        assert_ne!(id1, id2);
+        assert!(id1.len() >= 32);
+    }
+}