Add IPFS HLS streaming and GPU optimizations

- Add IPFSHLSOutput class that uploads segments to IPFS as they're created
- Update streaming task to use IPFS HLS output for distributed streaming
- Add /ipfs-stream endpoint to get IPFS playlist URL
- Update /stream endpoint to redirect to IPFS when available
- Add GPU persistence mode (STREAMING_GPU_PERSIST=1) to keep frames on GPU
- Add hardware video decoding (NVDEC) support for faster video processing
- Add GPU-accelerated primitive libraries: blending_gpu, color_ops_gpu, geometry_gpu
- Add streaming_gpu module with GPUFrame class for tracking CPU/GPU data location
- Add Dockerfile.gpu for building GPU-enabled worker image

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

app/services/cache_service.py

@@ -100,30 +100,52 @@ class CacheService:
 
     async def get_cache_item(self, cid: str, actor_id: str = None) -> Optional[Dict[str, Any]]:
         """Get cached item with full metadata for display."""
-        # Check if content exists
-        if not self.cache.has_content(cid):
-            return None
-
-        path = self.cache.get_by_cid(cid)
-        if not path or not path.exists():
-            return None
-
-        # Get metadata from database
+        # Get metadata from database first
         meta = await self.db.load_item_metadata(cid, actor_id)
         cache_item = await self.db.get_cache_item(cid)
 
-        media_type = detect_media_type(path)
-        mime_type = get_mime_type(path)
-        size = path.stat().st_size
+        # Check if content exists locally
+        path = self.cache.get_by_cid(cid) if self.cache.has_content(cid) else None
+
+        if path and path.exists():
+            # Local file exists - detect type from file
+            media_type = detect_media_type(path)
+            mime_type = get_mime_type(path)
+            size = path.stat().st_size
+        else:
+            # File not local - check database for type info
+            # Try to get type from item_types table
+            media_type = "unknown"
+            mime_type = "application/octet-stream"
+            size = 0
+
+            if actor_id:
+                try:
+                    item_types = await self.db.get_item_types(cid, actor_id)
+                    if item_types:
+                        media_type = item_types[0].get("type", "unknown")
+                        if media_type == "video":
+                            mime_type = "video/mp4"
+                        elif media_type == "image":
+                            mime_type = "image/png"
+                        elif media_type == "audio":
+                            mime_type = "audio/mpeg"
+                except Exception:
+                    pass
+
+            # If no local path but we have IPFS CID, content is available remotely
+            if not cache_item:
+                return None
 
         result = {
             "cid": cid,
-            "path": str(path),
+            "path": str(path) if path else None,
             "media_type": media_type,
             "mime_type": mime_type,
             "size": size,
             "ipfs_cid": cache_item.get("ipfs_cid") if cache_item else None,
             "meta": meta,
+            "remote_only": path is None or not path.exists(),
         }
 
         # Unpack meta fields to top level for template convenience