File size: 24,092 Bytes
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2719bf4
0364757
 
2719bf4
 
 
 
 
 
 
 
 
 
0364757
 
2719bf4
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2719bf4
 
0364757
2719bf4
0364757
2719bf4
 
0364757
 
 
2719bf4
0364757
 
 
2719bf4
 
0364757
2719bf4
 
 
 
0364757
 
2719bf4
 
 
 
 
 
 
 
0364757
 
2719bf4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a8aea51
 
 
 
 
 
 
 
 
 
0364757
 
 
a8aea51
 
0364757
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2719bf4
 
0364757
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
from __future__ import annotations

from collections import OrderedDict
from dataclasses import dataclass, field
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from ipaddress import IPv4Address
import json
import os
from pathlib import Path
import re
import secrets
import sys
import threading
import time


MAX_BODY = 32768
STATIC = Path(__file__).parent / 'static'
SESSION_ID = re.compile(r'^[a-f0-9]{32}$')
HTTPS_ORIGIN = re.compile(r'https://([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*)(?::([1-9][0-9]{0,4}))?')


def _https_origin(value):
    match = HTTPS_ORIGIN.fullmatch(value) if isinstance(value, str) else None
    if not match or len(match[1]) > 253 or (match[2] and int(match[2]) > 65535):
        raise ValueError('Deployment origins must be exact lowercase HTTPS origins without paths, credentials, or wildcards.')
    if match[1].rsplit('.', 1)[-1].isdigit():
        IPv4Address(match[1])
    return value


@dataclass(frozen=True)
class DeploymentConfig:
    public_origin: str | None = None
    frame_ancestors: tuple[str, ...] = ()

    def __post_init__(self):
        if self.public_origin is not None:
            _https_origin(self.public_origin)
        if not isinstance(self.frame_ancestors, tuple) or len(self.frame_ancestors) > 8:
            raise ValueError('Frame ancestors must be a tuple of at most eight exact HTTPS origins.')
        for ancestor in self.frame_ancestors:
            _https_origin(ancestor)
        if len(set(self.frame_ancestors)) != len(self.frame_ancestors):
            raise ValueError('Frame ancestors must be unique.')

    @classmethod
    def from_env(cls):
        ancestors = os.environ.get('BORDERLAND_FRAME_ANCESTORS')
        return cls(os.environ.get('BORDERLAND_PUBLIC_ORIGIN'), tuple(ancestors.split(',')) if ancestors is not None else ())

    @property
    def csp(self):
        ancestors = ' '.join(self.frame_ancestors) or "'none'"
        return "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; frame-ancestors " + ancestors + "; base-uri 'none'; form-action 'self'"


class RequestError(Exception):
    def __init__(self, status, message):
        self.status, self.message = status, message


@dataclass
class Session:
    campaign: object
    transition: dict
    touched: float = field(default_factory=time.monotonic)
    receipts: OrderedDict = field(default_factory=OrderedDict)
    lock: threading.Lock = field(default_factory=threading.Lock)


