@agentsdock/server 1.0.7-beta.5 → 1.0.8-beta.2

package/server/shared_chat_video_stream.py

@@ -18,6 +18,7 @@ from starlette.responses import Response, StreamingResponse
 
 
 VIDEO_CONTENT_TYPES = frozenset({"video/mp4", "video/webm", "video/quicktime", "video/ogg"})
+IMAGE_CONTENT_TYPES = frozenset({"image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp"})
 VIDEO_CHUNK_BYTES = 64 * 1024
 REAUTHORIZE_INTERVAL_SECONDS = 1.0
 _RANGE = re.compile(r"bytes=([0-9]*)-([0-9]*)", re.IGNORECASE)
@@ -106,6 +107,9 @@ class SharedVideoResponse(StreamingResponse):
     at construction, before headers, and before/after every bounded read.
     """
 
+    content_types = VIDEO_CONTENT_TYPES
+    disposition = "inline"
+
     def __init__(self, fd, *, byte_size, content_type, filename, request,
                  reauthorize=None, extra_headers=None, admission=None, file_revision=None):
         self._fd = fd
@@ -113,7 +117,9 @@ class SharedVideoResponse(StreamingResponse):
         self._called = False
         try:
             if (type(fd) is not int or fd < 0 or type(byte_size) is not int
-                    or byte_size < 0 or content_type not in VIDEO_CONTENT_TYPES):
+                    or byte_size < 0 or not isinstance(content_type, str)
+                    or re.fullmatch(r"[a-zA-Z0-9!#$&^_.+-]+/[a-zA-Z0-9!#$&^_.+-]+", content_type) is None
+                    or (self.content_types is not None and content_type not in self.content_types)):
                 raise ValueError("Invalid shared video")
             info = os.fstat(fd)
             if not stat.S_ISREG(info.st_mode) or info.st_size != byte_size:
@@ -149,7 +155,7 @@ class SharedVideoResponse(StreamingResponse):
                     headers["content-range"] = f"bytes */{byte_size}"
                 else:
                     headers["content-type"] = content_type
-                    headers["content-disposition"] = "inline; filename*=UTF-8''" + quote(filename, safe="")
+                    headers["content-disposition"] = self.disposition + "; filename*=UTF-8''" + quote(filename, safe="")
                     if status == 206:
                         headers["content-range"] = f"bytes {self._start}-{self._start + self._length - 1}/{byte_size}"
             headers["content-length"] = str(self._length)
@@ -260,3 +266,16 @@ class SharedVideoResponse(StreamingResponse):
             self.close()
             if admitted:
                 self._admission.release()
+
+
+class SharedFileResponse(SharedVideoResponse):
+    """Download any registered attachment using the same descriptor lifecycle."""
+
+    content_types = None
+    disposition = "attachment"
+
+
+class SharedImageResponse(SharedVideoResponse):
+    """Only raster images are embedded at the shared chat's origin."""
+
+    content_types = IMAGE_CONTENT_TYPES

package/server/shared_chat_videos.py

@@ -1,6 +1,6 @@
-"""Read-only, signed references to videos already published in one chat.
+"""Read-only, signed references to attachments already published in one chat.
 
