#!/usr/bin/env python3 """Concrete public-contract acceptance adapters. Importing performs no I/O.""" import datetime as dt import hashlib import json import subprocess import sys import time import uuid import vm_mvp_acceptance as m APT_CASES = ('apt_native_install','apt_native_update','ensure_package','apply_updates') RECIPES = {'apt_native_install':'rmm-apt-fixture-install-1.0','ensure_package':'rmm-apt-fixture-update-1.1', 'apt_native_update':'rmm-apt-fixture-update-1.1','apply_updates':'rmm-apt-fixture-update-1.1'} PINS = {'1.0':'74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867', '1.1':'ef67c9fe0ba1443fcfe465768e1204763063c369a2a1da04af6027d8a9c00491'} PLANNING_FIELDS = ('fixture_package','baseline_sha256','sealed_baseline_sha256','status_fingerprint', 'dpkg_updates_empty','pending_triggers_empty','host_reboot_required','runtime','runtime_sha256', 'provider_sha256','hook_sha256','apt_config_sha256','prefetch') def canonical(value): return json.dumps(value,sort_keys=True,separators=(',',':'),ensure_ascii=True).encode() def digest(value): return hashlib.sha256(value).hexdigest() def planning_from_device(device,recovery=False): """Only already stored passive observation, never an SSH package scan.""" observations=(device.get('inventory') or {}).get('observations',[]) scope='linux.apt.recovery-planning' if recovery else 'linux.apt.planning' observation=next((x for x in observations if x.get('scope')==scope),None) m.require(observation is not None,'not_configured:stored_linux.apt.planning_observation_missing') m.require(observation.get('quality')=='valid' and observation.get('completeness')=='complete' and observation.get('truncated') is False and 0 <= (m.now()-m.timestamp(observation['observed_at'])).total_seconds()<90, 'not_configured:fresh_complete_apt_planning_required') data=observation.get('data',{}) if recovery: m.require(observation['source_id']=='root-helper:apt_recovery_planning_v1' and data.get('fixture_package')==dict(version='1.0',status='install ok unpacked') and set(data.get('native_recovery',{}))=={'schema_version','previous_grant_id','previous_attempt_id','partial_proof_sha256'}, 'dedicated exact partial recovery observation required') else:m.require(data.get('native_recovery') is None,'normal planning cannot use partial recovery') missing=[key for key in PLANNING_FIELDS if key not in data] m.require(not missing,'not_configured:apt_planning_fields_missing:'+','.join(missing)) m.require(data['dpkg_updates_empty'] is True and data['pending_triggers_empty'] is True,'not_configured:dpkg_dirty') m.require(type(data['host_reboot_required']) is bool,'not_configured:actual_host_reboot_flag_required') m.require(data['baseline_sha256']==data['sealed_baseline_sha256'] and __import__('re').fullmatch('[a-f0-9]{64}',data['baseline_sha256']), 'not_configured:actual_sealed_baseline_binding') if 'baseline' in data: m.require(digest(canonical(data['baseline']))==data['baseline_sha256'] and data['baseline'].get('rmm-mvp-test:all')==data['fixture_package'],'not_configured:full_baseline_hash_or_fixture_projection') if 'status_records' in data: m.require(digest(canonical(data['status_records']))==data['status_fingerprint'],'not_configured:resolver_fingerprint') m.require(digest(canonical(data['runtime']))==data['runtime_sha256'] and data['runtime']['apt_config_sha256']==data['apt_config_sha256'],'not_configured:runtime_config_binding') for key in ('baseline_sha256','sealed_baseline_sha256','status_fingerprint','runtime_sha256','provider_sha256','hook_sha256','apt_config_sha256'): m.require(isinstance(data[key],str) and __import__('re').fullmatch('[a-f0-9]{64}',data[key]),'not_configured:measured_sha256_required:'+key) return data def manifest(name,data,start): recipe=RECIPES[name]; version='1.1' if recipe.endswith('1.1') else '1.0';old='1.0' if version=='1.1' else None installed=data['fixture_package'] if old is None: m.require(installed is None or installed.get('status') in ('purge ok not-installed','unknown ok not-installed'), 'not_configured:fixture_already_installed_no_approved_removal_or_idempotent_recipe') else: already_desired=name in ('ensure_package','apply_updates') and installed==dict(version=version,status='install ok installed') m.require(already_desired or installed==dict(version=old,status='install ok installed'),'not_configured:fixture_upgrade_requires_actual_1.0_or_approved_exact_noop_baseline') pin=PINS[version] receipt=data['prefetch'].get(pin,{}) m.require(receipt.get('schema_version')==1 and receipt.get('sha256')==pin and receipt.get('size')==20672 and type(receipt.get('sealed_at_ms')) is int and receipt['sealed_at_ms']<=int(start.timestamp()*1000), 'not_configured:real_pregrant_prefetch_receipt_required') transaction=dict(schema_version=1,recipe_id=recipe,recipe_version='1',platform='ubuntu-24.04-amd64', resolver_config_version='rmm-apt-local-v1',no_reboot=True,status_fingerprint=data['status_fingerprint'], baseline_sha256=data['baseline_sha256'],packages=[dict(name='rmm-mvp-test',architecture='all',old_version=old, new_version=version,origin='rmm-test',sha256=pin,size=20672,archive_path='/var/lib/rmm-apt-transaction/archives/'+pin+'.deb')]) raw=canonical(transaction) result=dict(type='rmm.apt.helper-action',schema_version=2,action='apt-native-acceptance' if name.startswith('apt_native_') else 'apt-execute', execution_profile='dev-test',transaction_sha256=digest(raw),resolved_apt_transaction=transaction,transaction_bytes=list(raw), **{key:data[key] for key in ('provider_sha256','hook_sha256','apt_config_sha256','runtime_sha256')},test_result_id='vm-'+uuid.uuid4().hex) m.validate_apt_manifest(result) return result def advanced_input(name,settings,start,planning=None): m.require(name not in ('duplicate_offer','lost_result_ack'),'existing_attempt_replay_has_no_new_plan') identity='agent_service';timeout=60;end=start+dt.timedelta(minutes=15) if name in APT_CASES: m.require(planning is not None,'not_configured:stored_linux.apt.planning_required') apt=manifest(name,planning,start);recipe=RECIPES[name];identity='root';timeout=300 if name.startswith('apt_native_'): action='apt_native_acceptance';parameters=dict(recipe_id=recipe,recipe_version='1',apt_manifest=apt) elif name=='ensure_package': action='ensure_package';parameters=dict(provider='apt',package='rmm-mvp-test',version='1.1',architecture='all', installation_context='system',recipe_id=recipe,recipe_version='1',apt_manifest=apt) else: action='apply_updates';parameters=dict(provider='apt',packages=['rmm-mvp-test'],reboot_policy='never',apt_manifest=apt) elif name in ('cancel_queued','expired_offline'): action='run_script';parameters=dict(variants=[dict(os_family='linux',interpreter='posix_sh',encoding='utf-8',script_utf8=m.HELLO)], arguments=[],expected_stdout='Hello World\n') if name=='cancel_queued':start=start+dt.timedelta(minutes=3);end=start+dt.timedelta(minutes=3) else:end=start+dt.timedelta(seconds=60) elif name=='reboot_last': identity='root';timeout=240;action='reboot';parameters=dict(reason='Explicit final Linux VM dev/test acceptance', dependency_group='single-test-vm',reconnect_timeout_seconds=180) else: raise m.GuardError('unknown_advanced_case') parameters.update(execution_identity=identity,timeout_seconds=timeout,max_output_bytes=65536) return dict(tenant_id=settings['tenant_id'],action=action,targets=dict(asset_ids=[settings['asset_id']]),parameters=parameters, schedule=m.schedule(start,end),rollout=dict(max_parallel=1,halt_after_failures=1),reason='Explicit dev/test VM acceptance ยท '+name) def authorize(backend,settings,artifact,name,folder,request,old_boot=None,verify_boot=None): if request['parameters']['execution_identity']=='root': # Default automation has no root:execute permission. Do not edit its # membership or borrow cookies: the simulated human prepares root plans # through actual UI interactions, then MCP reads the same stored request. output=folder/(name+'-prepared.json') preparation=folder/(name+'-prepare.json') m.write_private(preparation,dict(profile='dev/test',case=name,phase='prepare',request=request, asset_id=settings['asset_id'],tenant_id=settings['tenant_id'],agent_id=settings['agent_id'], expected_principal=artifact['expected_principal'],output_file=str(output))) process=subprocess.run([sys.executable,str(m.ROOT/'deploy/browser/run_mvp_actions.py'),'--case-file',str(preparation), '--prepare-only','--dev-test-ui-approve'],timeout=120) m.require(process.returncode==0,'root_UI_preparation_unconfirmed_no_requester_scope_bypass') prepared=m.protected_json(output);plan=prepared['plan'];pending=prepared['operation'] stored=backend.call('jobs.get',dict(tenant_id=settings['tenant_id'],operation_id=pending['operation_id'])) m.require(stored['plan_hash']==plan['plan_hash'] and stored['approval_state']=='pending_approval','root_UI_preparation_MCP_binding') else: plan=backend.call('operations.plan',dict(tenant_id=settings['tenant_id'],input=request)) pending=backend.call('operations.submit',dict(tenant_id=settings['tenant_id'],plan_id=plan['plan_id'],idempotency_key='mvp-'+uuid.uuid4().hex)) m.require(digest(bytes(plan['plan_payload_bytes']))==plan['plan_hash'] and len(plan['jobs'])==1,'exact_advanced_plan_bytes_required') job=plan['jobs'][0] m.require(job['agent_id']==settings['agent_id'] and job['asset_id']==settings['asset_id'] and job['payload']['execution_identity']==request['parameters']['execution_identity'],'fixed_advanced_job_binding') m.require(pending['approval_state']=='pending_approval' and pending['job_count']==0 and pending['execution_state'] is None and backend.counts(settings['tenant_id'],job['job_id'])==[0,0,0],'preapproval_zero_artifacts') checkpoint={**{key:settings[key] for key in ('tenant_id','asset_id','agent_id')},'operation_id':str(uuid.UUID(pending['operation_id'])), 'job_id':job['job_id'],'attempt_id':job['attempt_id'],'plan_hash':plan['plan_hash']} if old_boot is not None: m.require(verify_boot is not None and verify_boot()==old_boot,'preapproval_boot_changed_no_reboot_approval') checkpoint['old_boot_id']=old_boot m.write_private(folder/(name+'-checkpoint.json'),checkpoint) expected=dict(profile='dev/test',case=name,tenant_id=settings['tenant_id'],asset_id=settings['asset_id'],agent_id=settings['agent_id'], plan_hash=plan['plan_hash'],plan_payload_bytes=plan['plan_payload_bytes'],job_payload=job['payload'],job_payload_hash=job['job_payload_hash'], expected_principal=artifact['expected_principal'],operation_id=checkpoint['operation_id']) path=folder/(name+'-browser.json');m.write_private(path,expected) process=subprocess.run([sys.executable,str(m.ROOT/'deploy/browser/run_mvp_actions.py'),'--case-file',str(path),'--dev-test-ui-approve'],timeout=120) m.require(process.returncode==0,'browser_advanced_approval_unconfirmed_no_retry') return checkpoint def wait_job(backend,settings,job_id,timeout): end=time.monotonic()+timeout while True: result=backend.call('jobs.get',dict(tenant_id=settings['tenant_id'],job_id=job_id)) if result['state'] in m.TERMINAL or result['state']=='unknown':return result m.require(time.monotonic()0:time.sleep(min(remaining+2,62)) runtime.resume_after_offline(job_id) result=wait_job(backend,settings,job_id,60) m.require(result['state']=='expired' and backend.counts(settings['tenant_id'],job_id)==[1,1,0],'expired_offline_effect_not_excluded') else: if name=='reboot_last':runtime.recover_reboot(checkpoint['old_boot_id']) result=wait_job(backend,settings,job_id,request['parameters']['timeout_seconds']+45) evidence=(result.get('result') or {}).get('evidence',{}) m.require(result['state']=='succeeded' and evidence.get('postconditions_passed') is True,'advanced_effect_not_verified_no_retry') m.require(backend.counts(settings['tenant_id'],job_id)==[1,1,1],'exactly_one_advanced_attempt_grant') if name=='reboot_last': m.validate_reboot_checkpoint(checkpoint,runtime.server_state()['boot_id'],result) inventory=backend.call('inventory.get_device',dict(tenant_id=settings['tenant_id'],asset_id=settings['asset_id'])) m.require(inventory['agent_id']==settings['agent_id'] and m.timestamp(inventory['observed_at'])>=m.timestamp(request['schedule']['not_before']), 'unknown:authenticated_new_boot_inventory_missing') if name in APT_CASES: apt=evidence.get('apt',{});package=request['parameters']['apt_manifest']['resolved_apt_transaction']['packages'][0] m.require(apt.get('packages')==[dict(name=package['name'],architecture=package['architecture'],version=package['new_version'])] and apt.get('fixture_payload_sha256')==digest((package['new_version']+'\n').encode()),'independent_apt_version_payload_postconditions') if name.startswith('apt_native_'): m.require(apt.get('test_acceptance') is True and apt.get('noProductionEvidence') is True and apt.get('test_result_id')==request['parameters']['apt_manifest']['test_result_id'] and isinstance(apt.get('native_record_sha256'),str),'genuine_native_acceptance_record_required') elif planning['fixture_package']==dict(version=package['new_version'],status='install ok installed'): m.require(apt.get('changed') is False and apt.get('already_desired') is True and apt.get('postcondition_already_met') is True and apt.get('transaction_executed') is False, 'exact_desired_noop_must_not_execute_a_transaction') if name=='service_setup': m.require(result['result']['exit_code']==0 and bytes(result['result']['stdout'])==b'RMM test unit prepared\n','root_test_service_setup_exact_result') record=dict(case=name,verified=True,**checkpoint,audit=audit(backend,settings,checkpoint,artifact),output_not_published=True) m.write_private(folder/(name+'-result.json'),record)