class Application:
    def __init__(self, campaign_factory=None, archive_workload="standard", generation_version=3, notebook_bytes=768, memory_profile="static"):
        if archive_workload not in ("compact","standard","extended"):
            raise ValueError("Invalid Archive workload.")
        if type(generation_version) is not int or generation_version not in (2, 3):
            raise ValueError("Generation version must be 2 or 3.")
        if type(notebook_bytes) is not int or not 0 <= notebook_bytes <= 8192:
            raise ValueError("Notebook capacity must be an integer from 0 to 8192 bytes.")
        if memory_profile not in ("static", "commissioning") or (generation_version == 2 and memory_profile != "static"):
            raise ValueError("Commissioning requires generation three.")
        self.archive_workload = archive_workload
        self.generation_version = generation_version
        self.notebook_bytes = notebook_bytes
        self.memory_profile = memory_profile
        if campaign_factory is None:
            from borderland import Campaign
            campaign_factory = lambda: Campaign.generated(secrets.randbits(63), archive_workload=archive_workload, generation_version=generation_version, notebook_bytes=notebook_bytes, memory_profile=memory_profile)
        self.campaign_factory = campaign_factory
        self.sessions = {}
        self.lock = threading.Lock()

    def create(self):
        with self.lock:
            now = time.monotonic()
            self.sessions = {k: v for k, v in self.sessions.items() if now - v.touched < 7200}
            if len(self.sessions) >= 256:
                raise RequestError(503, 'The session limit is reached. Try again later.')
            campaign = self.campaign_factory()
            transition = campaign.reset().to_dict()
            session_id = secrets.token_hex(16)
            self.sessions[session_id] = Session(campaign, transition)
        return {'session': session_id, 'transition': transition}

    def session(self, session_id):
        if not isinstance(session_id, str) or not SESSION_ID.fullmatch(session_id):
            raise RequestError(404, 'Session not found.')
        with self.lock:
            session = self.sessions.get(session_id)
        if session is None or time.monotonic() - session.touched >= 7200:
            raise RequestError(404, 'Session expired. Start a new campaign.')
        session.touched = time.monotonic()
        return session

    def command(self, route, body):
        required = {'session', 'revision', 'request_id', 'action' if route == 'action' else 'text'}
        if set(body) != required:
            raise RequestError(400, 'Command fields do not match the request schema.')
        if type(body['revision']) is not int or body['revision'] < 0:
            raise RequestError(400, 'Revision must be a nonnegative integer.')
        request_id = body['request_id']
        if not isinstance(request_id, str) or not re.fullmatch(r'[A-Za-z0-9_-]{8,80}', request_id):
            raise RequestError(400, 'A request ID of 8 to 80 letters, digits, underscores or hyphens is required.')
        if route == 'notebook' and (not isinstance(body['text'], str) or len(body['text']) > 8192):
            raise RequestError(400, 'Notebook text is invalid or too long.')
        if route == 'action':
            action = body['action']
            if not isinstance(action, dict) or set(action) != {'tag', 'arguments'}:
                raise RequestError(400, 'Action requires exactly tag and arguments.')
            if not isinstance(action['tag'], str) or not isinstance(action['arguments'], dict):
                raise RequestError(400, 'Action tag and arguments have invalid types.')
        session = self.session(body['session'])
        fingerprint = json.dumps([route, body], sort_keys=True, separators=(',', ':'), allow_nan=False)
        with session.lock:
            if request_id in session.receipts:
                old_fingerprint, status, receipt = session.receipts[request_id]
                if old_fingerprint != fingerprint:
                    raise RequestError(409, 'This request ID was already used for a different command.')
                return status, receipt
            if len(session.receipts) >= 1024:
                raise RequestError(409, 'This session has reached its command limit. Start a new campaign.')
            if body['revision'] != session.transition['revision']:
                receipt = {'session': body['session'], 'request_id': request_id, 'error': 'State changed. Review the current observation before acting.', 'transition': session.transition}
                session.receipts[request_id] = fingerprint, 409, receipt
                return 409, receipt
            if route == 'action':
                transition = session.campaign.step(body['action'], expected_revision=body['revision'])
            else:
                transition = session.campaign.replace_notebook(body['text'], expected_revision=body['revision'])
            session.transition = transition.to_dict()
            status = 422 if session.transition.get('error') else 200
            receipt = {'session': body['session'], 'request_id': request_id, 'transition': session.transition}
            session.receipts[request_id] = fingerprint, status, receipt
            return status, receipt

    def _reference_replay(self, campaign, stop_before=None):
        from borderland_verify.reference import public_reference
        transition = campaign.reset()
        policy = public_reference(transition)
        frames = [{'transition': transition.to_dict(), 'action': None, 'kind': 'start'}]
        resets = 0
        for _ in range(320):
            if transition.done:
                break
            note = policy.notebook(transition)
            if note is not None and note != transition.observation.notebook['text']:
                transition = campaign.replace_notebook(note, expected_revision=transition.revision)
                frames.append({'transition': transition.to_dict(), 'action': None, 'kind': 'notebook'})
            action = policy.choose(transition)
            if stop_before is not None and stop_before(action, transition):
                break
            transition = campaign.step(action, expected_revision=transition.revision)
            frames.append({'transition': transition.to_dict(), 'action': action.to_dict(), 'kind': 'action'})
            if transition.context_reset:
                policy = public_reference(transition)
                resets += 1
            if transition.error:
                break
        return {'label': 'Scripted public reference', 'generation_version': self.generation_version,
                'scope': 'Actual public engine events from a separate campaign. A fresh scripted controller receives only the saved notebook and current state at Blackout. No Beam calls.',
                'frames': frames, 'outcome': transition.outcome, 'controller_resets': resets, 'memory_profile': self.memory_profile}

    def demonstration(self):
        from borderland import Campaign
        return self._reference_replay(Campaign.generated(17, archive_workload=self.archive_workload,
            generation_version=self.generation_version, notebook_bytes=self.notebook_bytes, memory_profile=self.memory_profile))

    def twins(self):
        if self.generation_version == 2:
            from borderland_verify.certificates import certify_twins
            return {'label': 'Legacy generation 2 assisted final-valve checkpoint',
                    'generation_version': 2, 'certificate': certify_twins(17)}
        from borderland import Action, Campaign
        from borderland.worlds import candidate, coherent_twin
        from borderland.plant import circuit_bus, circuit_order, exit_decision, compensated_bus
        base = candidate(0, generation_version=3, archive_workload=self.archive_workload,
                         notebook_bytes=self.notebook_bytes, memory_profile=self.memory_profile)
        channel = base.infrastructure.calibrations[0]
        twin = coherent_twin(base, sensor_xor=1-channel.sensor_xor)
        worlds = (base, twin)
        replays = [self._reference_replay(Campaign(world)) for world in worlds]
        hub_prefix = []
        for frame in replays[0]['frames'][1:]:
            if frame['action'] is not None and frame['transition']['observation']['phase'] == 4:
                if frame['action']['tag'] == 'bank':
                    break
                if frame['action']['tag'] != 'bind_docket':
                    hub_prefix.append(frame['action'])
        def selected_bus(world, service, index):
            plant = world.infrastructure
            bus = circuit_bus(plant, service)
            if plant.load_schedule is not None:
                meter = plant.load_schedule.test(service, index)
                bus = compensated_bus(bus, plant.load_schedule.curve(plant.current(service).id), meter.band, meter.load)
            return bus
        target, test_index = next((cid, index) for cid in circuit_order(base.infrastructure)
            for index in range(3 if self.memory_profile == 'commissioning' else 1)
            if selected_bus(base, cid, index) != selected_bus(twin, cid, index))
        commands = [
            ('delivery', 'The same flag bank pays different customs charge.',
             lambda action, transition: action.tag == 'bank', [Action('bank', {'actor': 'Ada'})]),
            ('circuit', 'The same bus and energize command passes a commissioning test versus tripping a circuit.' if self.memory_profile == 'commissioning' else 'The same bus and energize command produces live versus tripped circuits.',
             lambda action, transition: action.tag == 'connect' and action.arguments['circuit'] == target
                and next(c for c in transition.observation.board['circuits'] if c['id'] == target).get('completed_tests', 0) == test_index,
             [Action('connect', {'circuit': target, 'bus': selected_bus(base, target, test_index)}),
              Action('energize', {'circuit': target})]),
            ('exit', 'The same valve and launch commands preserve versus vent pressure.',
             lambda action, transition: action.tag == 'open_valve',
             [Action('open_valve', {'side': exit_decision(base.infrastructure)[1]}), Action('launch', {})]),
        ]
        comparisons = []
        for kind, description, stop, actions in commands:
            branches = []
            for world in worlds:
                campaign = Campaign(world)
                checkpoint = (lambda action, transition: transition.observation.phase == 4) if kind == 'delivery' else stop
                replay = self._reference_replay(campaign, stop_before=checkpoint)
                if kind == 'delivery':
                    for command in hub_prefix:
                        staged = campaign.step(command)
                        if staged.error:
                            raise RuntimeError('The shared delivery probe prefix was rejected.')
                        replay['frames'].append({'transition': staged.to_dict(), 'action': command, 'kind': 'action'})
                before = replay['frames'][-1]['transition']
                events = []
                revision = before['revision']
                for action in actions:
                    transition = campaign.step(action, expected_revision=revision)
                    revision = transition.revision
                    events.append({'transition': transition.to_dict(), 'action': action.to_dict(), 'kind': 'action'})
                branches.append({'before': before, 'events': events, 'prefix': replay,
                                 'charge_spent': before['observation']['charge']-events[-1]['transition']['observation']['charge']})
            comparisons.append({'kind': kind, 'description': description, 'branches': branches,
                                **({'service': target, 'test': test_index + 1} if kind == 'circuit' else {})})
        result = {'label': 'Generation 3 coherent causal replays', 'generation_version': 3,
                'scope': 'One channel wiring bit changes. Both complete replays use the public scripted controller. Separate checkpoint probes apply the same commands in both worlds. These examples establish no unrestricted memory bound or Beam result.',
                'intervention': {'channel': channel.id, 'field': 'sensor wiring bit',
                                 'observed_at_latch_zero': [channel.sensor_xor, 1-channel.sensor_xor]},
                'replays': replays, 'comparisons': comparisons}
        if self.memory_profile == 'commissioning':
            result['information_check'] = self._curve_information_check()
        return result

    @staticmethod
    def _curve_information_check():
        from borderland_verify.curve_twins import certify_curve_twins
        checked = certify_curve_twins()
        summary = checked['summary']
        result = {'label': 'Separate known standard seed 16 check',
                  'archive_workload': 'standard', 'notebook_bytes': 768,
                  'memory_profile': 'commissioning', 'summary': summary}
        if not summary['passed']:
            return result
        evidence_decision = summary['archive_evidence'][0]['decision']
        branches = []
        for label in ('low', 'high'):
            trace = checked['public_command_traces'][label]
            earlier = next(row for row in trace if row['decision'] == evidence_decision)
            target = next(row for row in trace if row['request']['tool'] == 'execute_action'
                          and row['request']['arguments']['tag'] == 'connect'
                          and row['request']['arguments']['arguments']['circuit'] == summary['target']['service'])
            branches.append({'label': label,
                             'earlier_evidence': {'decision': earlier['decision'], 'public': earlier['public']},
                             'saved_notebook': target['public']['observation']['notebook'],
                             'first_target_connect': target})
        result.update(branches=branches, erased_public_checkpoint=checked['erased_public_checkpoint'])
        return result


