@minaim/openclaw-channel 0.0.0-stage → 0.2.0

package/vendor/mina_native.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""Private-only native host bridge. Credentials stay in the protocol worker.
+
+JSON-lines is a local process protocol, never a remote command interface. A
+host request is emitted only after Runner has durably saved the start permit.
+"""
+import argparse
+import base64
+import copy
+import json
+import os
+import pathlib
+import re
+import select
+import signal
+import stat
+import sys
+import time
+
+if __package__:
+    from .mina_agent import ConfigurationError, ProtocolError, HttpGateway, Journal, Runner, encode
+else:
+    from mina_agent import ConfigurationError, ProtocolError, HttpGateway, Journal, Runner, encode
+
+if __package__:
+    from .mina_media import MediaFiles
+else:
+    from mina_media import MediaFiles
+
+FRAME_LIMIT = 131072
+CONFIG_KEYS = {'gateway', 'app_id', 'bot_id', 'owner_id', 'app_secret', 'credential_version', 'state_file'}
+
+
+def strict_object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise ConfigurationError('duplicate JSON key')
+        result[key] = value
+    return result
+
+
+def decode(raw):
+    try:
+        value = json.loads(raw, object_pairs_hook=strict_object)
+    except (ValueError, UnicodeError, RecursionError):
+        raise ConfigurationError('invalid bridge JSON') from None
+    if not isinstance(value, dict):
+        raise ConfigurationError('bridge object required')
+    return value
+
+
+def load_config(path):
+    path = pathlib.Path(path)
+    try:
+        fd = os.open(path, os.O_RDONLY | getattr(os, 'O_NOFOLLOW', 0) | os.O_NONBLOCK)
+    except OSError:
+        raise ConfigurationError('native config cannot be opened safely') from None
+    try:
+        info = os.fstat(fd)
+        if not stat.S_ISREG(info.st_mode) or info.st_mode & 0o077 or info.st_size > 16384:
+            raise ConfigurationError('config must be a private regular file, mode 0600')
+        with os.fdopen(fd, 'rb', closefd=False) as stream:
+            config = decode(stream.read(16385))
+    finally:
+        os.close(fd)
+    result=validate_configuration(config)
+    result['_config_path']=str(path.resolve())
+    return result
+
+
+def validate_configuration(config):
+    config=dict(config)
+    if not CONFIG_KEYS.issubset(config) or set(config)-CONFIG_KEYS-{'media_roots','media_hosts'}:
+        raise ConfigurationError('unexpected or missing native config fields')
+    for key, pattern in [('app_id', r'mina_[a-f0-9]{32}'), ('bot_id', r'bot_[a-f0-9]{32}'),
+                         ('owner_id', r'[A-Za-z0-9_-]{1,128}'), ('app_secret', r'[A-Za-z0-9_-]{32,128}')]:
+        if not isinstance(config[key], str) or not re.fullmatch(pattern, config[key]):
+            raise ConfigurationError('invalid native identity configuration')
+    version = config['credential_version']
+    if type(version) is not int or version < 1 or version > 9007199254740991:
+        raise ConfigurationError('invalid credential version')
+    if not isinstance(config['state_file'], str) or not pathlib.Path(config['state_file']).is_absolute():
+        raise ConfigurationError('state_file must be an absolute private path')
+    HttpGateway(config['gateway'], config['app_id'], config['app_secret'], version)
+    for name in ('media_roots','media_hosts'):
+        values=config.get(name,[])
+        if not isinstance(values,list) or len(values)>16 or any(not isinstance(x,str) or not x for x in values):
+            raise ConfigurationError('invalid media configuration')
+    if any(not pathlib.Path(x).is_absolute() for x in config.get('media_roots',[])):
+        raise ConfigurationError('media roots must be absolute')
+    if any(not re.fullmatch(r'[a-z0-9][a-z0-9.-]{0,252}',x) for x in config.get('media_hosts',[])):
+        raise ConfigurationError('media hosts must be lowercase hostnames')
+    return config
+
+
+def validate_event(event, config):
+    if not isinstance(event, dict):
+        raise ConfigurationError('invalid native event')
+    for key, expected in [('schema_version', '1'), ('event_type', 'message.created'),
+                          ('bot_id', config['bot_id']), ('sender_id', config['owner_id']),
+                          ('conversation_id', config['owner_id']), ('conversation_type', 'private'),
+                          ('credential_version', config['credential_version'])]:
+        if event.get(key) != expected or (type(expected) is int and type(event.get(key)) is not int):
+            raise ConfigurationError('native private event scope mismatch')
+    for key, pattern in [('event_id', r'evt_[a-f0-9]{32}'),
+                         ('session_key', r'mina:private:[a-f0-9]{64}'),
+                         ('message_id', r'[A-Za-z0-9_-]{1,128}')]:
+        if not isinstance(event.get(key), str) or not re.fullmatch(pattern, event[key]):
+            raise ConfigurationError('invalid trusted event metadata')
+    for key in ('timestamp_ms', 'expires_at_ms', 'context_epoch'):
+        if type(event.get(key)) is not int or event[key] < 1 or event[key] > 9007199254740991:
+            raise ConfigurationError('invalid event lifecycle metadata')
+    if event['expires_at_ms'] <= event['timestamp_ms']:
+        raise ConfigurationError('invalid event deadline')
+    kind=event.get('message_type')
+    items=event.get('attachments',[])
+    if kind not in ('text','image','file') or not isinstance(items,list) or (kind=='text' and items) or (kind!='text' and len(items)!=1):
+        raise ConfigurationError('unsupported native attachment event')
+    for item in items:
+        if (not isinstance(item,dict) or item.get('kind')!=kind
+                or not isinstance(item.get('attachment_id'),str) or not re.fullmatch(r'att_[a-f0-9]{32}',item['attachment_id'])
+                or not isinstance(item.get('sha256'),str) or not re.fullmatch(r'[a-f0-9]{64}',item['sha256'])
+                or type(item.get('size')) is not int or not 1<=item['size']<=(8388608 if kind=='image' else 20971520)):
+            raise ConfigurationError('invalid attachment metadata')
+    if not isinstance(event.get('content'), str) or not (0 if items else 1) <= len(event['content'].encode('utf-8')) <= 8192:
+        raise ConfigurationError('unsupported native input')
+    return event
+
+
+def read_frame(stream):
+    raw = stream.readline(FRAME_LIMIT + 1)
+    if not raw.endswith(b'\n') or len(raw) > FRAME_LIMIT:
+        raise ConfigurationError('missing or oversized bridge frame')
+    return decode(raw)
+
+
+class NativeRunner(Runner):
+    def __init__(self, gateway, journal, handler, config, client_type='Mina native'):
+        super().__init__(gateway, journal, handler, client_type)
+        self.config = config
+        self.capabilities=['text','image','file']
+        self.media_files=MediaFiles(config)
+        self.prepared={}
+
+    def connect(self, takeover=False):
+        response = super().connect(takeover)
+        if (response.get('bot_id') != self.config['bot_id'] or response.get('schema_version') != '1'
+                or not {'text','polling','private'}.issubset(response.get('capabilities', []))):
+            self.stop.set()
+            raise ConfigurationError('native connection identity or protocol mismatch')
+        self.cleanup_terminal()
+        return response
+
+    def cleanup_terminal(self):
+        now=int(time.time()*1000)
+        if now-getattr(self,'last_media_cleanup',0)<60000: return
+        self.last_media_cleanup=now
+        with self.journal.lock:
+            rows=self.journal.db.execute("SELECT id FROM events WHERE state IN ('submitted','expired','fenced','unknown') AND created_ms<?",(now-86400000,)).fetchall()
+        for row in rows: self.media_files.cleanup(row['id'])
+
+    def before_start(self,event):
+        prepared=copy.deepcopy(event)
+        for item in prepared.get('attachments',[]):
+            response=self.request('/bot/v1/events/'+event['event_id']+'/media/'+item['attachment_id']+'/download')
+            if any(response.get(key)!=item.get(key) for key in ('attachment_id','sha256','size','kind','name')):
+                raise ConfigurationError('input attachment descriptor mismatch')
+            try:data=base64.b64decode(response['data_base64'],validate=True)
+            except (ValueError,KeyError):raise ConfigurationError('invalid input attachment') from None
+            item['path']=self.media_files.save_input(event['event_id'],item,data)
+        self.prepared[event['event_id']]=prepared
+
+    def invoke_handler(self,event):
+        return self.handler(self.prepared.pop(event['event_id'],event))
+
+    def store_result(self,event,result):
+        prepared=self.media_files.prepare_result(result,event['event_id'])
+        # Plain text keeps the old journal representation for restart compatibility.
+        self.prepared_format='native_media_v1' if prepared['attachments'] else 'text'
+        return prepared['text'] if not prepared['attachments'] else encode(prepared)
+
+    def result_format(self,event):
+        return self.prepared_format
+
+    def submit_result(self,event,row):
+        if row.get('result_format','text')!='native_media_v1':
+            return super().submit_result(event,row)
+        result=decode(row['result'])
+        assets=[]
+        for item in result['attachments']:
+            if item.get('attachment_id'):
+                assets.append(item['attachment_id']);continue
+            data=self.media_files.read_snapshot(item,event['event_id'])
+            uploaded=self.request('/bot/v1/tasks/'+event['event_id']+'/media/upload',execution_id=row['execution_id'],
+                upload_id=item['upload_id'],kind=item['kind'],name=item['name'],data_base64=base64.b64encode(data).decode('ascii'))
+            asset=uploaded.get('attachment_id')
+            if not isinstance(asset,str) or not re.fullmatch(r'att_[a-f0-9]{32}',asset):
+                raise ConfigurationError('attachment upload not confirmed')
+            assets.append(asset)
+            item['attachment_id']=asset
+            self.journal.transition(event['event_id'],'result_ready',result=encode(result),result_format='native_media_v1')
+        self.request('/bot/v1/tasks/'+event['event_id']+'/reply',execution_id=row['execution_id'],content=result['text'],attachments=assets)
+
+    def handle(self, event):
+        # Validation precedes ACK and the irreversible execution decision, including recovered inbox entries.
+        validate_event(event, self.config)
+        try:
+            return super().handle(event)
+        finally:
+            row=self.journal.event(event['event_id'])
+            if row and row['state']=='submitted': self.media_files.cleanup(event['event_id'],output_only=True)
+            self.cleanup_terminal()
+
+
+class Worker(NativeRunner):
+    def report_status(self,code):
+        from mina_setup import safe_status
+        code=safe_status(code)
+        if code!=getattr(self,'last_status',None):
+            self.last_status=code
+            self.emit(dict(type='status',code=code))
+
+    def emit(self, value):
+        raw = (encode(value) + '\n').encode('utf-8')
+        if len(raw) > FRAME_LIMIT:
+            raise ConfigurationError('oversized bridge output')
+        sys.stdout.buffer.write(raw)
+        sys.stdout.buffer.flush()
+
+    def connect(self, takeover=False):
+        connection=super().connect(takeover)
+        self.last_status='connected'
+        self.emit(dict(type='ready', protocol=1, owner_id=self.config['owner_id'],
+                       bot_id=self.config['bot_id'], app_id=self.config['app_id'],
+                       credential_version=self.config['credential_version'],media_enabled={'image','file'}.issubset(connection.get('capabilities',[]))))
+
+    def execute(self, event):
+        self.emit(dict(type='execute', event=event))
+        # No late reply can be attached to another request. A stopped lease or host
+        # timeout terminates this worker and leaves a durable unknown execution.
+        deadline = time.monotonic() + 240
+        raw = b''
+        while not self.stop.is_set() and time.monotonic() < deadline:
+            if not select.select([sys.stdin.buffer], [], [], 0.5)[0]:
+                continue
+            chunk = os.read(sys.stdin.fileno(), 65536)
+            if not chunk:
+                break
+            raw += chunk
+            if len(raw) > FRAME_LIMIT:
+                break
+            if b'\n' not in raw:
+                continue
+            if not raw.endswith(b'\n') or raw.count(b'\n') != 1:
+                break
+            response = decode(raw)
+            if (set(response) in ({'type','event_id','content'},{'type','event_id','content','attachments'}) and response['type'] == 'result'
+                    and response['event_id'] == event['event_id']):
+                return {'text':response['content'],'attachments':response['attachments']} if response.get('attachments') else response['content']
+            break
+        self.stop.set()
+        raise ConfigurationError('native host reply missing or invalid')
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--config', required=True)
+    parser.add_argument('--host', required=True, choices=('OpenClaw', 'Hermes'))
+    args = parser.parse_args()
+    config = load_config(args.config)
+    journal = Journal(config['state_file'], config['app_id'], config['credential_version'])
+    worker = Worker(HttpGateway(config['gateway'], config['app_id'], config['app_secret'], config['credential_version']),
+                    journal, None, config, args.host)
+    worker.handler = worker.execute
+    signal.signal(signal.SIGTERM, lambda *_: worker.stop.set())
+    signal.signal(signal.SIGINT, lambda *_: worker.stop.set())
+    try:
+        worker.run()
+    finally:
+        journal.close()
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except BaseException as error:
+        from mina_setup import safe_status
+        code=safe_status(error.code) if isinstance(error,ProtocolError) else 'configuration_invalid' if isinstance(error,ConfigurationError) else 'network_unavailable' if isinstance(error,OSError) else 'worker_stopped'
+        if isinstance(error,ConfigurationError) and str(error)=='another adapter is already using this journal':code='state_locked'
+        # The wire carries an allowlisted code only, never exception text or server responses.
+        sys.stdout.write(encode(dict(type='error',code=code))+'\n');sys.stdout.flush()
+        raise SystemExit(1) from None

package/vendor/mina_setup.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Private local configuration and passive diagnostics. No network calls or journal writes."""
+import argparse
+import json
+import os
+from pathlib import Path
+import secrets
+import stat
+import sys
+
+if __package__:
+    from .mina_agent import ConfigurationError
+    from .mina_native import validate_configuration,decode
+else:
+    from mina_agent import ConfigurationError
+    from mina_native import validate_configuration,decode
+
+STATUS_CODES=frozenset(('connected','invalid_agent_credentials','authorization_revoked','lease_held',
+    'stale_lease','network_unavailable','transport_unavailable','media_unavailable','configuration_invalid',
+    'configuration_missing','host_version_unsupported','python_unsupported','platform_unsupported',
+    'state_locked','worker_stopped','protocol_error','rate_limited','storage_unavailable'))
+
+def safe_status(code):
+    return code if isinstance(code,str) and code in STATUS_CODES else 'worker_stopped'
+
+def compatibility():
+    return json.loads(Path(__file__).with_name('compatibility.json').read_text())
+
+def runtime_code(host,host_version=None,python_version=None,platform=None):
+    data=compatibility();info=data.get(host)
+    if not info or (host_version is not None and host_version not in info['host_versions']):return 'host_version_unsupported'
+    if (platform or sys.platform) not in data['platforms']:return 'platform_unsupported'
+    current=tuple((python_version or sys.version_info)[:2])
+    if current<tuple(info['python_min']) or ('python_max_exclusive' in info and current>=tuple(info['python_max_exclusive'])):return 'python_unsupported'
+    return None
+
+def _directory(path,create=False):
+    path=Path(path)
+    if not path.is_absolute() or '..' in path.parts:raise ConfigurationError('private_directory_required')
+    fd=os.open('/',os.O_RDONLY|os.O_DIRECTORY)
+    try:
+        for part in path.parts[1:]:
+            if create:
+                try:os.mkdir(part,0o700,dir_fd=fd)
+                except FileExistsError:pass
+            nxt=os.open(part,os.O_RDONLY|os.O_DIRECTORY|os.O_NOFOLLOW,dir_fd=fd)
+            os.close(fd);fd=nxt
+        info=os.fstat(fd)
+        if info.st_uid!=os.getuid() or info.st_mode&0o077:raise ConfigurationError('private_directory_required')
+        return fd
+    except BaseException:
+        os.close(fd);raise
+
+def _read_at(fd,name):
+    file=os.open(name,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK,dir_fd=fd)
+    try:
+        info=os.fstat(file)
+        if not stat.S_ISREG(info.st_mode) or info.st_uid!=os.getuid() or info.st_mode&0o077 or info.st_size>16384:raise ConfigurationError('private_file_required')
+        with os.fdopen(file,'rb',closefd=False) as stream:return decode(stream.read(16385))
+    finally:os.close(file)
+
+def atomic_private_json(directory,name,value):
+    """Create-only + immutable retry. Directory FDs prevent parent substitution and final symlinks."""
+    fd=_directory(directory,create=True);temporary='.mina-'+secrets.token_hex(12)
+    raw=(json.dumps(value,ensure_ascii=False,sort_keys=True,indent=2)+'\n').encode()
+    try:
+        try:
+            previous=_read_at(fd,name)
+        except FileNotFoundError:previous=None
+        if previous is not None:
+            if previous!=value:raise ConfigurationError('configuration_exists')
+            return
+        file=os.open(temporary,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600,dir_fd=fd)
+        try:
+            with os.fdopen(file,'wb',closefd=False) as stream:stream.write(raw);stream.flush();os.fsync(file)
+        finally:os.close(file)
+        try:os.link(temporary,name,src_dir_fd=fd,dst_dir_fd=fd,follow_symlinks=False)
+        except FileExistsError:
+            if _read_at(fd,name)!=value:raise ConfigurationError('configuration_exists')
+        os.fsync(fd)
+    finally:
+        try:os.unlink(temporary,dir_fd=fd)
+        except FileNotFoundError:pass
+        os.close(fd)
+
+def configure(directory,values):
+    directory=Path(directory)
+    if not isinstance(values,dict) or 'state_file' in values or not directory.is_absolute() or '..' in directory.parts:raise ConfigurationError('invalid_setup_input')
+    version=values.get('credential_version')
+    if type(version) is not int or version<1 or version>9007199254740991:raise ConfigurationError('invalid_setup_input')
+    result=validate_configuration(dict(values,state_file=str(directory/('state-v'+str(version)+'.sqlite'))))
+    for root in result.get('media_roots',[]):
+        path=Path(root)
+        if root=='/' or not path.is_dir() or path.is_symlink() or directory==path or path in directory.parents:raise ConfigurationError('invalid_media_root')
+    try:atomic_private_json(directory,'assistant.json',result)
+    except (OSError,ValueError):raise ConfigurationError('private_config_write_failed') from None
+    return dict(config_file=str(directory/'assistant.json'),state_file=result['state_file'])
+
+def doctor(config_file,host,host_version=None):
+    code=runtime_code(host,host_version)
+    configured=False
+    if code is None:
+        fd=None
+        try:
+            path=Path(config_file)
+            if not path.exists() and not path.is_symlink():raise FileNotFoundError()
+            fd=_directory(path.parent);values=validate_configuration(_read_at(fd,path.name));configured=True
+            code='configuration_valid'
+            state=Path(values['state_file'])
+            if state.is_symlink():code='configuration_invalid';configured=False
+        except FileNotFoundError:code='configuration_missing'
+        except Exception:code='configuration_invalid'
+        finally:
+            if fd is not None:os.close(fd)
+    return dict(ok=code=='configuration_valid',code=code,host=host,configured=configured,
+                connected=None,network_checked=False,host_version_checked=host_version is not None)
+
+def main(argv=None):
+    parser=argparse.ArgumentParser(description=__doc__);sub=parser.add_subparsers(dest='command',required=True)
+    configure_parser=sub.add_parser('configure');configure_parser.add_argument('--directory',required=True)
+    inspect=sub.add_parser('doctor');inspect.add_argument('--config',required=True);inspect.add_argument('--host',choices=('OpenClaw','Hermes'),required=True);inspect.add_argument('--host-version')
+    args=parser.parse_args(argv)
+    try:
+        if args.command=='configure':
+            raw=sys.stdin.buffer.read(16385)
+            if len(raw)>16384:raise ConfigurationError('invalid_setup_input')
+            result=configure(args.directory,decode(raw));code=0
+        else:result=doctor(args.config,args.host,args.host_version);code=0 if result['ok'] else 1
+    except Exception:
+        result={'ok':False,'code':'configuration_invalid'};code=1
+    print(json.dumps(result,ensure_ascii=False));return code
+
+if __name__=='__main__':raise SystemExit(main())