fix: correct USB vs direct-attach detection for Linux video devices

- Add _get_linux_video_connection_type() helper function
- Check sysfs device path ancestry for '/usb' to detect USB devices
- Fallback to checking subsystem symlink target
- Non-USB devices (PCI, platform, virtual) correctly return 'direct'
- Add 3 new tests for Linux video connection type detection

Fixes: Built-in cameras and v4l2loopback devices were incorrectly
labeled as 'usb' because the old logic checked for driver existence
which is true for ALL v4l2 devices, not just USB ones.

Author: iamh2o

marvain_cli/ops.py

@@ -2488,6 +2488,52 @@ class DetectedDevice:
     serial: str | None = None
 
 
+def _get_linux_video_connection_type(video_path: str) -> str:
+    """Determine if a Linux video device is USB or direct-attached.
+
+    Checks the sysfs device path ancestry to determine the bus type.
+    USB devices have '/usb' in their resolved sysfs path.
+
+    Args:
+        video_path: Path to the video device (e.g., /dev/video0)
+
+    Returns:
+        'usb' if the device is connected via USB, 'direct' otherwise
+        (includes PCI, platform, virtual devices like v4l2loopback)
+    """
+    device_name = os.path.basename(video_path)
+    sysfs_device_path = f"/sys/class/video4linux/{device_name}/device"
+
+    try:
+        # Resolve the symlink to get the actual device path in sysfs
+        # USB devices will have paths like:
+        #   /sys/devices/pci0000:00/.../usb1/1-2/1-2:1.0/video4linux/video0
+        # Built-in/PCI cameras will have paths like:
+        #   /sys/devices/pci0000:00/.../0000:00:14.0/video4linux/video0
+        # Platform devices (e.g., Raspberry Pi camera):
+        #   /sys/devices/platform/.../video4linux/video0
+        if os.path.exists(sysfs_device_path):
+            real_path = os.path.realpath(sysfs_device_path)
+            # Check if 'usb' appears in the path hierarchy
+            if "/usb" in real_path:
+                return "usb"
+    except OSError:
+        pass
+
+    # Fallback: check subsystem symlink
+    subsystem_path = f"/sys/class/video4linux/{device_name}/device/subsystem"
+    try:
+        if os.path.islink(subsystem_path):
+            subsystem = os.path.basename(os.path.realpath(subsystem_path))
+            if subsystem == "usb":
+                return "usb"
+    except OSError:
+        pass
+
+    # Default to direct for non-USB devices (PCI, platform, virtual, etc.)
+    return "direct"
+
+
 def detect_local_devices() -> list[DetectedDevice]:
     """Detect USB and direct-attach devices on the local machine.
 
@@ -2568,10 +2614,8 @@ def _detect_video_devices() -> list[DetectedDevice]:
                             name = line.split(":", 1)[-1].strip()
                             break
 
-                # Check if USB device
-                conn_type = "usb" if "usb" in video_path.lower() or os.path.exists(
-                    f"/sys/class/video4linux/{os.path.basename(video_path)}/device/driver"
-                ) else "direct"
+                # Determine connection type by checking sysfs device path ancestry
+                conn_type = _get_linux_video_connection_type(video_path)
 
                 devices.append(
                     DetectedDevice(
@@ -2582,13 +2626,14 @@ def _detect_video_devices() -> list[DetectedDevice]:
                     )
                 )
             except (subprocess.TimeoutExpired, FileNotFoundError):
-                # v4l2-ctl not installed, just add the device path
+                # v4l2-ctl not installed, try to determine connection type anyway
+                conn_type = _get_linux_video_connection_type(video_path)
                 devices.append(
                     DetectedDevice(
                         device_type="video",
                         name=video_path,
                         path=video_path,
-                        connection_type="usb",
+                        connection_type=conn_type,
                     )
                 )
 

tests/test_ops.py

@@ -488,6 +488,58 @@ def test_detect_audio_devices_runs_without_error(self) -> None:
         devices = _detect_audio_devices()
         self.assertIsInstance(devices, list)
 
+    def test_get_linux_video_connection_type_returns_valid_type(self) -> None:
+        """_get_linux_video_connection_type should return 'usb' or 'direct'."""
+        from marvain_cli.ops import _get_linux_video_connection_type
+
+        # Test with a non-existent device path (should return 'direct' as fallback)
+        result = _get_linux_video_connection_type("/dev/video999")
+        self.assertIn(result, ["usb", "direct"])
+
+    def test_get_linux_video_connection_type_usb_path_detection(self) -> None:
+        """_get_linux_video_connection_type should detect USB from sysfs path."""
+        from marvain_cli.ops import _get_linux_video_connection_type
+        import tempfile
+        import os
+
+        # Create a mock sysfs structure with USB in the path
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Mock: /sys/class/video4linux/video0/device -> .../usb1/...
+            video_dir = os.path.join(tmpdir, "sys", "class", "video4linux", "video0")
+            usb_device_dir = os.path.join(tmpdir, "sys", "devices", "pci0000:00", "usb1", "1-2", "1-2:1.0")
+            os.makedirs(video_dir, exist_ok=True)
+            os.makedirs(usb_device_dir, exist_ok=True)
+
+            # Create symlink: video0/device -> usb device path
+            device_link = os.path.join(video_dir, "device")
+            os.symlink(usb_device_dir, device_link)
+
+            # Patch the sysfs base path for testing
+            with mock.patch("marvain_cli.ops.os.path.exists") as mock_exists, \
+                 mock.patch("marvain_cli.ops.os.path.realpath") as mock_realpath:
+                mock_exists.return_value = True
+                # Simulate USB device path
+                mock_realpath.return_value = "/sys/devices/pci0000:00/0000:00:14.0/usb1/1-2/1-2:1.0"
+
+                result = _get_linux_video_connection_type("/dev/video0")
+                self.assertEqual(result, "usb")
+
+    def test_get_linux_video_connection_type_non_usb_path(self) -> None:
+        """_get_linux_video_connection_type should return 'direct' for non-USB devices."""
+        from marvain_cli.ops import _get_linux_video_connection_type
+
+        # Patch to simulate a PCI device (no 'usb' in path)
+        with mock.patch("marvain_cli.ops.os.path.exists") as mock_exists, \
+             mock.patch("marvain_cli.ops.os.path.realpath") as mock_realpath, \
+             mock.patch("marvain_cli.ops.os.path.islink") as mock_islink:
+            mock_exists.return_value = True
+            mock_islink.return_value = False
+            # Simulate PCI device path (no 'usb' in path)
+            mock_realpath.return_value = "/sys/devices/pci0000:00/0000:00:02.0/drm/card0"
+
+            result = _get_linux_video_connection_type("/dev/video0")
+            self.assertEqual(result, "direct")
+
 
 if __name__ == "__main__":
     unittest.main()