| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375 |
- """Hosted producers between independently owned local profile daemons.
- Only the private OS-authenticated owner socket exposes these verbs. The source
- owner attests durable membership/task state; the target never opens its database.
- """
- from __future__ import annotations
- import asyncio
- import base64
- from dataclasses import asdict
- import hashlib
- import json
- import os
- from pathlib import Path
- import threading
- import time
- from gateway.hosted_room_driver import TaskIdentity
- from gateway.session_contract import SessionActor
- from gateway.session_authorities import owner_scope
- from gateway.session_hosted_rpc import HostedRoomAuthorityRPC
- from gateway.owner_identity import same_owner
- from hermes_state_runtime import RuntimeStoreError, _epoch
- _BINDING = 'gateway.hosted.transport.v1:'
- _OPERATIONS = frozenset({'resolve_exact', 'create', 'resume', 'submit', 'history', 'results',
- 'info', 'interrupt', 'discard', 'approve'})
- # One chunk per private-socket exchange. The response is a single JSON line capped at
- # gateway.control_socket._MAX_RESPONSE_BYTES (512 KiB) on both the POSIX socket and the
- # Windows pipe: 360 KiB raw -> 480 KiB base64, leaving 32 KiB for the envelope (owner
- # subject, target home, digest); the attachment attest result carries no prompt/manifest.
- _CHUNK_BYTES = 360 * 1024
- _CAPS = frozenset({'session:create', 'session:read', 'session:submit',
- 'session:control', 'session:approve'})
- def owner_request(home, verb, params, *, timeout=30):
- """Authenticated private socket exchange; no owner-start or storage fallback."""
- home = Path(home)
- if home != home.resolve():
- raise RuntimeStoreError('permission_denied')
- from hermes_cli.gateway_runtime import discover_gateway_endpoint, control_home_for
- deadline = time.monotonic() + timeout
- discovered = discover_gateway_endpoint(home, timeout=timeout)
- if discovered.state != 'ready' or discovered.endpoint is None:
- raise RuntimeStoreError('runtime_draining')
- from hermes_constants import hermes_home_key
- if hermes_home_key(discovered.endpoint.profile_id) != hermes_home_key(home):
- raise RuntimeStoreError('profile_mismatch')
- # Socket identity and logical authority identity are distinct under multiplex.
- params = {**params, 'profile_id': discovered.endpoint.profile_id}
- home = control_home_for(home, discovered.endpoint)
- timeout = deadline - time.monotonic()
- if timeout <= 0:
- raise RuntimeStoreError('runtime_draining')
- request = json.dumps({'protocol': 1, 'id': 1, 'verb': verb, 'params': params}).encode() + b'\n'
- if len(request) > 65536:
- raise RuntimeStoreError('request_too_large')
- if os.name == 'nt':
- from gateway.runtime_bootstrap_windows import query_runtime_control
- raw = query_runtime_control(home, request, timeout)
- else:
- from hermes_cli.gateway_runtime_discovery import connect_private
- from gateway.control_socket import _read_response_line
- with connect_private(home, timeout) as peer:
- peer.sendall(request)
- def read():
- peer.settimeout(max(0.001, deadline - time.monotonic()))
- return peer.recv(65536)
- raw = _read_response_line(read, deadline)
- if not raw:
- raise RuntimeStoreError('runtime_draining')
- response = json.loads(raw)
- if response.get('ok') is not True:
- reason = str(response.get('error', '')).split(': ')[-1]
- if reason not in {'permission_denied', 'profile_mismatch', 'invalid_params', 'unknown_execution',
- 'stale_generation', 'admission_conflict', 'response_too_large', 'request_too_large'}:
- reason = 'runtime_draining'
- raise RuntimeStoreError(reason)
- if response.get('protocol') != 1 or response.get('id') != 1:
- raise RuntimeStoreError('runtime_draining')
- return response['result']
- def _attest(binding, operation, params):
- try:
- result = owner_request(binding['source_home'], 'hosted-attest', {
- 'selector': binding['selector'], 'operation': operation,
- 'params': {**params, '_target_home': binding['target_home']}})
- except RuntimeStoreError:
- raise
- except (OSError, ValueError) as exc:
- raise RuntimeStoreError('runtime_draining') from exc
- if not isinstance(result, dict) or not isinstance(result.get('owner'), str) or not result['owner']:
- raise RuntimeStoreError('permission_denied')
- if result.get('target_home') != binding['target_home']:
- raise RuntimeStoreError('permission_denied')
- return result
- def source_attachment_chunk(service, member, room_id, manifest, params):
- """Read scoped source bytes only on the source owner's authenticated handler.
- Serves one slice per call; the row's stored SHA-256 (verified at upload) rides along
- so the target can verify the reassembled file without the source re-hashing 15 MB
- per 24 KiB chunk.
- """
- index, offset = params.get('index'), params.get('offset')
- if (type(index) is not int or not 0 <= index < len(manifest)
- or type(offset) is not int or not 0 <= offset < manifest[index]['size']):
- raise RuntimeStoreError('permission_denied')
- from gateway.hosted_room_attachments import HostedRoomAttachmentStore
- item = manifest[index]
- saved = HostedRoomAttachmentStore(service.db_path).read_range(room_id=room_id,
- attachment_id=item['attachment_id'], event_id=item['event_id'], recipient_member_id=member,
- offset=offset, length=_CHUNK_BYTES)
- if any(saved.attachment[key] != item[key] for key in ('kind', 'name', 'mime', 'size')):
- raise RuntimeStoreError('permission_denied')
- return {'data_base64': base64.b64encode(saved.data).decode('ascii'),
- 'sha256': saved.attachment['sha256']}
- def source_attachment_digests(service, member, room_id, manifest):
- """Upload-verified SHA-256 of every bound input, read on the source owner's handler.
- Rides on the submit/execute attest result so the target can bind transferred bytes
- to the attested input and the preflight can verify the durable row without bytes.
- """
- from gateway.hosted_room_attachments import HostedRoomAttachmentStore
- store = HostedRoomAttachmentStore(service.db_path)
- digests = []
- for item in manifest:
- saved = store.describe(room_id=room_id, attachment_id=item['attachment_id'],
- event_id=item['event_id'], recipient_member_id=member)
- if any(saved[key] != item[key] for key in ('kind', 'name', 'mime', 'size')):
- raise RuntimeStoreError('permission_denied')
- digests.append(saved['sha256'])
- return digests
- def _attachment_data(binding, attested, params):
- """Transfer bytes, not foreign filenames, with a task fence on every chunk."""
- from gateway.hosted_room_driver import validate_bound_task_manifest
- manifest = attested.get('attachments', [])
- if not manifest:
- return []
- manifest = validate_bound_task_manifest(manifest)
- digests = attested.get('attachment_digests')
- if not isinstance(digests, list) or len(digests) != len(manifest):
- raise RuntimeStoreError('permission_denied')
- result = []
- for index, (item, digest) in enumerate(zip(manifest, digests)):
- data = bytearray()
- while len(data) < item['size']:
- chunk = _attest(binding, 'attachment', {
- 'task': params['task'], 'execution_generation': params['execution_generation'],
- 'prompt_sha256': hashlib.sha256(attested['prompt'].encode('utf-8')).hexdigest(),
- 'attachments': manifest, 'index': index, 'offset': len(data)})
- raw = base64.b64decode(chunk['data_base64'], validate=True)
- expected = min(_CHUNK_BYTES, item['size'] - len(data))
- if chunk['owner'] != attested['owner'] or len(raw) != expected or chunk['sha256'] != digest:
- raise RuntimeStoreError('permission_denied')
- data.extend(raw)
- if hashlib.sha256(data).hexdigest() != digest:
- raise RuntimeStoreError('permission_denied')
- result.append((item, bytes(data)))
- return result
- def _principal(authority, binding):
- # Source-profile namespace prevents equal room owner strings on other owners
- # from aliasing a target's principal. Never widen SessionActor.profile_id.
- identity = json.dumps([binding['source_home'], binding['owner']], separators=(',', ':'))
- subject = 'hosted-owner:' + hashlib.sha256(identity.encode()).hexdigest()
- return SessionActor(subject, authority.profile_id, _CAPS, 'hosted-owner-transport')
- def install_hosted_transport(server, authority, loop, *, attest):
- """Install profile-selected private routing over the existing authority registry.
- The callback must validate current room authority/member and, for submit and
- execute, exact TaskIdentity, generation and prompt against durable task data.
- It returns {'owner': durable_room_owner_subject}, never a client actor.
- Every wire envelope names the logical profile_id, not its control socket home.
- Reinstallation for a secondary preserves routing to all other served owners.
- """
- def select(envelope):
- from hermes_constants import assert_named_profile_home_live
- params = dict(envelope)
- profile_id = params.pop('profile_id', None)
- if not isinstance(profile_id, str) or not Path(profile_id).is_absolute():
- raise RuntimeStoreError('profile_mismatch')
- home = Path(profile_id)
- if home != home.resolve():
- raise RuntimeStoreError('profile_mismatch')
- registry = getattr(getattr(authority, 'runner', None), 'session_authorities', None)
- selected = registry.for_home(home) if registry is not None else authority
- if selected is None or selected.profile_id != profile_id:
- raise RuntimeStoreError('profile_mismatch')
- assert_named_profile_home_live(home)
- return selected, params
- def source(envelope, peer):
- selected, params = select(envelope)
- if set(params) != {'selector', 'operation', 'params'}:
- raise RuntimeStoreError('invalid_params')
- if params['operation'] not in _OPERATIONS | {'execute', 'attachment'}:
- raise RuntimeStoreError('invalid_params')
- callback = attest if selected is authority else getattr(
- getattr(selected, 'hosted_room_service', None), 'attest', None)
- if callback is None:
- raise RuntimeStoreError('runtime_draining')
- with owner_scope(selected):
- return callback(params['selector'], params['operation'], params['params'])
- def target(envelope, peer):
- selected, params = select(envelope)
- with owner_scope(selected):
- return produce(selected, params)
- def produce(authority, envelope):
- if set(envelope) != {'source_home', 'selector', 'operation', 'params'}:
- raise RuntimeStoreError('invalid_params')
- operation, params = envelope['operation'], dict(envelope['params'])
- selector = envelope['selector']
- if operation not in _OPERATIONS or set(selector) != {'room_id', 'member_id', 'profile'}:
- raise RuntimeStoreError('invalid_params')
- from gateway.session_authorities import served_profile_name
- profile = served_profile_name(Path(authority.profile_id))
- if selector['profile'] != profile:
- raise RuntimeStoreError('profile_mismatch')
- binding = {'source_home': envelope['source_home'], 'selector': selector,
- 'target_home': authority.profile_id}
- attested = _attest(binding, operation, params)
- binding['owner'] = attested['owner']
- principal = _principal(authority, binding)
- # Authorization already happened: every operation, including each attachment
- # chunk, is re-attested at the SOURCE owner above before anything runs here, so
- # the RPC's own authorize hook has nothing left to decide. A new operation must
- # be added to _OPERATIONS (and therefore attested) before it can reach _call.
- rpc = HostedRoomAuthorityRPC(authority, loop, **selector, principal=principal,
- authorize=lambda *args: True)
- key = _BINDING + rpc.ref.session_id
- encoded = json.dumps(binding, sort_keys=True)
- def persist(conn):
- _epoch(conn, authority.epoch)
- old = conn.execute('SELECT value FROM state_meta WHERE key=?', (key,)).fetchone()
- if old is not None and old[0] != encoded:
- raise RuntimeStoreError('permission_denied')
- conn.execute('INSERT OR IGNORE INTO state_meta(key,value) VALUES(?,?)', (key, encoded))
- authority.db._execute_write(persist)
- if operation == 'submit':
- rpc.hosted_attachment_data = _attachment_data(binding, attested, params)
- # Only the source's durable, attested text may become the admitted input.
- params.pop('prompt_sha256', None)
- params['prompt'] = attested['prompt']
- params['attachments'] = attested['attachments'] or None
- params['task'] = TaskIdentity(**params['task'])
- params['on_terminal'] = lambda value: None
- result = rpc._call(operation, **params)
- return result
- server.private_handlers.update({'hosted-attest': source, 'hosted-producer': target})
- def check_remote_hosted_admission(authority, ref, row):
- """Before claim, reauthorize durable target binding at its source owner.
- Returns False only for a non-transport session. A known transport binding
- fails closed on missing source, revoked membership or altered task payload.
- Call off the owner's event loop (the reverse RPC is synchronous).
- """
- with owner_scope(authority):
- return _check_remote_hosted_admission(authority, ref, row)
- def _check_remote_hosted_admission(authority, ref, row):
- with authority.db._read_ctx() as conn:
- stored = conn.execute('SELECT value FROM state_meta WHERE key=?',
- (_BINDING + ref.session_id,)).fetchone()
- if stored is None:
- return False
- try:
- binding = json.loads(stored[0])
- identity, generation = json.loads(row['request_id'][7:])
- if (not row['request_id'].startswith('hosted:')
- or not same_owner(row['principal_id'], _principal(authority, binding).subject)
- or ref.profile_id != authority.profile_id
- or binding.get('target_home') != authority.profile_id):
- raise ValueError('binding mismatch')
- params = {'task': identity, 'execution_generation': generation}
- attested = _attest(binding, 'execute', params)
- if attested['owner'] != binding['owner']:
- raise ValueError('owner changed')
- # Bytes are not re-transferred here: the durable row is compared against the
- # payload the attested prompt, manifest and source-verified digests commit to.
- from gateway.session_hosted_attachments import attested_submission_payload, verify_attested_documents
- if row['payload'] != attested_submission_payload(
- attested['prompt'], attested['attachments'], attested.get('attachment_digests')):
- raise ValueError('input changed')
- except (ValueError, KeyError, TypeError) as exc:
- raise RuntimeStoreError('permission_denied') from exc
- # Outside the permission_denied fold: a corrupted or missing retained document is a
- # storage fault of this destination, not a revoked source binding.
- verify_attested_documents(attested['attachments'], attested.get('attachment_digests'))
- return True
- class HostedRoomOwnerRPC(HostedRoomAuthorityRPC):
- """Driver-compatible producer; carries data, never a caller principal."""
- def __init__(self, *, home, source_home, room_id, member_id, profile):
- self.home = Path(home)
- self.member_id = member_id
- self.binding = {'source_home': str(Path(source_home)),
- 'selector': dict(room_id=room_id, member_id=member_id, profile=profile)}
- self.callbacks = {}
- self._lock = threading.Lock()
- self._monitor = None
- def _call(self, operation, **params):
- callback = params.pop('on_terminal', None)
- if operation == 'submit':
- # The private control request is 64 KiB, smaller than a legal room prompt.
- params['prompt_sha256'] = hashlib.sha256(params.pop('prompt').encode('utf-8')).hexdigest()
- if isinstance(params.get('task'), TaskIdentity):
- params['task'] = asdict(params['task'])
- result = owner_request(self.home, 'hosted-producer', {
- **self.binding, 'operation': operation, 'params': params})
- if operation in {'create', 'resume', 'resolve_exact'} and result is not None:
- from gateway.session_contract import SessionRef
- self.ref = SessionRef(str(self.home), result['session_id'])
- if operation == 'submit' and callback is not None:
- with self._lock:
- self.callbacks[result['admission_id']] = callback
- if self._monitor is None or not self._monitor.is_alive():
- self._monitor = threading.Thread(target=self._watch,
- args=(params['session_id'],), daemon=True)
- self._monitor.start()
- if operation in {'history', 'results'}:
- self._deliver(result)
- return result
- def history(self, *, profile, session_id, source):
- """Driver recovery reads terminal receipts; a transcript past one response line
- degrades to the bounded receipt rows (all the driver matches on) instead of failing."""
- try:
- return super().history(profile=profile, session_id=session_id, source=source)
- except RuntimeStoreError as exc:
- if exc.reason != 'response_too_large':
- raise
- return [{**receipt, 'role': 'assistant', 'content': receipt['text']}
- for receipt in self.results(profile=profile, session_id=session_id, source=source)]
- def _deliver(self, history):
- for row in history:
- with self._lock:
- callback = self.callbacks.pop(row.get('settlement_id'), None)
- if callback is not None:
- callback(row)
- def _watch(self, session_id):
- try:
- while True:
- with self._lock:
- if not self.callbacks:
- return
- pending = list(self.callbacks)[:256]
- # Per-admission receipts only: polling never re-reads the transcript.
- self.results(profile=self.binding['selector']['profile'],
- session_id=session_id, source='bot_room', admission_ids=pending)
- time.sleep(0.25)
- except (OSError, ValueError, RuntimeStoreError):
- # Retain callbacks/input for normal driver history recovery; no retry
- # admission and no assertion that a timed-out request was unaccepted.
- return
|