def _object(pairs):
    result = {}
    for key, value in pairs:
        if key in result:
            raise ValueError('Duplicate JSON keys are not accepted.')
        result[key] = value
    return result


def make_server(host='127.0.0.1', port=8765, application=None, deployment=None):
    application = application or Application()
    deployment = DeploymentConfig.from_env() if deployment is None else deployment
    if not isinstance(deployment, DeploymentConfig):
        raise TypeError('Deployment configuration must be a DeploymentConfig.')

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, format, *args):
            pass

        def send(self, status, payload, content_type='application/json; charset=utf-8'):
            data = json.dumps(payload, ensure_ascii=False, allow_nan=False).encode() if content_type.startswith('application/json') else payload
            self.send_response(status)
            self.send_header('Content-Type', content_type)
            self.send_header('Content-Length', str(len(data)))
            self.send_header('Cache-Control', 'no-store')
            self.send_header('X-Content-Type-Options', 'nosniff')
            self.send_header('Referrer-Policy', 'no-referrer')
            self.send_header('Content-Security-Policy', deployment.csp)
            self.end_headers()
            self.wfile.write(data)

        def do_GET(self):
            try:
                if self.path == '/api/recordings':
                    self.send(200, json.loads((STATIC / 'beam-recordings.json').read_text(encoding='utf-8')))
                    return
                if self.path.startswith('/api/session/'):
                    session = application.session(self.path.removeprefix('/api/session/'))
                    with session.lock:
                        self.send(200, {'transition': session.transition})
                    return
                files = {'/': ('index.html', 'text/html; charset=utf-8'), '/app.js': ('app.js', 'text/javascript; charset=utf-8'), '/style.css': ('style.css', 'text/css; charset=utf-8'),
                         '/proof.html': ('proof.html', 'text/html; charset=utf-8'), '/proof.js': ('proof.js', 'text/javascript; charset=utf-8'),
                         '/proof.css': ('proof.css', 'text/css; charset=utf-8'), '/proof.json': ('proof.json', 'application/json'),
                         '/probe.html': ('probe.html', 'text/html; charset=utf-8'), '/probe.js': ('probe.js', 'text/javascript; charset=utf-8'),
                         '/probe.css': ('probe.css', 'text/css; charset=utf-8'), '/probe.json': ('probe.json', 'application/json'),
                         '/campaign-pilot.html': ('campaign-pilot.html', 'text/html; charset=utf-8'),
                         '/campaign-pilot.js': ('campaign-pilot.js', 'text/javascript; charset=utf-8'),
                         '/campaign-pilot.json': ('campaign-pilot.json', 'application/json'),
                         '/campaign-pilot-receipts.zip': (STATIC.parent.parent / 'evidence/archive-campaign-pilot-v1/public-receipts.zip', 'application/zip'),
                         '/probe-receipts.zip': (STATIC.parent.parent / 'evidence/archive-probe-v1/public-receipts.zip', 'application/zip')}
                if self.path not in files:
                    raise RequestError(404, 'Route not found.')
                filename, content_type = files[self.path]
                payload = (STATIC / filename).read_bytes()
                self.send(200, json.loads(payload) if content_type.startswith('application/json') else payload, content_type)
            except RequestError as exc:
                self.send(exc.status, {'error': exc.message})

        def do_POST(self):
            try:
                if self.path not in {'/api/session', '/api/action', '/api/notebook', '/api/demo', '/api/twins'}:
                    raise RequestError(404, 'Route not found.')
                origins = self.headers.get_all('Origin', [])
                if origins and (len(origins) != 1 or origins[0] not in allowed_origins):
                    raise RequestError(403, 'Cross-origin commands are not accepted.')
                if self.headers.get('Transfer-Encoding') or len(self.headers.get_all('Content-Length', [])) != 1:
                    raise RequestError(400, 'One Content-Length header is required.')
                try:
                    length = int(self.headers['Content-Length'])
                except (TypeError, ValueError):
                    raise RequestError(400, 'Invalid content length.')
                if length < 0 or length > MAX_BODY:
                    raise RequestError(413, 'Request body is too large.')
                if self.headers.get('Content-Type', '').split(';')[0] != 'application/json':
                    raise RequestError(415, 'Use application/json.')
                self.connection.settimeout(10)
                try:
                    body = json.loads(self.rfile.read(length), object_pairs_hook=_object, parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Non-finite JSON number.')))
                except (ValueError, UnicodeError, RecursionError):
                    raise RequestError(400, 'Request body must be valid JSON without duplicate keys or non-finite numbers.')
                if not isinstance(body, dict):
                    raise RequestError(400, 'Request body must be a JSON object.')
                if self.path in {'/api/session', '/api/demo', '/api/twins'} and body:
                    raise RequestError(400, 'This endpoint accepts an empty object only.')
                if self.path == '/api/session':
                    self.send(201, application.create())
                elif self.path in {'/api/action', '/api/notebook'}:
                    status, receipt = application.command(self.path.rsplit('/', 1)[1], body)
                    self.send(status, receipt)
                elif self.path == '/api/demo':
                    self.send(200, application.demonstration())
                else:
                    self.send(200, application.twins())
            except RequestError as exc:
                self.send(exc.status, {'error': exc.message})
            except Exception as exc:
                print(f'Borderland request failed: {type(exc).__name__}', file=sys.stderr, flush=True)
                self.send(500, {'error': 'The operation could not finish. Try again or restart the local server.'})

    server = ThreadingHTTPServer((host, port), Handler)
    allowed_origins = {deployment.public_origin} if deployment.public_origin else {
        f'http://127.0.0.1:{server.server_port}', f'http://localhost:{server.server_port}',
    }
    server.daemon_threads = True
    return server


def serve(host='127.0.0.1', port=8765, archive_workload='standard', generation_version=3, notebook_bytes=768, memory_profile='static'):
    server = make_server(host, port, application=Application(archive_workload=archive_workload, generation_version=generation_version, notebook_bytes=notebook_bytes, memory_profile=memory_profile))
    print(f'Borderland is running at http://{host}:{server.server_port}', flush=True)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass
    finally:
        server.server_close()