session_hosted_attachments.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244
  1. """Owner-authorized room byte RPCs and committed task input materialization."""
  2. import base64
  3. import binascii
  4. import os
  5. from pathlib import Path
  6. import tempfile
  7. from gateway.hosted_room_attachments import HostedRoomAttachmentStore, MAX_ATTACHMENT_BYTES
  8. from gateway.session_ingress_media import HOSTED_DOCUMENT_LINE
  9. from hermes_state_runtime import RuntimeStoreError
  10. def _authorize(service, actor, params, capability):
  11. if actor.profile_id != service.authority.profile_id:
  12. raise RuntimeStoreError('profile_mismatch')
  13. if capability not in actor.capabilities:
  14. raise RuntimeStoreError('permission_denied')
  15. room_id = params.get('room_id')
  16. service.authorize_room(actor.subject, room_id)
  17. service._owned_authority(room_id)
  18. service._room(room_id)
  19. return room_id
  20. def upload(service, actor, params):
  21. return store_upload(service, _authorize(service, actor, params, 'session:submit'), params)
  22. def download(service, actor, params):
  23. return read_download(service, _authorize(service, actor, params, 'session:read'), params)
  24. def store_upload(service, room_id, params):
  25. """Retain one composer file for a later ``groups.send`` manifest (both routes)."""
  26. encoded = params.get('data_base64')
  27. if not isinstance(encoded, str) or len(encoded) > ((MAX_ATTACHMENT_BYTES + 2) // 3) * 4:
  28. raise RuntimeStoreError('invalid_params')
  29. try:
  30. data = base64.b64decode(encoded, validate=True)
  31. except (ValueError, binascii.Error) as exc:
  32. raise RuntimeStoreError('invalid_params') from exc
  33. return HostedRoomAttachmentStore(service.db_path).put(
  34. room_id=room_id, upload_id=params.get('upload_id'), kind=params.get('kind'),
  35. name=params.get('name'), mime=params.get('mime'), data=data)
  36. def read_download(service, room_id, params):
  37. """One committed file for a live room viewer (both routes)."""
  38. if not params.get('event_id'):
  39. raise RuntimeStoreError('invalid_params')
  40. gateway_id, epoch = service._owned_authority(room_id)
  41. saved = HostedRoomAttachmentStore(service.db_path).read_viewer(
  42. room_id=room_id, attachment_id=params.get('attachment_id'), event_id=params['event_id'],
  43. authority_gateway_id=gateway_id, authority_epoch=epoch)
  44. return {**saved.attachment, 'data_base64': base64.b64encode(saved.data).decode('ascii')}
  45. def append_user_event(service, *, room_id, event_id, payload, gateway_id, epoch):
  46. from gateway import hosted_rooms
  47. store = HostedRoomAttachmentStore(service.db_path)
  48. manifest = payload.get('attachments', [])
  49. transitioned = []
  50. if manifest:
  51. _, transitioned = store.commit_message_with_receipt(
  52. room_id=room_id, event_id=event_id, manifest=manifest,
  53. recipient_member_ids=[m['member_id'] for m in service._room(room_id)['members']],
  54. viewer_access=True, hold_until_event=True)
  55. try:
  56. return hosted_rooms.append_event(
  57. service.db_path, room_id=room_id, event_id=event_id, kind='message.user',
  58. actor={'kind': 'user', 'id': 'desktop'}, payload=payload,
  59. authority_gateway_id=gateway_id, authority_epoch=epoch)
  60. except Exception:
  61. if transitioned:
  62. store.abort_message_commit(room_id=room_id, event_id=event_id, attachment_ids=transitioned)
  63. raise
  64. # A file the member can never take: over its media cap, not bound to it, expired or corrupt.
  65. _PERMANENT_FILE_REFUSALS = frozenset({'invalid_params', 'permission_denied'})
  66. def prepare_before_submit(prepare):
  67. """Run a member turn's file preparation, which precedes its ``prompt.submit``/admission.
  68. A failure here started no work, so neither route may let the driver book it as uncertain
  69. execution: a refusal no retry can change settles the turn as failed (``refused_before_submit``)
  70. and anything else is proven not admitted, so the driver requeues it with backoff."""
  71. from gateway.hosted_room_attachments import AttachmentError
  72. from gateway.hosted_room_driver import DriverValidationError
  73. try:
  74. return prepare()
  75. except Exception as exc:
  76. permanent = isinstance(exc, (AttachmentError, DriverValidationError)) or (
  77. isinstance(exc, RuntimeStoreError) and exc.reason in _PERMANENT_FILE_REFUSALS)
  78. if permanent:
  79. exc.refused_before_submit = True
  80. else:
  81. exc.not_admitted = True
  82. raise
  83. def submission_payload(rpc, prompt, attachments=None):
  84. """Resolve only event-bound, member-authorized bytes, never a caller path."""
  85. return bound_submission_payload(
  86. rpc.authority.db.db_path, room_id=rpc.room_id, member_id=rpc.member_id, prompt=prompt,
  87. attachments=attachments, transferred=getattr(rpc, 'hosted_attachment_data', None))
  88. def bound_submission_payload(db_path, *, room_id, member_id, prompt, attachments=None, transferred=None):
  89. """``{'text', 'attachments'?}`` for one member turn: documents as prompt path lines, images as
  90. owner-local staging paths. Shared by both routes, so a file reaches a member identically."""
  91. if not attachments:
  92. return {'text': prompt}
  93. from gateway.hosted_room_driver import validate_bound_task_manifest
  94. from gateway.session_ingress_media import capture_native_media, restore_native_media, validate_media_batch_size
  95. manifest = validate_bound_task_manifest(attachments)
  96. # Each bound file is captured on its own, so the admission-wide cap is enforced here,
  97. # before any member is materialized.
  98. validate_media_batch_size(item['size'] for item in manifest)
  99. store = HostedRoomAttachmentStore(db_path)
  100. references = []
  101. if transferred is not None and [item for item, data in transferred] != manifest:
  102. raise RuntimeStoreError('permission_denied')
  103. for index, item in enumerate(manifest):
  104. if transferred is None:
  105. saved = store.read(room_id=room_id, attachment_id=item['attachment_id'],
  106. event_id=item['event_id'], recipient_member_id=member_id)
  107. if any(saved.attachment[key] != item[key] for key in ('kind', 'name', 'mime', 'size')):
  108. raise RuntimeStoreError('permission_denied')
  109. data = saved.data
  110. else:
  111. data = transferred[index][1]
  112. if len(data) != item['size']:
  113. raise RuntimeStoreError('permission_denied')
  114. # Retained native-inputs are excluded from age-only document cleanup; a live hosted row
  115. # holds its documents through the prompt path lines (``hosted_document_references``).
  116. # The content-addressed destination is stable on retry and refuses corruption.
  117. with tempfile.TemporaryDirectory(prefix='hermes-room-input-') as directory:
  118. path = Path(directory) / item['name']
  119. fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
  120. with os.fdopen(fd, 'wb') as output:
  121. output.write(data)
  122. reference = capture_native_media([path])[0]
  123. references.append(reference)
  124. paths = restore_native_media(references)
  125. from gateway.session_ingress_media import _ATTACHMENT_MIMES
  126. from gateway.platforms.base import get_image_cache_dir
  127. import hashlib
  128. images, documents = [], []
  129. for path, item in zip(paths, manifest):
  130. if item['mime'] not in _ATTACHMENT_MIMES:
  131. documents.append(path)
  132. continue
  133. # Public admission accepts only owner-local staging paths. Retained
  134. # room bytes are copied under a deterministic name for exact retries.
  135. data = Path(path).read_bytes()
  136. staging = get_image_cache_dir().resolve()
  137. staging.mkdir(parents=True, exist_ok=True)
  138. target = staging / (hashlib.sha256(data).hexdigest() + Path(item['name']).suffix)
  139. if target.exists():
  140. if target.is_symlink() or target.read_bytes() != data:
  141. raise RuntimeStoreError('storage_unavailable')
  142. else:
  143. fd, temporary = tempfile.mkstemp(dir=staging)
  144. try:
  145. with os.fdopen(fd, 'wb') as output:
  146. output.write(data)
  147. output.flush()
  148. os.fsync(output.fileno())
  149. os.replace(temporary, target)
  150. finally:
  151. Path(temporary).unlink(missing_ok=True)
  152. images.append({'path': str(target), 'mime': item['mime']})
  153. text = prompt + ''.join(HOSTED_DOCUMENT_LINE + path + '\n' for path in documents)
  154. return {'text': text, **({'attachments': images} if images else {})}
  155. def committed_submission_payload(rpc, prompt, attachments=None):
  156. from gateway.session_ingress_media import admit_attachments
  157. payload = submission_payload(rpc, prompt, attachments)
  158. return {'text': payload['text'], **admit_attachments(payload.get('attachments'))}
  159. def _attested_inputs(attachments, digests):
  160. """``(manifest item, retained reference)`` per bound input, from source-attested digests.
  161. Retained inputs are content-addressed under ``native-inputs/<sha256>/<name>`` (images
  162. under their digest-named staging copy), so the destination path of every input is a
  163. pure function of manifest and digest; nothing is transferred to compute it.
  164. """
  165. from gateway.hosted_room_driver import validate_bound_task_manifest
  166. from gateway.hosted_room_attachments import _SHA256_RE
  167. from gateway.session_ingress_media import _ATTACHMENT_MIMES, _media_root
  168. manifest = validate_bound_task_manifest(attachments)
  169. if (not isinstance(digests, list) or len(digests) != len(manifest)
  170. or any(not isinstance(d, str) or _SHA256_RE.fullmatch(d) is None for d in digests)):
  171. raise RuntimeStoreError('permission_denied')
  172. root = _media_root()
  173. inputs = []
  174. for item, digest in zip(manifest, digests):
  175. name = digest + Path(item['name']).suffix if item['mime'] in _ATTACHMENT_MIMES else item['name']
  176. inputs.append((item, {'path': str(root / digest / name), 'sha256': digest, 'size': item['size']}))
  177. return inputs
  178. def attested_submission_payload(prompt, attachments, digests):
  179. """The payload ``committed_submission_payload`` commits for these inputs, derived from
  180. source-attested digests alone.
  181. The durable row is a pure function of prompt, manifest and per-file digest; a source
  182. attachment re-pointed at other bytes yields another payload and is refused without
  183. transferring anything. Images ride as ``attachments_v1`` references that
  184. ``restore_native_media`` re-verifies at execution; documents ride in the prompt text as
  185. paths only, so their retained bytes are checked by ``verify_attested_documents``.
  186. """
  187. if not attachments:
  188. return {'text': prompt}
  189. from gateway.session_ingress_media import _ATTACHMENT_MIMES
  190. documents, media, media_types = [], [], []
  191. for item, reference in _attested_inputs(attachments, digests):
  192. if item['mime'] in _ATTACHMENT_MIMES:
  193. media.append(reference)
  194. media_types.append(item['mime'])
  195. else:
  196. documents.append(reference['path'])
  197. text = prompt + ''.join(HOSTED_DOCUMENT_LINE + path + '\n' for path in documents)
  198. return {'text': text, **({'attachments_v1': {'media': media, 'media_types': media_types}} if media else {})}
  199. def verify_attested_documents(attachments, digests):
  200. """Refuse ``storage_unavailable`` unless every retained document at the destination
  201. still hashes to its source-attested digest.
  202. A document is embedded in the prompt as a content-addressed path, not a structured
  203. reference, so execution reads whatever bytes sit there; a retained file mutated in
  204. place or deleted must pause the row here, as ``committed_submission_payload`` did
  205. before the digest-only preflight. Reads destination bytes only, never the source.
  206. """
  207. if not attachments:
  208. return
  209. from gateway.session_ingress_media import _ATTACHMENT_MIMES, restore_native_media
  210. restore_native_media([reference for item, reference in _attested_inputs(attachments, digests)
  211. if item['mime'] not in _ATTACHMENT_MIMES])