chore: sync repository to current working state

Brings azcomputerguru/guru-connect up to the authoritative working copy that
had been maintained in the claudetools monorepo: Phase 1 security and
infrastructure (middleware, metrics, utils, token blacklist, deployment
scripts, security audits) plus the native-remote-control integration spec.
Preserves the repo .gitignore, .cargo, and server/static/downloads.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

agent/src/install.rs

@@ -347,7 +347,7 @@ pub fn is_protocol_handler_registered() -> bool {
 }
 
 /// Parse a guruconnect:// URL and extract session parameters
-pub fn parse_protocol_url(url: &str) -> Result<(String, String, Option<String>)> {
+pub fn parse_protocol_url(url_str: &str) -> Result<(String, String, Option<String>)> {
     // Expected formats:
     // guruconnect://view/SESSION_ID
     // guruconnect://view/SESSION_ID?token=API_KEY
@@ -355,7 +355,7 @@ pub fn parse_protocol_url(url: &str) -> Result<(String, String, Option<String>)>
     //
     // Note: In URL parsing, "view" becomes the host, SESSION_ID is the path
 
-    let url = url::Url::parse(url)
+    let url = url::Url::parse(url_str)
         .map_err(|e| anyhow!("Invalid URL: {}", e))?;
 
     if url.scheme() != "guruconnect" {
@@ -368,8 +368,9 @@ pub fn parse_protocol_url(url: &str) -> Result<(String, String, Option<String>)>
 
     // The session ID is the first path segment
     let path = url.path().trim_start_matches('/');
+    info!("URL path: '{}', host: '{:?}'", path, url.host_str());
     let session_id = if path.is_empty() {
-        return Err(anyhow!("Missing session ID"));
+        return Err(anyhow!("Invalid URL: Missing session ID (path was empty, full URL: {})", url_str));
     } else {
         path.split('/').next().unwrap_or("").to_string()
     };

agent/src/session/mod.rs

@@ -120,32 +120,72 @@ impl SessionManager {
         }
 
         tracing::info!("Initializing streaming resources...");
+        tracing::info!("Capture config: use_dxgi={}, gdi_fallback={}, fps={}",
+            self.config.capture.use_dxgi, self.config.capture.gdi_fallback, self.config.capture.fps);
 
-        // Get primary display
-        let primary_display = capture::primary_display()?;
+        // Get primary display with panic protection
+        tracing::debug!("Enumerating displays...");
+        let primary_display = match std::panic::catch_unwind(|| capture::primary_display()) {
+            Ok(result) => result?,
+            Err(e) => {
+                tracing::error!("Panic during display enumeration: {:?}", e);
+                return Err(anyhow::anyhow!("Display enumeration panicked"));
+            }
+        };
         tracing::info!("Using display: {} ({}x{})",
             primary_display.name, primary_display.width, primary_display.height);
 
-        // Create capturer
-        let capturer = capture::create_capturer(
-            primary_display.clone(),
-            self.config.capture.use_dxgi,
-            self.config.capture.gdi_fallback,
-        )?;
+        // Create capturer with panic protection
+        // Force GDI mode if DXGI fails or panics
+        tracing::debug!("Creating capturer (DXGI={})...", self.config.capture.use_dxgi);
+        let capturer = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            capture::create_capturer(
+                primary_display.clone(),
+                self.config.capture.use_dxgi,
+                self.config.capture.gdi_fallback,
+            )
+        })) {
+            Ok(result) => result?,
+            Err(e) => {
+                tracing::error!("Panic during capturer creation: {:?}", e);
+                // Try GDI-only as last resort
+                tracing::warn!("Attempting GDI-only capture after DXGI panic...");
+                capture::create_capturer(primary_display.clone(), false, false)?
+            }
+        };
         self.capturer = Some(capturer);
+        tracing::info!("Capturer created successfully");
 
-        // Create encoder
-        let encoder = encoder::create_encoder(
-            &self.config.encoding.codec,
-            self.config.encoding.quality,
-        )?;
+        // Create encoder with panic protection
+        tracing::debug!("Creating encoder (codec={}, quality={})...",
+            self.config.encoding.codec, self.config.encoding.quality);
+        let encoder = match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            encoder::create_encoder(
+                &self.config.encoding.codec,
+                self.config.encoding.quality,
+            )
+        })) {
+            Ok(result) => result?,
+            Err(e) => {
+                tracing::error!("Panic during encoder creation: {:?}", e);
+                return Err(anyhow::anyhow!("Encoder creation panicked"));
+            }
+        };
         self.encoder = Some(encoder);
+        tracing::info!("Encoder created successfully");
 
-        // Create input controller
-        let input = InputController::new()?;
+        // Create input controller with panic protection
+        tracing::debug!("Creating input controller...");
+        let input = match std::panic::catch_unwind(InputController::new) {
+            Ok(result) => result?,
+            Err(e) => {
+                tracing::error!("Panic during input controller creation: {:?}", e);
+                return Err(anyhow::anyhow!("Input controller creation panicked"));
+            }
+        };
         self.input = Some(input);
 
-        tracing::info!("Streaming resources initialized");
+        tracing::info!("Streaming resources initialized successfully");
         Ok(())
     }