-No workspace paths, file discovery, registry writes, or video copies. Capabilities
+No workspace paths, file discovery, registry writes, or file copies. Capabilities
 pin the registered copy's metadata and inode revision; changed files fail closed.
 """
 from __future__ import annotations
@@ -9,6 +9,7 @@ import base64
 import hashlib
 import hmac
 import json
+import mimetypes
 import os
 from pathlib import Path
 import re
@@ -16,6 +17,8 @@ import stat
 
 VIDEO_TYPES = frozenset({"video/mp4", "video/webm", "video/quicktime", "video/ogg"})
 VIDEO_ID = re.compile(r"video_[A-Za-z0-9_-]+\.[a-f0-9]{64}\Z")
+SHARED_FILE_ID = re.compile(r"shared_file_[A-Za-z0-9_-]+\.[a-f0-9]{64}\Z")
+CONTENT_TYPE = re.compile(r"[a-zA-Z0-9!#$&^_.+-]+/[a-zA-Z0-9!#$&^_.+-]+\Z")
 FILE_ID = re.compile(r"(?:file|art)_[a-f0-9]{16,32}\Z")
 SESSION_ID = re.compile(r"[A-Za-z0-9_-]{1,128}\Z")
 EXTENSIONS = {".mp4": "video/mp4", ".m4v": "video/mp4", ".webm": "video/webm",
@@ -27,28 +30,38 @@ class SharedVideoUnavailable(ValueError):
         super().__init__("Shared video is unavailable")
 
 
-def normalize_shared_chat_videos(value):
-    if not isinstance(value, list) or len(value) > 32:
+def _normalize_shared_chat_files(value, *, videos):
+    if not isinstance(value, list):
         raise ValueError("Invalid shared videos")
     output, seen = [], set()
     for item in value:
         if not isinstance(item, dict) or set(item) != {"id", "filename", "content_type", "size"}:
             raise ValueError("Invalid shared video")
         identity, name = item["id"], item["filename"]
-        if (not isinstance(identity, str) or len(identity) > 1024 or VIDEO_ID.fullmatch(identity) is None
+        pattern = VIDEO_ID if videos else SHARED_FILE_ID
+        if (not isinstance(identity, str) or len(identity) > 1024 or pattern.fullmatch(identity) is None
                 or identity in seen or not isinstance(name, str) or not 1 <= len(name) <= 255
                 or name in {".", ".."} or any(ord(c) < 32 or ord(c) == 127 or c in "/\\" for c in name)
-                or len(name.encode("utf-8")) > 1024 or not isinstance(item["content_type"], str) or item["content_type"] not in VIDEO_TYPES
-                or type(item["size"]) is not int or not 0 < item["size"] <= (1 << 53) - 1):
+                or len(name.encode("utf-8")) > 1024 or not isinstance(item["content_type"], str)
+                or (item["content_type"] not in VIDEO_TYPES if videos else CONTENT_TYPE.fullmatch(item["content_type"]) is None)
+                or type(item["size"]) is not int or not (1 if videos else 0) <= item["size"] <= (1 << 53) - 1):
             raise ValueError("Invalid shared video")
         output.append(dict(item)); seen.add(identity)
     return output
 
 
-def _key(secret):
+def normalize_shared_chat_videos(value):
+    return _normalize_shared_chat_files(value, videos=True)
+
+
+def normalize_shared_chat_files(value):
+    return _normalize_shared_chat_files(value, videos=False)
+
+
+def _key(secret, *, videos=True):
     if not isinstance(secret, str) or not secret:
         raise SharedVideoUnavailable()
-    return hmac.new(secret.encode("utf-8"), b"agentsdock-chat-video-v1", hashlib.sha256).digest()
+    return hmac.new(secret.encode("utf-8"), b"agentsdock-chat-video-v1" if videos else b"agentsdock-chat-file-v1", hashlib.sha256).digest()
 
 
 def _regular(info, owner):
@@ -56,7 +69,7 @@ def _regular(info, owner):
         raise SharedVideoUnavailable()
 
 
-def _open_registered(root, session_id, file_id, *, legacy_owner=False):
+def _open_registered(root, session_id, file_id, *, legacy_owner=False, videos=True):
     """Open through pinned directories; return an owned FD, never reopen a path."""
     if (not isinstance(session_id, str) or SESSION_ID.fullmatch(session_id) is None
             or not isinstance(file_id, str) or FILE_ID.fullmatch(file_id) is None):
@@ -91,16 +104,16 @@ def _open_registered(root, session_id, file_id, *, legacy_owner=False):
                 or any(ord(c) < 32 or ord(c) == 127 or c in "/\\" for c in name)
                 or len(name.encode("utf-8")) > 1024 or meta.get("path") != str(root / file_id / name)):
             raise SharedVideoUnavailable()
-        guessed = EXTENSIONS.get(Path(name).suffix.lower())
+        guessed = EXTENSIONS.get(Path(name).suffix.lower()) if videos else mimetypes.guess_type(name)[0]
         mime = str(meta.get("content_type") or "").split(";", 1)[0].strip().lower()
         if mime in {"", "application/octet-stream", "binary/octet-stream"}:
-            mime = guessed
-        if mime not in VIDEO_TYPES or mime != guessed:
+            mime = guessed or "application/octet-stream"
+        if (videos and (mime not in VIDEO_TYPES or mime != guessed)) or CONTENT_TYPE.fullmatch(mime) is None:
             raise SharedVideoUnavailable()
         video_fd = os.open(name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=directory_fd)
         info = os.fstat(video_fd)
         _regular(info, owner)
-        if type(meta.get("size")) is not int or meta["size"] != info.st_size or not 0 < info.st_size <= (1 << 53) - 1:
+        if type(meta.get("size")) is not int or meta["size"] != info.st_size or not (1 if videos else 0) <= info.st_size <= (1 << 53) - 1:
             raise SharedVideoUnavailable()
         revision = hashlib.sha256(json.dumps([name, mime, meta.get("session_id"), info.st_dev, info.st_ino,
             info.st_size, info.st_mtime_ns, info.st_ctime_ns, info.st_uid, info.st_mode],
@@ -118,32 +131,41 @@ def _open_registered(root, session_id, file_id, *, legacy_owner=False):
                 os.close(fd)
 
 
-def shared_chat_video_descriptor(root, secret, session_id, file_id, *, legacy_owner=False):
-    key = _key(secret)
-    opened = _open_registered(root, session_id, file_id, legacy_owner=legacy_owner)
+def _shared_chat_descriptor(root, secret, session_id, file_id, *, legacy_owner=False, videos=True):
+    key = _key(secret, videos=videos)
+    opened = _open_registered(root, session_id, file_id, legacy_owner=legacy_owner, videos=videos)
     try:
         payload = json.dumps([1, session_id, file_id, opened["revision"]], separators=(",", ":")).encode("ascii")
         encoded = base64.urlsafe_b64encode(payload).rstrip(b"=").decode("ascii")
-        identity = "video_" + encoded + "." + hmac.new(key, encoded.encode("ascii"), hashlib.sha256).hexdigest()
-        return normalize_shared_chat_videos([{key: opened[key] for key in ("filename", "content_type", "size")} | {"id": identity}])[0]
+        identity = ("video_" if videos else "shared_file_") + encoded + "." + hmac.new(key, encoded.encode("ascii"), hashlib.sha256).hexdigest()
+        return _normalize_shared_chat_files([{key: opened[key] for key in ("filename", "content_type", "size")} | {"id": identity}], videos=videos)[0]
     finally:
         os.close(opened["file_fd"])
 
 
-def open_shared_chat_video(root, secret, session_id, identity):
+def shared_chat_video_descriptor(root, secret, session_id, file_id, *, legacy_owner=False):
+    return _shared_chat_descriptor(root, secret, session_id, file_id, legacy_owner=legacy_owner)
+
+
+def shared_chat_file_descriptor(root, secret, session_id, file_id, *, legacy_owner=False):
+    return _shared_chat_descriptor(root, secret, session_id, file_id, legacy_owner=legacy_owner, videos=False)
+
+
+def _open_shared_chat_file(root, secret, session_id, identity, *, videos):
     opened = None
     try:
-        if not isinstance(identity, str) or len(identity) > 1024 or VIDEO_ID.fullmatch(identity) is None:
+        pattern = VIDEO_ID if videos else SHARED_FILE_ID
+        if not isinstance(identity, str) or len(identity) > 1024 or pattern.fullmatch(identity) is None:
             raise SharedVideoUnavailable()
-        encoded, signature = identity[len("video_"):].split(".")
-        expected = hmac.new(_key(secret), encoded.encode("ascii"), hashlib.sha256).hexdigest()
+        encoded, signature = identity[len("video_" if videos else "shared_file_"):].split(".")
+        expected = hmac.new(_key(secret, videos=videos), encoded.encode("ascii"), hashlib.sha256).hexdigest()
         if not hmac.compare_digest(signature, expected):
             raise SharedVideoUnavailable()
         payload = json.loads(base64.b64decode(encoded + "=" * (-len(encoded) % 4), altchars=b"-_", validate=True))
         if (not isinstance(payload, list) or len(payload) != 4 or type(payload[0]) is not int or payload[0] != 1
                 or payload[1] != session_id or not isinstance(payload[3], str)):
             raise SharedVideoUnavailable()
-        opened = _open_registered(root, session_id, payload[2], legacy_owner=True)
+        opened = _open_registered(root, session_id, payload[2], legacy_owner=True, videos=videos)
         if not hmac.compare_digest(opened.pop("revision"), payload[3]):
             raise SharedVideoUnavailable()
         result, opened = opened, None
@@ -153,3 +175,11 @@ def open_shared_chat_video(root, secret, session_id, identity):
     finally:
         if opened is not None:
             os.close(opened["file_fd"])
+
+
+def open_shared_chat_video(root, secret, session_id, identity):
+    return _open_shared_chat_file(root, secret, session_id, identity, videos=True)
+
+
+def open_shared_chat_file(root, secret, session_id, identity):
+    return _open_shared_chat_file(root, secret, session_id, identity, videos=False)