ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
feat(restore-points): add surface adapters and checkpoints
Juan Deniscf2cce6041c9
diff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex 42615db6..75ec993a 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -220,6 +220,11 @@ def create_app(config_name=None):from app.services import recycle_bin_servicerecycle_bin_service.register_builtin_types()+ # Restore adapters are process-local strategy registrations. They do not+ # touch the database and must exist in testing/CLI app factories too.+ from app.services.restore_point_adapters import register_builtin_restore_point_adapters+ register_builtin_restore_point_adapters()+# Handle database migrations (Alembic) — must run before plugin loader# since the loader queries the installed_plugins table.with app.app_context():diff --git a/backend/app/api/cron.py b/backend/app/api/cron.pyindex b0cef45b..902ba33b 100644--- a/backend/app/api/cron.py+++ b/backend/app/api/cron.py@@ -231,14 +231,11 @@ def toggle_tracking(job_id):serverkit-cron-run shim; disabling restores the bare command)."""data = request.get_json(silent=True) or {}enabled = bool(data.get('enabled', True))- result = CronService.set_tracking(job_id, enabled)+ options = {}+ if 'alert_on_failure' in data:+ options['alert_on_failure'] = data['alert_on_failure']+ result = CronService.set_tracking(job_id, enabled, **options)if result.get('success'):- # Persist the optional per-job "alert on failure" flag alongside.- if 'alert_on_failure' in data:- meta = CronService._load_jobs_metadata()- if job_id in meta.get('jobs', {}):- meta['jobs'][job_id]['alert_on_failure'] = bool(data['alert_on_failure'])- CronService._save_jobs_metadata(meta)return jsonify(result)return jsonify(result), 400diff --git a/backend/app/api/env_vars.py b/backend/app/api/env_vars.pyindex 2be61b1a..5d8f4e96 100644--- a/backend/app/api/env_vars.py+++ b/backend/app/api/env_vars.py@@ -127,36 +127,21 @@ def update_env_var(app_id, key):if not data:return jsonify({'error': 'No data provided'}), 400- value = data.get('value')- is_secret = data.get('is_secret')- description = data.get('description')-- # Get existing- existing = EnvService.get_env_var(app_id, key)- if not existing:- return jsonify({'error': 'Environment variable not found'}), 404-- # Update only provided fields- if value is not None:- old_value = existing.value- existing.value = value- from app.models import EnvironmentVariableHistory- from app import db- EnvironmentVariableHistory.record_change(- existing, 'updated', old_value=old_value, new_value=value, user_id=current_user_id- )-- if is_secret is not None:- existing.is_secret = is_secret-- if description is not None:- existing.description = description-+ updates = {}+ if data.get('value') is not None:+ updates['value'] = data['value']+ if data.get('is_secret') is not None:+ updates['is_secret'] = data['is_secret']+ if data.get('description') is not None:+ updates['description'] = data['description']if 'target_service' in data:- existing.target_service = data.get('target_service') or None+ updates['target_service'] = data.get('target_service')- from app import db- db.session.commit()+ existing, err = EnvService.update_env_var(+ app_id, key, user_id=current_user_id, **updates,+ )+ if err:+ return jsonify({'error': err}), 404return jsonify({'message': 'Environment variable updated',diff --git a/backend/app/models/dns_change.py b/backend/app/models/dns_change.pyindex fea7ea8e..4062f188 100644--- a/backend/app/models/dns_change.py+++ b/backend/app/models/dns_change.py@@ -22,10 +22,10 @@ class DnsChange(SerializableMixin, db.Model):record_type = db.Column(db.String(10))name = db.Column(db.String(256))content = db.Column(db.Text) # value we set (after)+ before_json = db.Column(db.Text) # complete owned pre-imageprovider_record_id = db.Column(db.String(128))source = db.Column(db.String(40)) # zone|ddns|wordpress|email|auto-dns|caa|...result = db.Column(db.String(16), nullable=False) # ok | error | conflict | skippederror = db.Column(db.Text)created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)-diff --git a/backend/app/models/env_variable.py b/backend/app/models/env_variable.pyindex b81f7198..27823221 100644--- a/backend/app/models/env_variable.py+++ b/backend/app/models/env_variable.py@@ -140,6 +140,10 @@ class EnvironmentVariableHistory(db.Model):action = db.Column(db.String(20), nullable=False) # 'created', 'updated', 'deleted'old_value_hash = db.Column(db.String(64), nullable=True) # SHA256 hash (not the actual value)new_value_hash = db.Column(db.String(64), nullable=True)+ # One logical operation (bulk import, clear, or restore replay) may write+ # several per-variable audit rows. ``batch_id`` keeps those rows grouped+ # without weakening the existing one-row-per-key history.+ batch_id = db.Column(db.String(36), nullable=True, index=True)changed_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)changed_at = db.Column(db.DateTime, default=datetime.utcnow)@@ -151,7 +155,8 @@ class EnvironmentVariableHistory(db.Model):return hashlib.sha256(value.encode()).hexdigest()@classmethod- def record_change(cls, env_var, action, old_value=None, new_value=None, user_id=None):+ def record_change(cls, env_var, action, old_value=None, new_value=None,+ user_id=None, batch_id=None):"""Record a change to an environment variable."""history = cls(env_variable_id=env_var.id if env_var.id else 0,@@ -160,7 +165,8 @@ class EnvironmentVariableHistory(db.Model):action=action,old_value_hash=cls.hash_value(old_value) if old_value else None,new_value_hash=cls.hash_value(new_value) if new_value else None,- changed_by=user_id+ batch_id=batch_id,+ changed_by=user_id,)db.session.add(history)return history@@ -172,6 +178,7 @@ class EnvironmentVariableHistory(db.Model):'application_id': self.application_id,'key': self.key,'action': self.action,+ 'batch_id': self.batch_id,'changed_by': self.changed_by,'changed_at': self.changed_at.isoformat() if self.changed_at else None,}diff --git a/backend/app/models/managed_dns_record.py b/backend/app/models/managed_dns_record.pyindex 3edf1405..05d38b6f 100644--- a/backend/app/models/managed_dns_record.py+++ b/backend/app/models/managed_dns_record.py@@ -26,6 +26,12 @@ class ManagedDnsRecord(SerializableMixin, TimestampMixin, db.Model):record_type = db.Column(db.String(10), nullable=False)name = db.Column(db.String(256), nullable=False) # FQDNcontent = db.Column(db.Text)+ ttl = db.Column(db.Integer)+ priority = db.Column(db.Integer)+ # Nullable on purpose: rows predating migration 092 do not know these+ # provider attributes. Restore must preserve/hydrate unknowns, not invent+ # a default that could change live DNS behavior.+ proxied = db.Column(db.Boolean)source = db.Column(db.String(40)) # zone|ddns|preset|wordpress|emailapp_id = db.Column(db.Integer, db.ForeignKey('applications.id'), nullable=True)diff --git a/backend/app/services/cron_service.py b/backend/app/services/cron_service.pyindex 5d162726..f16e9d86 100644--- a/backend/app/services/cron_service.py+++ b/backend/app/services/cron_service.py@@ -28,6 +28,26 @@ SHIM_PATH = os.path.join('serverkit_cron_run.py',)+_UNSET = object()+++def _auto_capture_cron(action):+ """Best-effort local CRON checkpoint without burdening utility callers.++ Several unit-level and bootstrap callers use CronService outside a Flask+ application context. Restore points are database-backed, so those callers+ must retain the pre-existing standalone service behaviour.+ """+ from flask import has_app_context++ if not has_app_context():+ return None+ from app.services.restore_point_service import auto_capture, get_adapter++ if get_adapter('cron') is None:+ return None+ return auto_capture('cron', 'cron', action)+class CronService:"""Service for managing cron jobs and scheduled tasks."""@@ -57,14 +77,22 @@ class CronService:@classmethoddef _load_jobs_metadata(cls) -> Dict:"""Load job metadata from file."""+ try:+ return cls._load_jobs_metadata_strict()+ except (json.JSONDecodeError, IOError, ValueError):+ return {'jobs': {}}++ @classmethod+ def _load_jobs_metadata_strict(cls) -> Dict:+ """Load metadata without converting corruption into an empty schedule."""cls._ensure_data_dir()- if os.path.exists(JOBS_FILE):- try:- with open(JOBS_FILE, 'r') as f:- return json.load(f)- except (json.JSONDecodeError, IOError):- pass- return {'jobs': {}}+ if not os.path.exists(JOBS_FILE):+ return {'jobs': {}}+ with open(JOBS_FILE, 'r') as handle:+ data = json.load(handle)+ if not isinstance(data, dict) or not isinstance(data.get('jobs'), dict):+ raise ValueError('CRON metadata is malformed')+ return data@classmethoddef _save_jobs_metadata(cls, data: Dict):@@ -319,6 +347,8 @@ class CronService:if not cls._validate_command(command):return {'success': False, 'error': 'Invalid command: must use absolute paths and cannot contain shell operators (;, &&, ||, |, `, $())'}+ _auto_capture_cron('add_job')+# Generate job IDjob_id = f"job_{datetime.now().strftime('%Y%m%d%H%M%S')}"@@ -367,6 +397,9 @@ class CronService:job_data = metadata.get('jobs', {}).get(job_id)+ if job_data is not None:+ _auto_capture_cron('remove_job')+if cls.is_linux() and job_data:current = cls._read_crontab()if current is not None:@@ -408,6 +441,7 @@ class CronService:return {'success': False, 'error': 'Job not found'}job_data = metadata['jobs'][job_id]+ _auto_capture_cron('toggle_job')if cls.is_linux():current = cls._read_crontab()@@ -527,6 +561,8 @@ class CronService:if schedule and not cls._validate_schedule(schedule):return {'success': False, 'error': 'Invalid cron schedule format'}+ _auto_capture_cron('update_job')+# Update crontab on Linux if schedule or command changedif cls.is_linux() and (new_schedule != old_schedule or new_command != old_command):current = cls._read_crontab()@@ -660,7 +696,8 @@ class CronService:return job@classmethod- def set_tracking(cls, job_id: str, enabled: bool) -> Dict:+ def set_tracking(cls, job_id: str, enabled: bool, *,+ alert_on_failure=_UNSET) -> Dict:"""Enable/disable run tracking for a job.On Linux this rewrites the job's crontab line to add/remove the@@ -673,6 +710,7 @@ class CronService:job_data = metadata['jobs'][job_id]enabled = bool(enabled)was_tracked = bool(job_data.get('tracked', False))+ _auto_capture_cron('set_tracking')if cls.is_linux() and enabled != was_tracked:schedule = job_data.get('schedule', '')@@ -684,6 +722,8 @@ class CronService:return errjob_data['tracked'] = enabled+ if alert_on_failure is not _UNSET:+ job_data['alert_on_failure'] = bool(alert_on_failure)job_data['updated_at'] = datetime.now().isoformat()cls._save_jobs_metadata(metadata)@@ -732,13 +772,18 @@ class CronService:delete uses `suspend_for_application` instead, which is reversible."""metadata = cls._load_jobs_metadata()+ targets = [+ job_data for job_data in metadata.get('jobs', {}).values()+ if cls._same_application(job_data.get('application_id'), application_id)+ ]+ if targets:+ _auto_capture_cron('clear_application')changed = 0- for job_data in metadata.get('jobs', {}).values():- if cls._same_application(job_data.get('application_id'), application_id):- job_data['application_id'] = None- job_data['suspended_by_app'] = False- job_data['updated_at'] = datetime.now().isoformat()- changed += 1+ for job_data in targets:+ job_data['application_id'] = None+ job_data['suspended_by_app'] = False+ job_data['updated_at'] = datetime.now().isoformat()+ changed += 1if changed:cls._save_jobs_metadata(metadata)return changed@@ -765,8 +810,12 @@ class CronService:if cls._same_application(job_data.get('application_id'), application_id)and job_data.get('enabled')]- for job_id in targets:- cls.toggle_job(job_id, False)+ if targets:+ _auto_capture_cron('suspend_for_application')+ from app.services.restore_point_service import suppress_auto_capture+ with suppress_auto_capture():+ for job_id in targets:+ cls.toggle_job(job_id, False)if targets:# Re-read: toggle_job persists on each call, so the copy above is@@ -787,8 +836,12 @@ class CronService:if cls._same_application(job_data.get('application_id'), application_id)and job_data.get('suspended_by_app')]- for job_id in targets:- cls.toggle_job(job_id, True)+ if targets:+ _auto_capture_cron('resume_for_application')+ from app.services.restore_point_service import suppress_auto_capture+ with suppress_auto_capture():+ for job_id in targets:+ cls.toggle_job(job_id, True)if targets:metadata = cls._load_jobs_metadata()diff --git a/backend/app/services/dns/__init__.py b/backend/app/services/dns/__init__.pyindex 0fdd69b8..c6ae14a1 100644--- a/backend/app/services/dns/__init__.py+++ b/backend/app/services/dns/__init__.py@@ -7,16 +7,25 @@ provider lives in exactly one module."""from app.services.dns.base import DnsCredential, DnsRecordSpecfrom app.services.dns.cloudflare import CloudflareClient+from app.services.dns.providers import (+ DigitalOceanClient,+ GoDaddyClient,+ Route53Client,+ get_record_client,+)-__all__ = ['DnsCredential', 'DnsRecordSpec', 'CloudflareClient', 'get_client']+__all__ = [+ 'DnsCredential', 'DnsRecordSpec', 'CloudflareClient', 'Route53Client',+ 'DigitalOceanClient', 'GoDaddyClient', 'get_client', 'get_record_client',+]def get_client(credential: DnsCredential):"""Return the API client for ``credential.provider``.- Only Cloudflare is shared today (it was the duplicated path); Route53 /- DigitalOcean / GoDaddy still live in ``DNSProviderService`` and can move- behind this factory later without changing callers.+ This legacy factory remains Cloudflare-only because DNS cutover currently+ has Cloudflare-specific snapshot semantics. Record-management callers use+ ``get_record_client`` for the four-provider contract."""if credential.provider == 'cloudflare':return CloudflareClient(credential)diff --git a/backend/app/services/dns/base.py b/backend/app/services/dns/base.pyindex b9e338b0..a9cbd273 100644--- a/backend/app/services/dns/base.py+++ b/backend/app/services/dns/base.py@@ -53,7 +53,7 @@ class DnsRecordSpec:content: strttl: int = 3600priority: Optional[int] = None # MX / SRV- proxied: bool = False # Cloudflare orange-cloud+ proxied: Optional[bool] = False # Cloudflare orange-cloud; None = legacy unknown@classmethoddef from_record(cls, record) -> 'DnsRecordSpec':diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.pyindex aced7f85..ce9ee400 100644--- a/backend/app/services/dns/cloudflare.py+++ b/backend/app/services/dns/cloudflare.py@@ -43,6 +43,17 @@ def _first_error(data: dict) -> str:return 'Unknown error'+def _is_missing_record(data: dict) -> bool:+ errors = data.get('errors') or []+ for error in errors:+ if error.get('code') in (81044, 81057):+ return True+ message = str(error.get('message') or '').lower()+ if 'does not exist' in message or 'not found' in message:+ return True+ return False++class CloudflareClient:"""Stateless wrapper around the Cloudflare v4 DNS API for one credential."""@@ -183,7 +194,10 @@ class CloudflareClient:f'{API_BASE}/zones/{zone_id}/dns_records?type={record_type}&name={name}',headers=self._headers(), timeout=15,)- existing = (resp.json() or {}).get('result', []) or []+ data = resp.json() or {}+ if data.get('success') is False:+ raise RuntimeError(_first_error(data))+ existing = data.get('result', []) or []if caa is not None:existing = [r for r in existing@@ -235,11 +249,21 @@ class CloudflareClient:else:resp = requests.get(f'{base}?type={record_type}&name={name}',headers=self._headers(), timeout=15)- ids = [r['id'] for r in (resp.json() or {}).get('result', []) or []]+ data = resp.json() or {}+ if data.get('success') is False:+ return {'success': False, 'error': _first_error(data)}+ ids = [r['id'] for r in data.get('result', []) or []]if not ids:return {'success': True, 'message': 'Record not found (already deleted)'}for rid in ids:- requests.delete(f'{base}/{rid}', headers=self._headers(), timeout=15)+ resp = requests.delete(+ f'{base}/{rid}', headers=self._headers(), timeout=15,+ )+ data = resp.json() or {}+ if data.get('success') is False:+ if _is_missing_record(data):+ continue+ return {'success': False, 'error': _first_error(data)}return {'success': True, 'message': 'Record deleted'}except Exception as e:return {'success': False, 'error': str(e)}diff --git a/backend/app/services/dns/providers.py b/backend/app/services/dns/providers.pynew file mode 100644index 00000000..12f6ac77--- /dev/null+++ b/backend/app/services/dns/providers.py@@ -0,0 +1,482 @@+"""Provider-agnostic record clients for Route53, DigitalOcean, and GoDaddy.++Each client exposes the same record surface as :class:`CloudflareClient`:+``list_records``, ``find_record_id``, ``upsert``, and ``delete``. The provider+connection service and restore-point replay can therefore use the ownership+door without knowing provider wire formats.+"""+import logging+from typing import Optional++import requests++from app.services.dns.base import DnsCredential, DnsRecordSpec+from app.services.dns.cloudflare import parse_caa_value++logger = logging.getLogger(__name__)+++def _fqdn(value: str) -> str:+ return (value or '').strip().lower().rstrip('.')+++def _relative_name(name: str, zone: str) -> str:+ name = _fqdn(name)+ zone = _fqdn(zone)+ if not zone or name == zone:+ return '@'+ if name.endswith('.' + zone):+ return name[:-len(zone) - 1]+ return name or '@'+++def _absolute_name(name: str, zone: str) -> str:+ name = (name or '@').strip().rstrip('.')+ zone = _fqdn(zone)+ if name in ('', '@'):+ return zone+ if _fqdn(name) == zone or _fqdn(name).endswith('.' + zone):+ return _fqdn(name)+ return f'{name}.{zone}'.lower()+++def _split_priority(spec: DnsRecordSpec):+ content = spec.content+ priority = spec.priority+ if spec.record_type in ('MX', 'SRV') and priority is None:+ head, _, rest = (content or '').strip().partition(' ')+ if head.isdigit() and rest.strip():+ priority, content = int(head), rest.strip()+ return content, priority+++def _http_error(response, data, fallback='Provider request failed'):+ if isinstance(data, dict):+ return data.get('message') or data.get('error') or fallback+ return f'HTTP {getattr(response, "status_code", "?")}: {fallback}'+++class Route53Client:+ """Normalized Route53 RRset client."""++ def __init__(self, credential: DnsCredential, client=None):+ self.cred = credential+ self._boto_client = client++ def _client(self):+ if self._boto_client is None:+ try:+ import boto3+ except ImportError as exc:+ raise RuntimeError(+ 'boto3 is required for Route53 integration. '+ 'Install with: pip install boto3'+ ) from exc+ self._boto_client = boto3.client(+ 'route53',+ aws_access_key_id=self.cred.token,+ aws_secret_access_key=self.cred.secret,+ )+ return self._boto_client++ @staticmethod+ def _record_id(record_type: str, name: str) -> str:+ # Route53 has no per-record id. Its mutation identity is the RRset key.+ return f'{record_type.upper()}:{_fqdn(name)}'++ @staticmethod+ def _content(record_type, value):+ value = str(value or '')+ if record_type == 'TXT' and len(value) >= 2 and value[0] == value[-1] == '"':+ return value[1:-1]+ return value.rstrip('.') if record_type in ('CNAME', 'NS', 'PTR') else value++ def list_records(self, zone_id: str) -> dict:+ try:+ out = []+ kwargs = {'HostedZoneId': zone_id}+ while True:+ response = self._client().list_resource_record_sets(**kwargs)+ for rrset in response.get('ResourceRecordSets', []):+ record_type = rrset.get('Type')+ name = _fqdn(rrset.get('Name'))+ ttl = rrset.get('TTL')+ values = rrset.get('ResourceRecords') or []+ for value in values:+ content = self._content(record_type, value.get('Value'))+ priority = None+ if record_type in ('MX', 'SRV'):+ head, _, rest = content.partition(' ')+ if head.isdigit() and rest:+ priority, content = int(head), rest+ out.append({+ 'id': self._record_id(record_type, name),+ 'type': record_type,+ 'name': name,+ 'content': content,+ 'ttl': ttl,+ 'priority': priority,+ 'proxied': False,+ })+ if not response.get('IsTruncated'):+ break+ kwargs.update({+ 'StartRecordName': response['NextRecordName'],+ 'StartRecordType': response['NextRecordType'],+ })+ if response.get('NextRecordIdentifier'):+ kwargs['StartRecordIdentifier'] = response['NextRecordIdentifier']+ return {'success': True, 'records': out}+ except Exception as exc:+ return {'success': False, 'error': str(exc)}++ def _find_rrset(self, zone_id, record_type, name):+ fqdn = f'{_fqdn(name)}.'+ response = self._client().list_resource_record_sets(+ HostedZoneId=zone_id,+ StartRecordName=fqdn,+ StartRecordType=record_type,+ MaxItems='1',+ )+ records = response.get('ResourceRecordSets', [])+ return next((+ item for item in records+ if _fqdn(item.get('Name')) == _fqdn(name)+ and item.get('Type') == record_type+ ), None)++ def find_record_id(self, zone_id: str, record_type: str, name: str,+ caa: dict = None):+ del caa # Route53 identity is the whole name+type RRset.+ rrset = self._find_rrset(zone_id, record_type, name)+ if rrset is None:+ return None+ return self._record_id(record_type, name)++ @staticmethod+ def _rrset(spec: DnsRecordSpec):+ content, priority = _split_priority(spec)+ if spec.record_type == 'TXT':+ content = f'"{content}"'+ elif spec.record_type == 'CAA':+ caa = parse_caa_value(content)+ content = f'{caa["flags"]} {caa["tag"]} "{caa["value"]}"'+ elif priority is not None:+ content = f'{priority} {content}'+ return {+ 'Name': f'{_fqdn(spec.name)}.',+ 'Type': spec.record_type,+ 'TTL': spec.ttl,+ 'ResourceRecords': [{'Value': content}],+ }++ def upsert(self, zone_id: str, spec: DnsRecordSpec,+ record_id: str = None) -> dict:+ try:+ self._client().change_resource_record_sets(+ HostedZoneId=zone_id,+ ChangeBatch={'Changes': [{+ 'Action': 'UPSERT',+ 'ResourceRecordSet': self._rrset(spec),+ }]},+ )+ return {+ 'success': True,+ 'record_id': self._record_id(spec.record_type, spec.name),+ 'message': f'{spec.record_type} record set for {spec.name}',+ }+ except Exception as exc:+ return {'success': False, 'error': str(exc)}++ def delete(self, zone_id: str, *, record_id: str = None,+ record_type: str = None, name: str = None) -> dict:+ try:+ rrset = self._find_rrset(zone_id, record_type, name)+ if rrset is None:+ return {'success': True, 'message': 'Record not found (already deleted)'}+ self._client().change_resource_record_sets(+ HostedZoneId=zone_id,+ ChangeBatch={'Changes': [{+ 'Action': 'DELETE',+ 'ResourceRecordSet': rrset,+ }]},+ )+ return {'success': True, 'message': f'{record_type} record deleted for {name}'}+ except Exception as exc:+ return {'success': False, 'error': str(exc)}+++class DigitalOceanClient:+ """Normalized DigitalOcean domain-record client."""++ API_BASE = 'https://api.digitalocean.com/v2'++ def __init__(self, credential: DnsCredential):+ self.cred = credential++ def _headers(self):+ return {+ 'Authorization': f'Bearer {self.cred.token or ""}',+ 'Content-Type': 'application/json',+ }++ def _raw_records(self, zone_id, record_type=None):+ params = '?per_page=200'+ if record_type:+ params += f'&type={record_type}'+ response = requests.get(+ f'{self.API_BASE}/domains/{zone_id}/records{params}',+ headers=self._headers(), timeout=15,+ )+ data = response.json()+ if response.status_code != 200:+ raise RuntimeError(_http_error(response, data))+ return data.get('domain_records', [])++ @staticmethod+ def _normalize(zone_id, record):+ content = record.get('data', '')+ priority = record.get('priority')+ if record.get('type') == 'CAA':+ content = f'{record.get("flags", 0)} {record.get("tag", "issue")} "{content}"'+ return {+ 'id': str(record.get('id')),+ 'type': record.get('type'),+ 'name': _absolute_name(record.get('name'), zone_id),+ 'content': content,+ 'ttl': record.get('ttl'),+ 'priority': priority,+ 'proxied': False,+ }++ def list_records(self, zone_id: str) -> dict:+ try:+ return {+ 'success': True,+ 'records': [self._normalize(zone_id, row) for row in self._raw_records(zone_id)],+ }+ except Exception as exc:+ return {'success': False, 'error': str(exc)}++ def find_record_id(self, zone_id: str, record_type: str, name: str,+ caa: dict = None):+ host = _relative_name(name, zone_id)+ for row in self._raw_records(zone_id, record_type):+ if row.get('name') != host:+ continue+ if caa is not None and (+ row.get('tag') != caa['tag']+ or str(row.get('data', '')).strip('"').rstrip('.').lower()+ != caa['value'].rstrip('.').lower()+ ):+ continue+ return str(row.get('id'))+ return None++ @staticmethod+ def _payload(zone_id, spec):+ content, priority = _split_priority(spec)+ payload = {+ 'type': spec.record_type,+ 'name': _relative_name(spec.name, zone_id),+ 'data': content,+ 'ttl': spec.ttl,+ }+ if priority is not None:+ payload['priority'] = priority+ if spec.record_type == 'CAA':+ caa = parse_caa_value(content)+ payload.update(data=caa['value'], flags=caa['flags'], tag=caa['tag'])+ return payload++ def upsert(self, zone_id: str, spec: DnsRecordSpec,+ record_id: str = None) -> dict:+ try:+ base = f'{self.API_BASE}/domains/{zone_id}/records'+ if record_id is None:+ caa = parse_caa_value(spec.content) if spec.record_type == 'CAA' else None+ record_id = self.find_record_id(+ zone_id, spec.record_type, spec.name, caa=caa,+ )+ payload = self._payload(zone_id, spec)+ if record_id:+ response = requests.put(+ f'{base}/{record_id}', headers=self._headers(),+ json=payload, timeout=15,+ )+ else:+ response = requests.post(+ base, headers=self._headers(), json=payload, timeout=15,+ )+ data = response.json()+ if response.status_code not in (200, 201):+ return {'success': False, 'error': _http_error(response, data)}+ result_id = (data.get('domain_record') or {}).get('id') or record_id+ return {+ 'success': True,+ 'record_id': str(result_id) if result_id is not None else None,+ 'message': f'{spec.record_type} record set for {spec.name}',+ }+ except Exception as exc:+ return {'success': False, 'error': str(exc)}++ def delete(self, zone_id: str, *, record_id: str = None,+ record_type: str = None, name: str = None) -> dict:+ try:+ ids = [record_id] if record_id else []+ if not ids:+ host = _relative_name(name, zone_id)+ ids = [+ str(row['id']) for row in self._raw_records(zone_id, record_type)+ if row.get('name') == host+ ]+ if not ids:+ return {'success': True, 'message': 'Record not found (already deleted)'}+ for item_id in ids:+ response = requests.delete(+ f'{self.API_BASE}/domains/{zone_id}/records/{item_id}',+ headers=self._headers(), timeout=15,+ )+ if response.status_code == 404:+ continue+ if response.status_code not in (200, 204):+ try:+ data = response.json()+ except ValueError:+ data = {}+ return {'success': False, 'error': _http_error(response, data)}+ return {'success': True, 'message': f'{record_type} record deleted for {name}'}+ except Exception as exc:+ return {'success': False, 'error': str(exc)}+++class GoDaddyClient:+ """Normalized GoDaddy record-set client."""++ API_BASE = 'https://api.godaddy.com/v1'++ def __init__(self, credential: DnsCredential):+ self.cred = credential++ def _headers(self):+ return {+ 'Authorization': f'sso-key {self.cred.token or ""}:{self.cred.secret or ""}',+ 'Content-Type': 'application/json',+ }++ @staticmethod+ def _record_id(record_type, name):+ return f'{record_type.upper()}:{name}'++ def _raw_records(self, zone_id, record_type=None, name=None):+ url = f'{self.API_BASE}/domains/{zone_id}/records'+ if record_type:+ url += f'/{record_type}'+ if name is not None:+ url += f'/{name}'+ response = requests.get(url, headers=self._headers(), timeout=15)+ data = response.json()+ if response.status_code != 200:+ raise RuntimeError(_http_error(response, data))+ return data or []++ @staticmethod+ def _normalize(zone_id, row):+ content = row.get('data', '')+ priority = row.get('priority')+ if row.get('type') == 'CAA':+ content = f'{row.get("flags", 0)} {row.get("tag", "issue")} "{content}"'+ return {+ 'id': GoDaddyClient._record_id(row.get('type'), row.get('name')),+ 'type': row.get('type'),+ 'name': _absolute_name(row.get('name'), zone_id),+ 'content': content,+ 'ttl': row.get('ttl'),+ 'priority': priority,+ 'proxied': False,+ }++ def list_records(self, zone_id: str) -> dict:+ try:+ return {+ 'success': True,+ 'records': [self._normalize(zone_id, row) for row in self._raw_records(zone_id)],+ }+ except Exception as exc:+ return {'success': False, 'error': str(exc)}++ def find_record_id(self, zone_id: str, record_type: str, name: str,+ caa: dict = None):+ del caa # GoDaddy PUT addresses/replaces the whole name+type RRset.+ host = _relative_name(name, zone_id)+ rows = self._raw_records(zone_id, record_type, host)+ return self._record_id(record_type, host) if rows else None++ @staticmethod+ def _payload(spec):+ content, priority = _split_priority(spec)+ row = {'data': content, 'ttl': spec.ttl}+ if priority is not None:+ row['priority'] = priority+ if spec.record_type == 'CAA':+ caa = parse_caa_value(content)+ row.update(data=caa['value'], flags=caa['flags'], tag=caa['tag'])+ return row++ def upsert(self, zone_id: str, spec: DnsRecordSpec,+ record_id: str = None) -> dict:+ try:+ host = _relative_name(spec.name, zone_id)+ response = requests.put(+ f'{self.API_BASE}/domains/{zone_id}/records/{spec.record_type}/{host}',+ headers=self._headers(), json=[self._payload(spec)], timeout=15,+ )+ if response.status_code not in (200, 201, 204):+ try:+ data = response.json()+ except ValueError:+ data = {}+ return {'success': False, 'error': _http_error(response, data)}+ return {+ 'success': True,+ 'record_id': self._record_id(spec.record_type, host),+ 'message': f'{spec.record_type} record set for {spec.name}',+ }+ except Exception as exc:+ return {'success': False, 'error': str(exc)}++ def delete(self, zone_id: str, *, record_id: str = None,+ record_type: str = None, name: str = None) -> dict:+ try:+ host = _relative_name(name, zone_id)+ response = requests.delete(+ f'{self.API_BASE}/domains/{zone_id}/records/{record_type}/{host}',+ headers=self._headers(), timeout=15,+ )+ if response.status_code in (200, 204, 404):+ message = ('Record not found (already deleted)'+ if response.status_code == 404+ else f'{record_type} record deleted for {name}')+ return {'success': True, 'message': message}+ try:+ data = response.json()+ except ValueError:+ data = {}+ return {'success': False, 'error': _http_error(response, data)}+ except Exception as exc:+ return {'success': False, 'error': str(exc)}+++def get_record_client(credential: DnsCredential, *, route53_client=None):+ """Build a normalized record client for every supported provider."""+ provider = (credential.provider or '').lower()+ if provider == 'cloudflare':+ from app.services.dns.cloudflare import CloudflareClient+ return CloudflareClient(credential)+ if provider == 'route53':+ return Route53Client(credential, client=route53_client)+ if provider == 'digitalocean':+ return DigitalOceanClient(credential)+ if provider == 'godaddy':+ return GoDaddyClient(credential)+ raise ValueError(f'No DNS record client for provider: {credential.provider}')diff --git a/backend/app/services/dns_change_service.py b/backend/app/services/dns_change_service.pyindex 964cfb81..891a6f82 100644--- a/backend/app/services/dns_change_service.py+++ b/backend/app/services/dns_change_service.py@@ -6,6 +6,7 @@ Recording happens at the single write choke pointconnection is a complete, honest account of what the panel changed in the user'szone — successes, foreign-record refusals, and failures alike."""+import jsonimport loggingfrom app import db@@ -19,7 +20,7 @@ class DnsChangeService:@staticmethoddef record(*, provider, provider_zone_id, action, record_type=None, name=None,content=None, provider_record_id=None, source=None, result='ok',- error=None, config_id=None):+ error=None, config_id=None, before=None):"""Append a change to the log. On a real failure (``result == 'error'``) alsosurface an admin-facing notice. Never raises — logging a change must not breakthe write it describes."""@@ -27,6 +28,8 @@ class DnsChangeService:row = DnsChange(provider=provider, provider_zone_id=provider_zone_id, action=action,record_type=record_type, name=name, content=content,+ before_json=(json.dumps(before, sort_keys=True, separators=(',', ':'))+ if isinstance(before, (dict, list)) else before),provider_record_id=provider_record_id, source=source,result=result, error=error, dns_provider_config_id=config_id)db.session.add(row)diff --git a/backend/app/services/dns_ownership_service.py b/backend/app/services/dns_ownership_service.pyindex 9833755f..b384883f 100644--- a/backend/app/services/dns_ownership_service.py+++ b/backend/app/services/dns_ownership_service.py@@ -20,39 +20,127 @@ from app.models.managed_dns_record import ManagedDnsRecordlogger = logging.getLogger(__name__)+_UNSET = object()+LEGACY_DNS_CONFIG = 'legacy'+++def dns_scope_id(provider, config_id, provider_zone_id):+ """Stable restore-point scope: provider:config-or-legacy:zone."""+ config_key = LEGACY_DNS_CONFIG if config_id is None else str(config_id)+ return f'{str(provider).lower()}:{config_key}:{provider_zone_id}'+++def parse_dns_scope_id(scope_id):+ """Return ``(provider, config_id|None, provider_zone_id)``."""+ try:+ provider, config_key, provider_zone_id = str(scope_id).split(':', 2)+ except ValueError as exc:+ raise ValueError('DNS scope must be provider:config-or-legacy:zone') from exc+ if not provider or not provider_zone_id:+ raise ValueError('DNS scope must include provider and zone')+ if config_key == LEGACY_DNS_CONFIG:+ config_id = None+ else:+ try:+ config_id = int(config_key)+ except (TypeError, ValueError) as exc:+ raise ValueError('DNS scope has an invalid provider configuration') from exc+ return provider.lower(), config_id, provider_zone_id+class DnsOwnershipService:+ @staticmethod+ def scope_id(provider, config_id, provider_zone_id):+ return dns_scope_id(provider, config_id, provider_zone_id)++ @staticmethod+ def _scope_query(provider_zone_id, *, provider=None, config_id=_UNSET):+ query = ManagedDnsRecord.query.filter_by(+ provider_zone_id=provider_zone_id,+ )+ if provider is not None:+ query = query.filter_by(provider=str(provider).lower())+ if config_id is not _UNSET:+ if config_id is None:+ query = query.filter(ManagedDnsRecord.dns_provider_config_id.is_(None))+ else:+ query = query.filter_by(dns_provider_config_id=config_id)+ return query+# ── ledger reads ─────────────────────────────────────────────────────────@staticmethod- def _row(provider_zone_id, record_type, name):- return ManagedDnsRecord.query.filter_by(- provider_zone_id=provider_zone_id, record_type=record_type, name=name).first()+ def _row(provider_zone_id, record_type, name, *, provider=None,+ config_id=_UNSET):+ """One owned RRset, scoped so identical provider zone ids cannot collide."""+ normalized_type = str(record_type or '').upper()+ normalized_name = str(name or '').lower().rstrip('.')+ query = DnsOwnershipService._scope_query(+ provider_zone_id, provider=provider, config_id=config_id,+ ).filter_by(record_type=normalized_type)+ return query.filter(+ db.func.lower(db.func.rtrim(ManagedDnsRecord.name, '.'))+ == normalized_name,+ ).first()@staticmethod- def owns(provider_zone_id, *, provider_record_id=None, record_type=None, name=None):+ def _row_by_id(provider_zone_id, provider_record_id, *, provider=None,+ config_id=_UNSET):+ return DnsOwnershipService._scope_query(+ provider_zone_id, provider=provider, config_id=config_id,+ ).filter_by(provider_record_id=provider_record_id).first()++ @staticmethod+ def record_payload(row):+ """Complete managed DNS pre-image used by restore points/change rows."""+ if row is None:+ return None+ return {+ 'record_type': row.record_type,+ 'name': row.name,+ 'content': row.content,+ 'ttl': row.ttl,+ 'priority': row.priority,+ 'proxied': row.proxied,+ 'source': row.source,+ 'app_id': row.app_id,+ }++ @staticmethod+ def owns(provider_zone_id, *, provider_record_id=None, record_type=None,+ name=None, provider=None, config_id=_UNSET):"""Whether ServerKit created the matching record (by provider record id, orby type+name)."""- q = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id)+ q = DnsOwnershipService._scope_query(+ provider_zone_id, provider=provider, config_id=config_id,+ )if provider_record_id:q = q.filter_by(provider_record_id=provider_record_id)elif record_type and name:- q = q.filter_by(record_type=record_type, name=name)+ return DnsOwnershipService._row(+ provider_zone_id, record_type, name,+ provider=provider, config_id=config_id,+ ) is not Noneelse:return Falsereturn q.first() is not None@staticmethod- def owned_keys(provider_zone_id):+ def owned_keys(provider_zone_id, *, provider=None, config_id=_UNSET):"""``(record_id set, (type, lower-name) set)`` for fast mirror classification."""- rows = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id).all()+ rows = DnsOwnershipService._scope_query(+ provider_zone_id, provider=provider, config_id=config_id,+ ).all()ids = {r.provider_record_id for r in rows if r.provider_record_id}- keys = {(r.record_type, (r.name or '').lower().rstrip('.')) for r in rows}+ keys = {((r.record_type or '').upper(), (r.name or '').lower().rstrip('.'))+ for r in rows}return ids, keys@staticmethod- def list_for_zone(provider_zone_id):- return ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id).all()+ def list_for_zone(provider_zone_id, *, provider=None, config_id=_UNSET):+ return DnsOwnershipService._scope_query(+ provider_zone_id, provider=provider, config_id=config_id,+ ).all()@staticmethoddef list_all():@@ -63,8 +151,15 @@ class DnsOwnershipService:@staticmethoddef record_write(provider, provider_zone_id, record_type, name, *,provider_record_id=None, content=None, source=None,- app_id=None, config_id=None):- row = DnsOwnershipService._row(provider_zone_id, record_type, name)+ app_id=None, config_id=None, ttl=None, priority=None,+ proxied=None):+ provider = str(provider).lower()+ record_type = str(record_type).upper()+ name = str(name).lower().rstrip('.')+ row = DnsOwnershipService._row(+ provider_zone_id, record_type, name,+ provider=provider, config_id=config_id,+ )if row is None:row = ManagedDnsRecord(provider=provider, provider_zone_id=provider_zone_id,record_type=record_type, name=name)@@ -72,6 +167,9 @@ class DnsOwnershipService:if provider_record_id:row.provider_record_id = provider_record_idrow.content = content+ row.ttl = ttl+ row.priority = priority+ row.proxied = proxiedif source:row.source = sourceif app_id is not None:@@ -82,12 +180,20 @@ class DnsOwnershipService:return row@staticmethod- def record_delete(provider_zone_id, *, record_type=None, name=None, provider_record_id=None):- q = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id)+ def record_delete(provider_zone_id, *, record_type=None, name=None,+ provider_record_id=None, provider=None,+ config_id=_UNSET):+ q = DnsOwnershipService._scope_query(+ provider_zone_id, provider=provider, config_id=config_id,+ )if provider_record_id:q = q.filter_by(provider_record_id=provider_record_id)elif record_type and name:- q = q.filter_by(record_type=record_type, name=name)+ normalized_name = str(name).lower().rstrip('.')+ q = q.filter_by(record_type=str(record_type).upper()).filter(+ db.func.lower(db.func.rtrim(ManagedDnsRecord.name, '.'))+ == normalized_name,+ )else:return 0n = q.delete()@@ -107,13 +213,40 @@ class DnsOwnershipService:"""from app.services.dns.cloudflare import parse_caa_valuefrom app.services.dns_change_service import DnsChangeService+ from app.services.restore_point_service import auto_capture++ provider = str(provider).lower()+ spec.record_type = str(spec.record_type).upper()+ spec.name = str(spec.name).lower().rstrip('.')+ if spec.record_type in ('MX', 'SRV') and spec.priority is None:+ head, _, rest = str(spec.content or '').strip().partition(' ')+ if head.isdigit() and rest.strip():+ # Canonicalize once at the door so every provider and the+ # ownership ledger see complete, replayable priority data.+ spec.priority = int(head)+ spec.content = rest.strip()++ before_row = DnsOwnershipService._row(+ provider_zone_id, spec.record_type, spec.name,+ provider=provider, config_id=config_id,+ )+ before = DnsOwnershipService.record_payload(before_row)record_id = known_record_idif record_id is None:caa = parse_caa_value(spec.content) if spec.record_type == 'CAA' else None- existing = client.find_record_id(provider_zone_id, spec.record_type, spec.name, caa=caa)+ existing = client.find_record_id(+ provider_zone_id, spec.record_type, spec.name, caa=caa,+ )if existing:- if DnsOwnershipService.owns(provider_zone_id, provider_record_id=existing):+ owns_existing_id = DnsOwnershipService.owns(+ provider_zone_id, provider_record_id=existing,+ provider=provider, config_id=config_id,+ )+ owns_rrset_without_id = (+ before_row is not None and not before_row.provider_record_id+ )+ if owns_existing_id or owns_rrset_without_id:record_id = existing # ours — update in placeelif allow_foreign:record_id = existing # explicit management — adopt it@@ -125,22 +258,29 @@ class DnsOwnershipService:DnsChangeService.record(provider=provider, provider_zone_id=provider_zone_id, action='create',record_type=spec.record_type, name=spec.name, content=spec.content,- source=source, result='conflict', error=msg, config_id=config_id)+ source=source, result='conflict', error=msg,+ config_id=config_id, before=before)return {'success': False, 'conflict': True, 'error': msg}- action = 'update' if record_id else 'create'+ action = 'update' if record_id or before_row is not None else 'create'+ auto_capture(+ 'dns', dns_scope_id(provider, config_id, provider_zone_id),+ f'upsert {spec.record_type} {spec.name}',+ )res = client.upsert(provider_zone_id, spec, record_id=record_id)if res.get('success'):DnsOwnershipService.record_write(provider, provider_zone_id, spec.record_type, spec.name,provider_record_id=res.get('record_id'), content=spec.content,- source=source, app_id=app_id, config_id=config_id)+ source=source, app_id=app_id, config_id=config_id,+ ttl=spec.ttl, priority=spec.priority, proxied=spec.proxied)DnsChangeService.record(provider=provider, provider_zone_id=provider_zone_id, action=action,record_type=spec.record_type, name=spec.name, content=spec.content,provider_record_id=res.get('record_id'), source=source,result='ok' if res.get('success') else 'error',- error=None if res.get('success') else res.get('error'), config_id=config_id)+ error=None if res.get('success') else res.get('error'),+ config_id=config_id, before=before)return res@staticmethod@@ -149,20 +289,43 @@ class DnsOwnershipService:"""Delete only a record ServerKit owns; never a foreign one. Clears ourledger entry and logs the change on success."""from app.services.dns_change_service import DnsChangeService+ from app.services.restore_point_service import auto_capture++ provider = str(provider).lower()if provider_record_id:- owned = DnsOwnershipService.owns(provider_zone_id, provider_record_id=provider_record_id)+ owned_row = DnsOwnershipService._row_by_id(+ provider_zone_id, provider_record_id,+ provider=provider, config_id=config_id,+ )else:- owned = DnsOwnershipService.owns(provider_zone_id, record_type=record_type, name=name)- if not owned:+ owned_row = DnsOwnershipService._row(+ provider_zone_id, record_type, name,+ provider=provider, config_id=config_id,+ )+ if owned_row is None:return {'success': True, 'skipped': True,'message': 'No ServerKit-owned record to delete.'}++ before = DnsOwnershipService.record_payload(owned_row)+ provider_record_id = provider_record_id or owned_row.provider_record_id+ auto_capture(+ 'dns', dns_scope_id(provider, config_id, provider_zone_id),+ f'delete {record_type} {name}',+ )res = client.delete(provider_zone_id, record_id=provider_record_id,record_type=record_type, name=name)- DnsOwnershipService.record_delete(provider_zone_id, record_type=record_type,- name=name, provider_record_id=provider_record_id)+ # A failed provider delete must keep ownership. Otherwise a transient+ # failure turns our still-live record into one ServerKit now sees as foreign.+ if res.get('success'):+ DnsOwnershipService.record_delete(+ provider_zone_id, record_type=record_type, name=name,+ provider_record_id=provider_record_id, provider=provider,+ config_id=config_id,+ )DnsChangeService.record(provider=provider, provider_zone_id=provider_zone_id, action='delete',record_type=record_type, name=name, provider_record_id=provider_record_id,source=source, result='ok' if res.get('success') else 'error',- error=None if res.get('success') else res.get('error'), config_id=config_id)+ error=None if res.get('success') else res.get('error'),+ config_id=config_id, before=before)return resdiff --git a/backend/app/services/dns_provider_service.py b/backend/app/services/dns_provider_service.pyindex 38c74ff1..59e65f89 100644--- a/backend/app/services/dns_provider_service.py+++ b/backend/app/services/dns_provider_service.py@@ -145,40 +145,22 @@ class DNSProviderService:name: str, value: str, ttl: int = 3600,proxied: bool = False, priority: int = None,source: str = 'provider') -> Dict:- """Create or update a DNS record. ``proxied``/``priority`` are honored by- the Cloudflare path; other providers ignore them. ``source`` tags the write- in the ownership ledger."""+ """Create or update through the common client + ownership door."""config = DNSProviderConfig.query.get(provider_id)if not config:return {'success': False, 'error': 'Provider not found'}-- if config.provider == 'cloudflare':- return cls._cloudflare_set_record(config, zone_id, record_type, name, value, ttl,- proxied=proxied, priority=priority, source=source)- elif config.provider == 'route53':- return cls._route53_set_record(config, zone_id, record_type, name, value, ttl)- elif config.provider == 'digitalocean':- return cls._digitalocean_set_record(config, zone_id, record_type, name, value, ttl)- elif config.provider == 'godaddy':- return cls._godaddy_set_record(config, zone_id, record_type, name, value, ttl)- return {'success': False, 'error': 'Unknown provider'}+ return cls._guarded_set_record(+ config, zone_id, record_type, name, value, ttl,+ proxied=proxied, priority=priority, source=source,+ )@classmethoddef delete_record(cls, provider_id: int, zone_id: str, record_type: str, name: str) -> Dict:- """Delete a DNS record."""+ """Delete through the common client + ownership door."""config = DNSProviderConfig.query.get(provider_id)if not config:return {'success': False, 'error': 'Provider not found'}-- if config.provider == 'cloudflare':- return cls._cloudflare_delete_record(config, zone_id, record_type, name)- elif config.provider == 'route53':- return cls._route53_delete_record(config, zone_id, record_type, name)- elif config.provider == 'digitalocean':- return cls._digitalocean_delete_record(config, zone_id, record_type, name)- elif config.provider == 'godaddy':- return cls._godaddy_delete_record(config, zone_id, record_type, name)- return {'success': False, 'error': 'Unknown provider'}+ return cls._guarded_delete_record(config, zone_id, record_type, name)@classmethoddef deploy_email_records(cls, provider_id: int, zone_id: str, domain: str,@@ -270,6 +252,58 @@ class DNSProviderService:from app.services.dns.cloudflare import parse_caa_value as _parsereturn _parse(value)+ @classmethod+ def record_client(cls, config: DNSProviderConfig):+ """Build the normalized record client for a connected provider."""+ from app.services.dns import get_record_client+ from app.services.dns.base import DnsCredential+ return get_record_client(DnsCredential.from_provider_config(config))++ @classmethod+ def _guarded_set_record(cls, config, zone_id, record_type, name, value,+ ttl=3600, *, proxied=False, priority=None,+ source='provider'):+ from app.services.dns.base import DnsRecordSpec+ from app.services.dns_ownership_service import DnsOwnershipService++ spec = DnsRecordSpec(+ record_type=record_type, name=name, content=value, ttl=ttl,+ priority=priority, proxied=proxied,+ )+ try:+ result = DnsOwnershipService.guarded_upsert(+ cls.record_client(config), provider=config.provider,+ provider_zone_id=zone_id, spec=spec, source=source,+ config_id=config.id, allow_foreign=False,+ )+ except (TypeError, ValueError, RuntimeError) as exc:+ return {'success': False, 'error': str(exc)}++ if result.get('success'):+ return {+ 'success': True,+ 'message': result.get(+ 'message', f'{record_type} record set for {name}',+ ),+ }+ output = {'success': False, 'error': result.get('error', 'Unknown error')}+ if result.get('conflict'):+ output['conflict'] = True+ return output++ @classmethod+ def _guarded_delete_record(cls, config, zone_id, record_type, name,+ *, source='provider'):+ from app.services.dns_ownership_service import DnsOwnershipService+ try:+ return DnsOwnershipService.guarded_delete(+ cls.record_client(config), provider=config.provider,+ provider_zone_id=zone_id, record_type=record_type, name=name,+ source=source, config_id=config.id,+ )+ except (TypeError, ValueError, RuntimeError) as exc:+ return {'success': False, 'error': str(exc)}+@classmethoddef ensure_caa_record(cls, domain: str, ca: str = 'letsencrypt.org') -> Dict:"""Ensure a CAA record authorizing ``ca`` (default Let's Encrypt) exists at@@ -332,34 +366,17 @@ class DNSProviderService:record_type: str, name: str, value: str, ttl: int,proxied: bool = False, priority: int = None,source: str = 'provider') -> Dict:- """Create or update a Cloudflare DNS record (idempotent upsert by name),- gated by the ownership guard so an automatic write never clobbers a record- the user created themselves."""- from app.services.dns.base import DnsRecordSpec- from app.services.dns_ownership_service import DnsOwnershipService- spec = DnsRecordSpec(record_type=record_type, name=name, content=value,- ttl=ttl, priority=priority, proxied=proxied)- res = DnsOwnershipService.guarded_upsert(- cls._cloudflare_client(config), provider='cloudflare', provider_zone_id=zone_id,- spec=spec, source=source, config_id=config.id, allow_foreign=False)- # Preserve the historical {success, message|error} contract callers expect.- if res.get('success'):- return {'success': True,- 'message': res.get('message', f'{record_type} record set for {name}')}- out = {'success': False, 'error': res.get('error', 'Unknown error')}- if res.get('conflict'):- out['conflict'] = True- return out+ return cls._guarded_set_record(+ config, zone_id, record_type, name, value, ttl,+ proxied=proxied, priority=priority, source=source,+ )@classmethoddef _cloudflare_delete_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str) -> Dict:"""Delete a Cloudflare DNS record ServerKit owns (by type+name); a foreignrecord with that name is left untouched."""- from app.services.dns_ownership_service import DnsOwnershipService- return DnsOwnershipService.guarded_delete(- cls._cloudflare_client(config), provider_zone_id=zone_id,- record_type=record_type, name=name, config_id=config.id)+ return cls._guarded_delete_record(config, zone_id, record_type, name)@staticmethoddef _host_relative_to_zone(name: str, zone: str) -> str:@@ -425,71 +442,14 @@ class DNSProviderService:@classmethoddef _route53_set_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str, value: str, ttl: int) -> Dict:- """Create or update a Route53 DNS record."""- try:- client = cls._get_route53_client(config)- # Ensure name ends with a dot for Route53- fqdn = name if name.endswith('.') else f'{name}.'-- resource_record = {'Value': value}- if record_type == 'TXT':- # TXT records need to be quoted- resource_record = {'Value': f'"{value}"'}- elif record_type == 'MX':- resource_record = {'Value': value}-- client.change_resource_record_sets(- HostedZoneId=zone_id,- ChangeBatch={- 'Changes': [{- 'Action': 'UPSERT',- 'ResourceRecordSet': {- 'Name': fqdn,- 'Type': record_type,- 'TTL': ttl,- 'ResourceRecords': [resource_record],- }- }]- }- )- return {'success': True, 'message': f'{record_type} record set for {name}'}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._guarded_set_record(+ config, zone_id, record_type, name, value, ttl,+ )@classmethoddef _route53_delete_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str) -> Dict:- """Delete a Route53 DNS record."""- try:- client = cls._get_route53_client(config)- fqdn = name if name.endswith('.') else f'{name}.'-- # Get current record to know its value (required for DELETE)- resp = client.list_resource_record_sets(- HostedZoneId=zone_id,- StartRecordName=fqdn,- StartRecordType=record_type,- MaxItems='1',- )- records = resp.get('ResourceRecordSets', [])- matching = [r for r in records if r['Name'] == fqdn and r['Type'] == record_type]-- if not matching:- return {'success': True, 'message': 'Record not found (already deleted)'}-- record = matching[0]- client.change_resource_record_sets(- HostedZoneId=zone_id,- ChangeBatch={- 'Changes': [{- 'Action': 'DELETE',- 'ResourceRecordSet': record,- }]- }- )- return {'success': True, 'message': f'{record_type} record deleted for {name}'}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._guarded_delete_record(config, zone_id, record_type, name)# ── DigitalOcean Implementation ──@@ -538,75 +498,14 @@ class DNSProviderService:@classmethoddef _digitalocean_set_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str, value: str, ttl: int) -> Dict:- """Create or update a DigitalOcean DNS record (zone_id is the domain)."""- try:- headers = cls._digitalocean_headers(config)- base = f'https://api.digitalocean.com/v2/domains/{zone_id}/records'- host = cls._host_relative_to_zone(name, zone_id)-- payload = {'type': record_type, 'name': host, 'data': value, 'ttl': ttl}- if record_type == 'MX':- # Input is "<priority> <target>"; split into priority + data.- parts = value.split(None, 1)- if len(parts) == 2 and parts[0].isdigit():- payload['priority'] = int(parts[0])- payload['data'] = parts[1]- elif record_type == 'CAA':- # DigitalOcean wants flags/tag as separate fields, data = CA value.- caa = cls.parse_caa_value(value)- payload['flags'] = caa['flags']- payload['tag'] = caa['tag']- payload['data'] = caa['value']-- # Find an existing record of the same type/host to update.- resp = requests.get(- f'{base}?type={record_type}&per_page=200',- headers=headers, timeout=15,- )- data = resp.json()- existing = [r for r in data.get('domain_records', []) if r.get('name') == host]-- if existing:- record_id = existing[0]['id']- resp = requests.put(- f'{base}/{record_id}',- headers=headers, json=payload, timeout=15,- )- else:- resp = requests.post(base, headers=headers, json=payload, timeout=15)-- if resp.status_code in (200, 201):- return {'success': True, 'message': f'{record_type} record set for {name}'}- data = resp.json()- return {'success': False, 'error': data.get('message', f'HTTP {resp.status_code}')}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._guarded_set_record(+ config, zone_id, record_type, name, value, ttl,+ )@classmethoddef _digitalocean_delete_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str) -> Dict:- """Delete a DigitalOcean DNS record (zone_id is the domain)."""- try:- headers = cls._digitalocean_headers(config)- base = f'https://api.digitalocean.com/v2/domains/{zone_id}/records'- host = cls._host_relative_to_zone(name, zone_id)-- resp = requests.get(- f'{base}?type={record_type}&per_page=200',- headers=headers, timeout=15,- )- data = resp.json()- existing = [r for r in data.get('domain_records', []) if r.get('name') == host]-- if not existing:- return {'success': True, 'message': 'Record not found (already deleted)'}-- for record in existing:- requests.delete(f'{base}/{record["id"]}', headers=headers, timeout=15)-- return {'success': True, 'message': f'{record_type} record deleted for {name}'}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._guarded_delete_record(config, zone_id, record_type, name)# ── GoDaddy Implementation ──@@ -656,43 +555,11 @@ class DNSProviderService:@classmethoddef _godaddy_set_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str, value: str, ttl: int) -> Dict:- """Create or update a GoDaddy DNS record (record-typed PUT, zone_id is the domain)."""- try:- headers = cls._godaddy_headers(config)- host = cls._host_relative_to_zone(name, zone_id)- url = f'https://api.godaddy.com/v1/domains/{zone_id}/records/{record_type}/{host}'-- record = {'data': value, 'ttl': ttl}- if record_type == 'MX':- # Input is "<priority> <target>"; GoDaddy wants priority + data.- parts = value.split(None, 1)- if len(parts) == 2 and parts[0].isdigit():- record['priority'] = int(parts[0])- record['data'] = parts[1]-- resp = requests.put(url, headers=headers, json=[record], timeout=15)- if resp.status_code in (200, 201):- return {'success': True, 'message': f'{record_type} record set for {name}'}- data = resp.json()- return {'success': False, 'error': data.get('message', f'HTTP {resp.status_code}')}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._guarded_set_record(+ config, zone_id, record_type, name, value, ttl,+ )@classmethoddef _godaddy_delete_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str) -> Dict:- """Delete a GoDaddy DNS record (record-typed DELETE, zone_id is the domain)."""- try:- headers = cls._godaddy_headers(config)- host = cls._host_relative_to_zone(name, zone_id)- url = f'https://api.godaddy.com/v1/domains/{zone_id}/records/{record_type}/{host}'-- resp = requests.delete(url, headers=headers, timeout=15)- if resp.status_code in (200, 204):- return {'success': True, 'message': f'{record_type} record deleted for {name}'}- if resp.status_code == 404:- return {'success': True, 'message': 'Record not found (already deleted)'}- data = resp.json()- return {'success': False, 'error': data.get('message', f'HTTP {resp.status_code}')}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._guarded_delete_record(config, zone_id, record_type, name)diff --git a/backend/app/services/dns_zone_service.py b/backend/app/services/dns_zone_service.pyindex c2eeb1a0..03cbbc04 100644--- a/backend/app/services/dns_zone_service.py+++ b/backend/app/services/dns_zone_service.py@@ -289,7 +289,16 @@ class DNSZoneService:if not res.get('success'):return res- owned_ids, owned_keys = DnsOwnershipService.owned_keys(zone.provider_zone_id)+ owned_ids, owned_keys = DnsOwnershipService.owned_keys(+ zone.provider_zone_id, provider=zone.provider,+ config_id=zone.dns_provider_config_id,+ )+ if zone.dns_provider_config_id is not None:+ legacy_ids, legacy_keys = DnsOwnershipService.owned_keys(+ zone.provider_zone_id, provider=zone.provider, config_id=None,+ )+ owned_ids |= legacy_ids+ owned_keys |= legacy_keysrecords = []for r in res['records']:owned = (r['id'] in owned_ids) or \@@ -326,7 +335,14 @@ class DNSZoneService:res = CloudflareClient(DnsCredential.from_provider_config(config)).list_records(provider_zone_id)if not res.get('success'):return res- owned_ids, owned_keys = DnsOwnershipService.owned_keys(provider_zone_id)+ owned_ids, owned_keys = DnsOwnershipService.owned_keys(+ provider_zone_id, provider=config.provider, config_id=config.id,+ )+ legacy_ids, legacy_keys = DnsOwnershipService.owned_keys(+ provider_zone_id, provider=config.provider, config_id=None,+ )+ owned_ids |= legacy_ids+ owned_keys |= legacy_keysrecords = []for r in res['records']:owned = (r['id'] in owned_ids) or \diff --git a/backend/app/services/env_service.py b/backend/app/services/env_service.pyindex b7bdfebe..459007c0 100644--- a/backend/app/services/env_service.py+++ b/backend/app/services/env_service.py@@ -7,6 +7,7 @@ including encryption, history tracking, and .env file operations.import loggingimport re+import uuidfrom app import dbfrom app.models import Application, EnvironmentVariable, EnvironmentVariableHistory@@ -17,6 +18,20 @@ logger = logging.getLogger(__name__)_UNSET = object()+def _new_batch_id():+ """Return the shared ledger id for one multi-variable operation."""+ return str(uuid.uuid4())+++def _auto_capture(application_id, action, user_id):+ """Best-effort checkpoint immediately before an env mutation."""+ from app.services.restore_point_service import auto_capture++ return auto_capture(+ 'env', str(application_id), action, actor=user_id,+ )++class EnvService:"""Service for managing application environment variables."""@@ -112,7 +127,9 @@ class EnvService:return ''@staticmethod- def set_env_reference(application_id, key, reference, user_id=None, target_service=_UNSET):+ def set_env_reference(application_id, key, reference, user_id=None,+ target_service=_UNSET, description=_UNSET,+ batch_id=None):"""Create/update a variable that resolves from a reference (manifest).``reference`` is a dict e.g. {'kind':'secret','secret':'name'} or@@ -128,12 +145,20 @@ class EnvService:norm_target = None if target_service in ('', _UNSET) else target_serviceexisting = EnvService.get_env_var(application_id, key)+ _auto_capture(application_id, 'env.set_env_reference', user_id)if existing:+ old_value = '<reference>' if existing.get_reference() else existing.valueexisting.set_reference(reference)existing.is_secret = Trueexisting.value = '' # clear any stored literalif target_service is not _UNSET:existing.target_service = norm_target+ if description is not _UNSET:+ existing.description = description+ EnvironmentVariableHistory.record_change(+ existing, 'updated', old_value=old_value,+ new_value='<reference>', user_id=user_id, batch_id=batch_id,+ )db.session.commit()return existing, False, None@@ -141,12 +166,16 @@ class EnvService:application_id=application_id, key=key, is_secret=True,target_service=norm_target, created_by=user_id,)+ if description is not _UNSET:+ env_var.description = descriptionenv_var.set_reference(reference)env_var.value = ''db.session.add(env_var)db.session.flush()- EnvironmentVariableHistory.record_change(env_var, 'created', new_value='<reference>',- user_id=user_id)+ EnvironmentVariableHistory.record_change(+ env_var, 'created', new_value='<reference>', user_id=user_id,+ batch_id=batch_id,+ )db.session.commit()return env_var, True, None@@ -214,7 +243,7 @@ class EnvService:@staticmethoddef set_env_var(application_id, key, value, is_secret=False, description=None,- user_id=None, target_service=_UNSET):+ user_id=None, target_service=_UNSET, batch_id=None):"""Set an environment variable (create or update).Returns (env_var, created, error)@@ -237,10 +266,15 @@ class EnvService:# Check if key already existsexisting = EnvService.get_env_var(application_id, key)+ _auto_capture(application_id, 'env.set_env_var', user_id)if existing:# Update existing- old_value = existing.value+ old_value = '<reference>' if existing.get_reference() else existing.value+ # A literal write intentionally replaces a manifest reference.+ # Restore code skips masked literals before reaching this door, so+ # a redaction sentinel can never accidentally clear a reference.+ existing.set_reference(None)existing.value = valueexisting.is_secret = is_secretif description is not None:@@ -250,7 +284,8 @@ class EnvService:# Record historyEnvironmentVariableHistory.record_change(- existing, 'updated', old_value=old_value, new_value=value, user_id=user_id+ existing, 'updated', old_value=old_value, new_value=value,+ user_id=user_id, batch_id=batch_id,)db.session.commit()@@ -272,25 +307,67 @@ class EnvService:# Record historyEnvironmentVariableHistory.record_change(- env_var, 'created', new_value=value, user_id=user_id+ env_var, 'created', new_value=value, user_id=user_id,+ batch_id=batch_id,)db.session.commit()return env_var, True, None@staticmethod- def delete_env_var(application_id, key, user_id=None):+ def update_env_var(application_id, key, *, value=_UNSET,+ is_secret=_UNSET, description=_UNSET,+ target_service=_UNSET, user_id=None, batch_id=None):+ """Update only supplied fields on an existing environment variable.++ This is the service-layer door used by the PUT controller. Keeping+ partial-update semantics here prevents API code from mutating ORM rows+ directly and ensures the restore-point hook cannot be bypassed.+ """+ existing = EnvService.get_env_var(application_id, key)+ if not existing:+ return None, 'Environment variable not found'++ if all(value is _UNSET for value in (+ value, is_secret, description, target_service)):+ return existing, None++ _auto_capture(application_id, 'env.update_env_var', user_id)++ old_value = '<reference>' if existing.get_reference() else existing.value+ if value is not _UNSET:+ existing.set_reference(None)+ existing.value = value+ if is_secret is not _UNSET:+ existing.is_secret = bool(is_secret)+ if description is not _UNSET:+ existing.description = description+ if target_service is not _UNSET:+ existing.target_service = target_service or None++ new_value = '<reference>' if existing.get_reference() else existing.value+ EnvironmentVariableHistory.record_change(+ existing, 'updated', old_value=old_value, new_value=new_value,+ user_id=user_id, batch_id=batch_id,+ )+ db.session.commit()+ return existing, None++ @staticmethod+ def delete_env_var(application_id, key, user_id=None, batch_id=None):"""Delete an environment variable. Returns (success, error)."""env_var = EnvService.get_env_var(application_id, key)if not env_var:return False, "Environment variable not found"- old_value = env_var.value+ _auto_capture(application_id, 'env.delete_env_var', user_id)+ old_value = '<reference>' if env_var.get_reference() else env_var.value# Record history before deletionEnvironmentVariableHistory.record_change(- env_var, 'deleted', old_value=old_value, user_id=user_id+ env_var, 'deleted', old_value=old_value, user_id=user_id,+ batch_id=batch_id,)db.session.delete(env_var)@@ -299,18 +376,22 @@ class EnvService:return True, None@staticmethod- def delete_env_var_by_id(env_var_id, user_id=None):+ def delete_env_var_by_id(env_var_id, user_id=None, batch_id=None):"""Delete an environment variable by ID. Returns (success, error)."""env_var = EnvironmentVariable.query.get(env_var_id)if not env_var:return False, "Environment variable not found"- old_value = env_var.value+ _auto_capture(+ env_var.application_id, 'env.delete_env_var_by_id', user_id,+ )+ old_value = '<reference>' if env_var.get_reference() else env_var.value# Record history before deletionEnvironmentVariableHistory.record_change(- env_var, 'deleted', old_value=old_value, user_id=user_id+ env_var, 'deleted', old_value=old_value, user_id=user_id,+ batch_id=batch_id,)db.session.delete(env_var)@@ -319,7 +400,8 @@ class EnvService:return True, None@staticmethod- def bulk_set_env_vars(application_id, env_vars_dict, user_id=None):+ def bulk_set_env_vars(application_id, env_vars_dict, user_id=None,+ batch_id=None):"""Set multiple environment variables at once.env_vars_dict: {key: value} or {key: {value, is_secret, description}}@@ -327,25 +409,34 @@ class EnvService:"""count = 0errors = []+ batch_id = batch_id or _new_batch_id()++ _auto_capture(application_id, 'env.bulk_set_env_vars', user_id)+ from app.services.restore_point_service import suppress_auto_capture++ with suppress_auto_capture():+ for key, val in env_vars_dict.items():+ if isinstance(val, dict):+ value = val.get('value', '')+ is_secret = val.get('is_secret', False)+ description = val.get('description')+ target_service = val.get('target_service', _UNSET)+ else:+ value = val+ is_secret = False+ description = None+ target_service = _UNSET++ env_var, created, error = EnvService.set_env_var(+ application_id, key, value, is_secret, description,+ user_id, target_service=target_service,+ batch_id=batch_id,+ )- for key, val in env_vars_dict.items():- if isinstance(val, dict):- value = val.get('value', '')- is_secret = val.get('is_secret', False)- description = val.get('description')- else:- value = val- is_secret = False- description = None-- env_var, created, error = EnvService.set_env_var(- application_id, key, value, is_secret, description, user_id- )-- if error:- errors.append(f"{key}: {error}")- else:- count += 1+ if error:+ errors.append(f"{key}: {error}")+ else:+ count += 1return count, errors@@ -471,16 +562,22 @@ class EnvService:return {ev.key: ev.value for ev in env_vars}@staticmethod- def clear_all(application_id, user_id=None):+ def clear_all(application_id, user_id=None, batch_id=None):"""Delete all environment variables for an application."""env_vars = EnvironmentVariable.query.filter_by(application_id=application_id).all()+ if env_vars:+ _auto_capture(application_id, 'env.clear_all', user_id)+ batch_id = batch_id or _new_batch_id()+count = 0for ev in env_vars:+ old_value = '<reference>' if ev.get_reference() else ev.valueEnvironmentVariableHistory.record_change(- ev, 'deleted', old_value=ev.value, user_id=user_id+ ev, 'deleted', old_value=old_value, user_id=user_id,+ batch_id=batch_id,)db.session.delete(ev)count += 1diff --git a/backend/app/services/firewall_service.py b/backend/app/services/firewall_service.pyindex bf2187d0..5cb0f8cd 100644--- a/backend/app/services/firewall_service.py+++ b/backend/app/services/firewall_service.py@@ -18,6 +18,24 @@ from app.utils.system import (class FirewallService:"""Service for managing firewall (firewalld or ufw)."""+ @classmethod+ def _checkpoint(cls, action: str, detail: str = ''):+ """Best-effort checkpoint immediately before an accepted mutation."""+ from flask import has_app_context++ if not has_app_context():+ return None+ from app.services.restore_point_service import auto_capture, get_adapter++ if get_adapter('firewall') is None:+ return None++ suffix = f' {detail}' if detail else ''+ return auto_capture(+ 'firewall', 'firewall', action,+ label=f'before firewall.{action}{suffix}',+ )+@classmethoddef get_status(cls) -> Dict:"""Get firewall status and detect which firewall is in use."""@@ -163,18 +181,28 @@ class FirewallService:return sorted(set(ports)) or None@classmethod- def _ufw_default_incoming_allow(cls) -> bool:- """True when ufw's default inbound policy is ACCEPT (no lockout risk)."""+ def _ufw_default_incoming_policy(cls) -> Optional[bool]:+ """Observed UFW inbound policy, or ``None`` when it cannot be read."""try:with open('/etc/default/ufw', 'r') as handle:for line in handle:match = re.match(r'^\s*DEFAULT_INPUT_POLICY\s*=\s*"?(\w+)"?',line)if match:- return match.group(1).upper() == 'ACCEPT'+ policy = match.group(1).upper()+ if policy == 'ACCEPT':+ return True+ if policy in ('DROP', 'REJECT', 'DENY'):+ return False+ return Noneexcept Exception:pass- return False+ return None++ @classmethod+ def _ufw_default_incoming_allow(cls) -> bool:+ """True only when UFW's observed inbound policy is ACCEPT."""+ return cls._ufw_default_incoming_policy() is True@classmethoddef _ufw_allowed_ports(cls) -> set:@@ -294,6 +322,7 @@ class FirewallService:'override': 'Send force=true to enable anyway.',}+ cls._checkpoint('enable', firewall)if firewall == 'firewalld':return cls._enable_firewalld()return cls._enable_ufw()@@ -329,8 +358,10 @@ class FirewallService:firewall = status['active_firewall']if firewall == 'firewalld':+ cls._checkpoint('disable', firewall)return cls._disable_firewalld()elif firewall == 'ufw':+ cls._checkpoint('disable', firewall)return cls._disable_ufw()else:return {'success': False, 'error': 'No firewall detected'}@@ -460,38 +491,72 @@ class FirewallService:status = cls.get_status()firewall = status['active_firewall']+ error = cls._validate_rule_request(rule_type, kwargs)+ if error:+ return {'success': False, 'error': error}+if firewall == 'firewalld':+ cls._checkpoint('add_rule', cls._rule_label(rule_type, kwargs))+ kwargs['_offline'] = status.get('firewalld', {}).get('running') is Falsereturn cls._add_firewalld_rule(rule_type, **kwargs)elif firewall == 'ufw':+ cls._checkpoint('add_rule', cls._rule_label(rule_type, kwargs))return cls._add_ufw_rule(rule_type, **kwargs)else:return {'success': False, 'error': 'No firewall detected'}+ @staticmethod+ def _rule_label(rule_type: str, values: Dict) -> str:+ target = (values.get('port') or values.get('service') or+ values.get('ip') or values.get('rule') or '')+ return f'{rule_type} {target}'.strip()++ @staticmethod+ def _validate_rule_request(rule_type: str, values: Dict,+ *, removing: bool = False) -> Optional[str]:+ if removing and values.get('number') is not None:+ return None+ required = {+ 'port': ('port', 'Port number required'),+ 'service': ('service', 'Service name required'),+ 'block_ip': ('ip', 'IP address required'),+ 'allow_ip': ('ip', 'IP address required'),+ 'rich': ('rule', 'Rich rule required'),+ }+ entry = required.get(rule_type)+ if entry is None:+ return f'Unknown rule type: {rule_type}'+ field, message = entry+ return None if values.get(field) not in (None, '') else message+@classmethoddef _add_firewalld_rule(cls, rule_type: str, **kwargs) -> Dict:"""Add a firewalld rule."""try:permanent = kwargs.get('permanent', True)- perm_flag = ['--permanent'] if permanent else []+ offline = bool(kwargs.get('_offline'))+ command = 'firewall-offline-cmd' if offline else 'firewall-cmd'+ perm_flag = ['--permanent'] if permanent and not offline else []+ zone_flag = [f'--zone={kwargs["zone"]}'] if kwargs.get('zone') else []if rule_type == 'service':service = kwargs.get('service')if not service:return {'success': False, 'error': 'Service name required'}- cmd = ['firewall-cmd'] + perm_flag + [f'--add-service={service}']+ cmd = [command] + perm_flag + zone_flag + [f'--add-service={service}']elif rule_type == 'port':port = kwargs.get('port')protocol = kwargs.get('protocol', 'tcp')if not port:return {'success': False, 'error': 'Port number required'}- cmd = ['firewall-cmd'] + perm_flag + [f'--add-port={port}/{protocol}']+ cmd = [command] + perm_flag + zone_flag + [f'--add-port={port}/{protocol}']elif rule_type == 'block_ip':ip = kwargs.get('ip')if not ip:return {'success': False, 'error': 'IP address required'}- cmd = ['firewall-cmd'] + perm_flag + [+ cmd = [command] + perm_flag + zone_flag + [f'--add-rich-rule=rule family="ipv4" source address="{ip}" reject']@@ -501,14 +566,20 @@ class FirewallService:if not ip:return {'success': False, 'error': 'IP address required'}if port:- cmd = ['firewall-cmd'] + perm_flag + [+ cmd = [command] + perm_flag + zone_flag + [f'--add-rich-rule=rule family="ipv4" source address="{ip}" port port="{port}" protocol="tcp" accept']else:- cmd = ['firewall-cmd'] + perm_flag + [+ cmd = [command] + perm_flag + zone_flag + [f'--add-rich-rule=rule family="ipv4" source address="{ip}" accept']+ elif rule_type == 'rich':+ rule = kwargs.get('rule')+ if not rule:+ return {'success': False, 'error': 'Rich rule required'}+ cmd = [command] + perm_flag + zone_flag + [f'--add-rich-rule={rule}']+else:return {'success': False, 'error': f'Unknown rule type: {rule_type}'}@@ -516,7 +587,7 @@ class FirewallService:if result.returncode == 0:# Reload if permanent- if permanent:+ if permanent and not offline:run_privileged(['firewall-cmd', '--reload'])return {'success': True, 'message': 'Rule added successfully'}@@ -785,6 +856,10 @@ class FirewallService:if firewall not in ('firewalld', 'ufw'):return {'success': False, 'error': 'No firewall detected'}+ error = cls._validate_rule_request(rule_type, kwargs, removing=True)+ if error:+ return {'success': False, 'error': error}+if not force:preflight = cls.check_ssh_rule_removal(rule_type, **kwargs)if not preflight['safe']:@@ -797,7 +872,9 @@ class FirewallService:'override': 'Send force=true to remove it anyway.',}+ cls._checkpoint('remove_rule', cls._rule_label(rule_type, kwargs))if firewall == 'firewalld':+ kwargs['_offline'] = status.get('firewalld', {}).get('running') is Falsereturn cls._remove_firewalld_rule(rule_type, **kwargs)return cls._remove_ufw_rule(rule_type, **kwargs)@@ -806,26 +883,29 @@ class FirewallService:"""Remove a firewalld rule."""try:permanent = kwargs.get('permanent', True)- perm_flag = ['--permanent'] if permanent else []+ offline = bool(kwargs.get('_offline'))+ command = 'firewall-offline-cmd' if offline else 'firewall-cmd'+ perm_flag = ['--permanent'] if permanent and not offline else []+ zone_flag = [f'--zone={kwargs["zone"]}'] if kwargs.get('zone') else []if rule_type == 'service':service = kwargs.get('service')- cmd = ['firewall-cmd'] + perm_flag + [f'--remove-service={service}']+ cmd = [command] + perm_flag + zone_flag + [f'--remove-service={service}']elif rule_type == 'port':port = kwargs.get('port')protocol = kwargs.get('protocol', 'tcp')- cmd = ['firewall-cmd'] + perm_flag + [f'--remove-port={port}/{protocol}']+ cmd = [command] + perm_flag + zone_flag + [f'--remove-port={port}/{protocol}']elif rule_type == 'block_ip':ip = kwargs.get('ip')- cmd = ['firewall-cmd'] + perm_flag + [+ cmd = [command] + perm_flag + zone_flag + [f'--remove-rich-rule=rule family="ipv4" source address="{ip}" reject']elif rule_type == 'rich':rule = kwargs.get('rule')- cmd = ['firewall-cmd'] + perm_flag + [f'--remove-rich-rule={rule}']+ cmd = [command] + perm_flag + zone_flag + [f'--remove-rich-rule={rule}']else:return {'success': False, 'error': f'Unknown rule type: {rule_type}'}@@ -833,7 +913,7 @@ class FirewallService:result = run_privileged(cmd)if result.returncode == 0:- if permanent:+ if permanent and not offline:run_privileged(['firewall-cmd', '--reload'])return {'success': True, 'message': 'Rule removed successfully'}@@ -858,6 +938,17 @@ class FirewallService:elif rule_type == 'block_ip':ip = kwargs.get('ip')result = run_privileged(['ufw', 'delete', 'deny', 'from', ip])+ elif rule_type == 'service':+ service = kwargs.get('service')+ action = kwargs.get('action', 'allow')+ result = run_privileged(['ufw', 'delete', action, service])+ elif rule_type == 'allow_ip':+ ip = kwargs.get('ip')+ port = kwargs.get('port')+ cmd = ['ufw', 'delete', 'allow', 'from', ip]+ if port:+ cmd.extend(['to', 'any', 'port', str(port)])+ result = run_privileged(cmd)else:return {'success': False, 'error': 'Rule number or specification required'}@@ -1140,13 +1231,34 @@ class FirewallService:}try:- result = run_privileged(['firewall-cmd', f'--set-default-zone={zone}'])+ status = cls.get_status()+ offline = status.get('firewalld', {}).get('running') is False+ command = 'firewall-offline-cmd' if offline else 'firewall-cmd'+ cls._checkpoint('set_default_zone', zone)+ result = run_privileged([command, f'--set-default-zone={zone}'])if result.returncode == 0:return {'success': True, 'message': f'Default zone set to {zone}'}return {'success': False, 'error': result.stderr or 'Failed to set default zone'}except Exception as e:return {'success': False, 'error': str(e)}+ @classmethod+ def set_default_incoming(cls, allow: bool) -> Dict:+ """Converge UFW's persisted default incoming policy."""+ cls._checkpoint('set_default_incoming', 'allow' if allow else 'deny')+ try:+ result = run_privileged([+ 'ufw', 'default', 'allow' if allow else 'deny', 'incoming',+ ])+ if result.returncode == 0:+ return {'success': True, 'allow': bool(allow)}+ return {+ 'success': False,+ 'error': result.stderr or 'Failed to set UFW incoming policy',+ }+ except Exception as e:+ return {'success': False, 'error': str(e)}+@classmethoddef install_firewall(cls, firewall: str = 'ufw') -> Dict:"""Install a firewall."""diff --git a/backend/app/services/nginx_service.py b/backend/app/services/nginx_service.pyindex d6d6ad5d..206c1f6c 100644--- a/backend/app/services/nginx_service.py+++ b/backend/app/services/nginx_service.py@@ -8,6 +8,19 @@ from app.utils.system import (ServiceControl, is_command_available,run_privileged, write_privileged_file)+def _auto_capture_vhost(name, action):+ """Best-effort checkpoint for request-bound vhost lifecycle mutations."""+ from flask import has_app_context++ if not has_app_context():+ return None+ from app.services.restore_point_service import auto_capture, get_adapter++ if get_adapter('nginx_vhost') is None:+ return None+ return auto_capture('nginx_vhost', name, action)++def _validate_domain(domain: str) -> bool:"""Validate domain name to prevent nginx config injection."""return bool(re.match(r'^(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?$', domain, re.IGNORECASE))@@ -782,6 +795,7 @@ location /p/ {{enabled_path = os.path.join(cls.SITES_ENABLED, name)previous = cls.read_vhost(name)was_enabled = os.path.exists(enabled_path)+ _auto_capture_vhost(name, 'write_vhost')written = write_privileged_file(available_path, content)if not written['success']:@@ -833,6 +847,8 @@ location /p/ {{if not os.path.exists(available_path):return {'success': False, 'error': f'Site {name} not found in sites-available'}+ _auto_capture_vhost(name, 'enable_site')+try:result = run_privileged(['ln', '-sf', available_path, enabled_path])if result.returncode == 0:@@ -849,6 +865,7 @@ location /p/ {{def disable_site(cls, name: str) -> Dict:"""Disable a site by removing symlink from sites-enabled."""enabled_path = os.path.join(cls.SITES_ENABLED, name)+ _auto_capture_vhost(name, 'disable_site')try:result = run_privileged(['rm', '-f', enabled_path])@@ -864,8 +881,11 @@ location /p/ {{@classmethoddef delete_site(cls, name: str) -> Dict:"""Delete a site configuration."""+ _auto_capture_vhost(name, 'delete_site')# First disable it- cls.disable_site(name)+ from app.services.restore_point_service import suppress_auto_capture+ with suppress_auto_capture():+ cls.disable_site(name)available_path = os.path.join(cls.SITES_AVAILABLE, name)try:diff --git a/backend/app/services/restore_point_adapter_cron.py b/backend/app/services/restore_point_adapter_cron.pynew file mode 100644index 00000000..53210eff--- /dev/null+++ b/backend/app/services/restore_point_adapter_cron.py@@ -0,0 +1,100 @@+"""Restore-point adapter for the local CRON surface.++The crontab and ServerKit's JSON metadata are one logical state. Capturing+only the rendered crontab would lose application attribution, tracking, and+alert preferences; capturing only metadata would lose hand-written lines.+"""++from copy import deepcopy++from app.services.cron_service import CronService+++SCOPE_ID = 'cron'+++def _validate_scope(scope_id, server_id):+ if str(scope_id) != SCOPE_ID:+ raise ValueError(f'Invalid CRON restore-point scope: {scope_id}')+ if server_id is not None:+ raise ValueError('Remote CRON restore points are not supported')+++def capture(scope_id, server_id=None):+ """Return the complete readable crontab and its metadata sidecar."""+ _validate_scope(scope_id, server_id)++ if CronService.is_linux():+ crontab = CronService._read_crontab()+ if crontab is None:+ raise RuntimeError('Could not read the current crontab')+ else:+ # Non-Linux installs use the metadata-backed scheduler and therefore+ # have a real, readable empty system-crontab component.+ crontab = ''++ try:+ metadata = CronService._load_jobs_metadata_strict()+ except (OSError, ValueError) as exc:+ raise RuntimeError('CRON metadata is unreadable or malformed') from exc++ return {+ 'crontab': crontab,+ 'metadata': deepcopy(metadata),+ }+++def _validate_payload(payload):+ if not isinstance(payload, dict):+ raise ValueError('CRON restore payload must be an object')+ crontab = payload.get('crontab')+ metadata = payload.get('metadata')+ if not isinstance(crontab, str):+ raise ValueError('CRON restore payload requires readable crontab text')+ if not isinstance(metadata, dict) or not isinstance(metadata.get('jobs'), dict):+ raise ValueError('CRON restore payload requires jobs metadata')+ return crontab, deepcopy(metadata)+++def restore(scope_id, payload, actor=None, server_id=None):+ """Restore CRON state, rolling the crontab back if metadata cannot persist.++ The normal service doors remain responsible for both writes. A metadata+ failure after installing the target crontab is compensated with the full+ pre-image so callers never receive a false atomic-success result.+ """+ del actor # Actor attribution belongs to the generic restore-point service.+ _validate_scope(scope_id, server_id)+ target_crontab, target_metadata = _validate_payload(payload)+ previous = capture(scope_id, server_id=server_id)++ if CronService.is_linux():+ failure = CronService._install_crontab(target_crontab)+ if failure:+ return failure++ try:+ CronService._save_jobs_metadata(target_metadata)+ except Exception as exc: # noqa: BLE001 - compensate both state components+ rollback_errors = []+ if CronService.is_linux():+ rollback = CronService._install_crontab(previous['crontab'])+ if rollback:+ rollback_errors.append(+ rollback.get('error') or 'failed to roll back crontab')+ try:+ CronService._save_jobs_metadata(previous['metadata'])+ except Exception as rollback_exc: # noqa: BLE001 - report degraded rollback+ rollback_errors.append(+ f'failed to roll back metadata: {rollback_exc}')++ result = {+ 'success': False,+ 'error': f'Failed to restore CRON metadata: {exc}',+ 'rolled_back': not rollback_errors,+ }+ if rollback_errors:+ result['rollback_error'] = '; '.join(rollback_errors)+ return result++ return {'success': True, 'message': 'CRON state restored'}diff --git a/backend/app/services/restore_point_adapter_dns.py b/backend/app/services/restore_point_adapter_dns.pynew file mode 100644index 00000000..8db35605--- /dev/null+++ b/backend/app/services/restore_point_adapter_dns.py@@ -0,0 +1,486 @@+"""Restore-point adapter for panel-owned provider DNS records.++The checkpoint intentionally reads only ``ManagedDnsRecord``. Provider-only+records remain outside coverage and are never adopted by a restore. Replay+uses ``DnsOwnershipService`` so the same foreign-record protection guards+ordinary writes and restores.+"""+from app.models.dns_zone import DNSZone+from app.models.email import DNSProviderConfig+from app.models.managed_dns_record import ManagedDnsRecord+from app.services.dns.base import DnsCredential, DnsRecordSpec+from app.services.dns_ownership_service import (+ DnsOwnershipService,+ parse_dns_scope_id,+)+++def _validate_scope(scope_id, server_id=None):+ if server_id is not None:+ raise ValueError('Remote DNS restore points are not supported')+ return parse_dns_scope_id(scope_id)+++def _query(provider, config_id, provider_zone_id):+ query = ManagedDnsRecord.query.filter_by(+ provider=provider,+ provider_zone_id=provider_zone_id,+ )+ if config_id is None:+ query = query.filter(ManagedDnsRecord.dns_provider_config_id.is_(None))+ else:+ query = query.filter_by(dns_provider_config_id=config_id)+ return query+++def _record_payload(row):+ return DnsOwnershipService.record_payload(row)+++def capture(scope_id, server_id=None):+ """Capture exactly the managed ledger rows for one provider connection/zone."""+ provider, config_id, provider_zone_id = _validate_scope(scope_id, server_id)+ rows = _query(provider, config_id, provider_zone_id).order_by(+ ManagedDnsRecord.record_type,+ ManagedDnsRecord.name,+ ManagedDnsRecord.id,+ ).all()+ return {+ 'provider': provider,+ 'config_id': config_id,+ 'provider_zone_id': provider_zone_id,+ 'records': [_record_payload(row) for row in rows],+ }+++def _record_map(payload, *, expected_scope=None):+ if not isinstance(payload, dict):+ raise ValueError('DNS restore payload must be an object')+ required = ('provider', 'config_id', 'provider_zone_id', 'records')+ if any(key not in payload for key in required):+ raise ValueError('DNS restore payload is incomplete')++ if expected_scope is not None:+ provider, config_id, provider_zone_id = expected_scope+ if (+ str(payload.get('provider')).lower() != provider+ or payload.get('config_id') != config_id+ or str(payload.get('provider_zone_id')) != provider_zone_id+ ):+ raise ValueError('DNS restore payload belongs to a different scope')++ records = payload.get('records')+ if not isinstance(records, list):+ raise ValueError('DNS restore payload.records must be a list')++ out = {}+ for item in records:+ if not isinstance(item, dict):+ raise ValueError('DNS restore records must be objects')+ record_type = str(item.get('record_type') or '').upper()+ name = str(item.get('name') or '').lower().rstrip('.')+ if not record_type or not name or item.get('content') is None:+ raise ValueError('DNS restore record requires type, name, and content')+ key = (record_type, name)+ if key in out:+ raise ValueError(f'DNS restore payload repeats RRset {record_type} {name}')+ normalized = {+ 'record_type': record_type,+ 'name': name,+ 'content': str(item.get('content')),+ 'ttl': item.get('ttl'),+ 'priority': item.get('priority'),+ 'proxied': item.get('proxied'),+ 'source': item.get('source'),+ 'app_id': item.get('app_id'),+ }+ if normalized['proxied'] not in (None, True, False):+ raise ValueError(+ f'DNS restore record {record_type} {name} has invalid proxy state',+ )+ try:+ normalized['ttl'] = (int(normalized['ttl'])+ if normalized['ttl'] is not None else None)+ normalized['priority'] = (+ int(normalized['priority'])+ if normalized['priority'] is not None else None+ )+ except (TypeError, ValueError) as exc:+ raise ValueError(+ f'DNS restore record {record_type} {name} has invalid numeric fields',+ ) from exc+ out[key] = normalized+ return out+++def _display_key(key):+ return f'{key[0]} {key[1]}'+++def diff(old_payload, new_payload):+ """Return the common added/removed/changed vocabulary per DNS RRset."""+ old = _record_map(old_payload)+ new = _record_map(new_payload)+ old_keys = set(old)+ new_keys = set(new)+ return {+ 'added': {+ _display_key(key): new[key] for key in sorted(new_keys - old_keys)+ },+ 'removed': {+ _display_key(key): old[key] for key in sorted(old_keys - new_keys)+ },+ 'changed': {+ _display_key(key): {'old': old[key], 'new': new[key]}+ for key in sorted(old_keys & new_keys)+ if old[key] != new[key]+ },+ }+++def _legacy_credential(provider, provider_zone_id):+ zone = DNSZone.query.filter_by(+ provider=provider,+ provider_zone_id=provider_zone_id,+ dns_provider_config_id=None,+ ).first()+ if zone is None:+ raise ValueError('Legacy DNS zone credential not found')+ data = zone.provider_config or {}+ token = data.get('api_token') or data.get('api_key') or data.get('token')+ if not token:+ raise ValueError('Legacy DNS zone has no usable credential')+ return DnsCredential(+ provider=provider,+ token=token,+ email=data.get('api_email') or data.get('email'),+ secret=data.get('api_secret') or data.get('secret'),+ )+++def _client_for_scope(provider, config_id, provider_zone_id):+ from app.services.dns import get_record_client++ if config_id is None:+ credential = _legacy_credential(provider, provider_zone_id)+ else:+ config = DNSProviderConfig.query.get(config_id)+ if config is None:+ raise ValueError(f'DNS provider connection {config_id} not found')+ if config.provider.lower() != provider:+ raise ValueError('DNS provider connection does not match restore scope')+ credential = DnsCredential.from_provider_config(config)+ return get_record_client(credential)+++def _existing_id(client, provider_zone_id, record):+ caa = None+ if record['record_type'] == 'CAA':+ from app.services.dns.cloudflare import parse_caa_value+ caa = parse_caa_value(record['content'])+ return client.find_record_id(+ provider_zone_id, record['record_type'], record['name'], caa=caa,+ )+++def _foreign_conflicts(client, provider, config_id, provider_zone_id,+ target, current_rows):+ """Preflight every target before the first write to avoid partial replay."""+ conflicts = []+ existing_ids = {}+ for key, record in sorted(target.items()):+ existing_id = _existing_id(client, provider_zone_id, record)+ existing_ids[key] = existing_id+ if not existing_id:+ continue+ row = current_rows.get(key)+ owns_id = DnsOwnershipService.owns(+ provider_zone_id, provider_record_id=existing_id,+ provider=provider, config_id=config_id,+ )+ if not owns_id and not (row is not None and not row.provider_record_id):+ conflicts.append(_display_key(key))+ return conflicts, existing_ids+++def _live_record_map(client, provider_zone_id):+ result = client.list_records(provider_zone_id)+ if not result.get('success'):+ raise RuntimeError(+ result.get('error') or 'Provider live DNS records are unavailable',+ )+ out = {}+ for row in result.get('records', []):+ key = (+ str(row.get('type') or '').upper(),+ str(row.get('name') or '').lower().rstrip('.'),+ )+ if key[0] and key[1]:+ out.setdefault(key, row)+ return out+++def _prepare_target(client, provider, provider_zone_id, target):+ """Hydrate nullable migration-092 fields without fabricating live state."""+ needs_live = any(+ item.get('ttl') is None+ or (provider == 'cloudflare' and item.get('proxied') is None)+ or (+ item.get('record_type') in ('MX', 'SRV')+ and item.get('priority') is None+ and not str(item.get('content') or '').partition(' ')[0].isdigit()+ )+ for item in target.values()+ )+ live = {}+ if needs_live:+ try:+ live = _live_record_map(client, provider_zone_id)+ except Exception as exc: # noqa: BLE001 - preview should explain refusal+ return target, [+ 'Legacy DNS record attributes are unknown and live provider '+ f'state could not be read safely: {exc}',+ ]++ prepared = {}+ refusals = []+ for key, original in target.items():+ item = dict(original)+ live_row = live.get(key)++ if item.get('ttl') is None:+ if live_row is None or live_row.get('ttl') is None:+ refusals.append(+ f'{_display_key(key)} has unknown legacy TTL and no live '+ 'provider value; restore cannot safely invent one.'+ )+ else:+ item['ttl'] = int(live_row['ttl'])++ if provider == 'cloudflare' and item.get('proxied') is None:+ if live_row is None or live_row.get('proxied') is None:+ refusals.append(+ f'{_display_key(key)} has unknown legacy proxy state and '+ 'no live provider value; restore cannot safely disable it.'+ )+ else:+ item['proxied'] = bool(live_row['proxied'])++ if (+ item['record_type'] in ('MX', 'SRV')+ and item.get('priority') is None+ and not item['content'].partition(' ')[0].isdigit()+ ):+ if live_row is None or live_row.get('priority') is None:+ refusals.append(+ f'{_display_key(key)} has unknown legacy priority and no '+ 'live provider value; restore cannot safely invent one.'+ )+ else:+ item['priority'] = int(live_row['priority'])++ prepared[key] = item+ return prepared, refusals+++def _canonical_live_content(record_type, content):+ value = str(content or '').strip()+ if record_type in ('CNAME', 'MX', 'NS', 'PTR', 'SRV'):+ return value.rstrip('.').lower()+ if record_type == 'CAA':+ return value.lower()+ return value+++def _content_and_priority(record_type, content, priority):+ value = str(content or '').strip()+ effective_priority = priority+ if record_type in ('MX', 'SRV') and effective_priority is None:+ head, _, rest = value.partition(' ')+ if head.isdigit() and rest.strip():+ effective_priority = int(head)+ value = rest.strip()+ return _canonical_live_content(record_type, value), effective_priority+++def _synthetic_delete_matches(row, live_row):+ ledger_content, ledger_priority = _content_and_priority(+ row.record_type, row.content, row.priority,+ )+ live_content, live_priority = _content_and_priority(+ row.record_type, live_row.get('content'), live_row.get('priority'),+ )+ if (+ ledger_content != live_content+ ):+ return False+ comparisons = (+ ('ttl', row.ttl),+ ('priority', ledger_priority),+ ('proxied', row.proxied),+ )+ for key, expected in comparisons:+ actual = live_priority if key == 'priority' else live_row.get(key)+ if expected is not None and actual is not None and expected != actual:+ return False+ return True+++def _delete_refusals(client, provider, provider_zone_id, target, current_rows):+ """Never delete a provider-side replacement merely because its RRset is ours."""+ delete_keys = sorted(set(current_rows) - set(target))+ if not delete_keys:+ return []+ try:+ live = _live_record_map(client, provider_zone_id)+ except Exception as exc: # noqa: BLE001 - inability to prove safety refuses+ return [+ 'Provider live DNS state could not be read, so restore cannot '+ f'safely delete managed records: {exc}',+ ]++ refusals = []+ stable_id_provider = provider in ('cloudflare', 'digitalocean')+ for key in delete_keys:+ row = current_rows[key]+ live_row = live.get(key)+ if live_row is None:+ continue+ if stable_id_provider and row.provider_record_id:+ if str(live_row.get('id')) != str(row.provider_record_id):+ refusals.append(+ f'Restore would delete provider-only replacement '+ f'{_display_key(key)}; its provider id no longer matches.'+ )+ elif not _synthetic_delete_matches(row, live_row):+ refusals.append(+ f'Restore would delete provider-only replacement '+ f'{_display_key(key)}; its live value no longer matches the ledger.'+ )+ return refusals+++def validate_restore(scope_id, payload, current_payload, actor=None,+ server_id=None):+ """Surface foreign-record refusals during preview, before restore is offered."""+ del actor, current_payload+ scope = _validate_scope(scope_id, server_id)+ provider, config_id, provider_zone_id = scope+ target = _record_map(payload, expected_scope=scope)+ client = _client_for_scope(provider, config_id, provider_zone_id)+ current_rows = {+ ((row.record_type or '').upper(), (row.name or '').lower().rstrip('.')): row+ for row in _query(provider, config_id, provider_zone_id).all()+ }+ _, attribute_refusals = _prepare_target(+ client, provider, provider_zone_id, target,+ )+ conflicts, _ = _foreign_conflicts(+ client, provider, config_id, provider_zone_id, target, current_rows,+ )+ delete_refusals = _delete_refusals(+ client, provider, provider_zone_id, target, current_rows,+ )+ return attribute_refusals + delete_refusals + [+ 'Restore would overwrite provider-only DNS record '+ f'{record}; it was not created by ServerKit.'+ for record in conflicts+ ]+++def restore(scope_id, payload, actor=None, server_id=None):+ """Re-converge owned RRsets while refusing to touch provider-only records."""+ del actor # Generic restore auditing owns actor attribution.+ scope = _validate_scope(scope_id, server_id)+ provider, config_id, provider_zone_id = scope+ target = _record_map(payload, expected_scope=scope)+ client = _client_for_scope(provider, config_id, provider_zone_id)++ current_rows = {+ ((row.record_type or '').upper(), (row.name or '').lower().rstrip('.')): row+ for row in _query(provider, config_id, provider_zone_id).all()+ }+ target, attribute_refusals = _prepare_target(+ client, provider, provider_zone_id, target,+ )+ conflicts, existing_ids = _foreign_conflicts(+ client, provider, config_id, provider_zone_id, target, current_rows,+ )+ delete_refusals = _delete_refusals(+ client, provider, provider_zone_id, target, current_rows,+ )+ if conflicts or attribute_refusals or delete_refusals:+ errors = list(attribute_refusals) + list(delete_refusals)+ if conflicts:+ errors.append(+ 'Restore refused to overwrite provider-only DNS records: '+ + ', '.join(conflicts)+ )+ return {+ 'success': False,+ 'conflict': bool(conflicts),+ 'refused': True,+ 'error': '; '.join(errors),+ 'conflicts': conflicts,+ }++ restored = []+ removed = []+ results = []++ for key in sorted(target):+ item = target[key]+ # The ledger is the capture source, not proof that provider live state+ # still matches. Always send the idempotent guarded upsert so deleted or+ # drifted managed records are repaired during restore.+ spec = DnsRecordSpec(+ record_type=item['record_type'],+ name=item['name'],+ content=item['content'],+ ttl=item['ttl'],+ priority=item['priority'],+ proxied=item['proxied'],+ )+ result = DnsOwnershipService.guarded_upsert(+ client, provider=provider, provider_zone_id=provider_zone_id,+ spec=spec, source=item.get('source') or 'restore',+ app_id=item.get('app_id'), config_id=config_id,+ # Provider live state, not the ledger, decides whether an id is+ # still usable. A stale id must become a create, never a PUT to a+ # provider-deleted object.+ known_record_id=existing_ids.get(key),+ allow_foreign=False,+ )+ results.append({'action': 'upsert', 'record': _display_key(key), **result})+ if not result.get('success'):+ return {+ 'success': False,+ 'error': result.get('error', 'DNS restore upsert failed'),+ 'results': results,+ }+ restored.append(_display_key(key))++ for key in sorted(set(current_rows) - set(target)):+ row = current_rows[key]+ result = DnsOwnershipService.guarded_delete(+ client, provider=provider, provider_zone_id=provider_zone_id,+ record_type=row.record_type, name=row.name,+ provider_record_id=row.provider_record_id,+ source='restore', config_id=config_id,+ )+ results.append({'action': 'delete', 'record': _display_key(key), **result})+ if not result.get('success'):+ return {+ 'success': False,+ 'error': result.get('error', 'DNS restore delete failed'),+ 'results': results,+ }+ removed.append(_display_key(key))++ return {+ 'success': True,+ 'scope_id': scope_id,+ 'restored': restored,+ 'removed': removed,+ 'results': results,+ }diff --git a/backend/app/services/restore_point_adapter_env.py b/backend/app/services/restore_point_adapter_env.pynew file mode 100644index 00000000..5d8a14c7--- /dev/null+++ b/backend/app/services/restore_point_adapter_env.py@@ -0,0 +1,233 @@+"""Restore-point adapter for an application's local environment variables.++The payload deliberately stores metadata and references, but never plaintext+for a secret-flagged or sensitive-looking key. Restore replays through+``EnvService`` so encryption, history, and future policy remain centralized.+"""++from app.models import Application, EnvironmentVariable+from app.services.configuration_service import ConfigurationService+from app.utils.sensitive_data_filter import MASK+++coverage = (+ 'Only environment variables set directly on this application are '+ 'captured. Shared variable groups and their attachment order are outside '+ 'this checkpoint.',+)+++def _application_id(scope_id):+ try:+ return int(scope_id)+ except (TypeError, ValueError) as exc:+ raise ValueError(f'Invalid application environment scope: {scope_id}') from exc+++def _require_application(scope_id):+ application_id = _application_id(scope_id)+ application = Application.query_active().filter_by(id=application_id).first()+ if application is None:+ raise ValueError(f'Application {application_id} not found')+ return application_id+++def _masked_value(env_var):+ """Avoid decrypting rows that ConfigurationService will redact anyway."""+ placeholder = ConfigurationService.mask_env_value(+ env_var.key, '', bool(env_var.is_secret),+ )+ if placeholder == MASK:+ return MASK+ return ConfigurationService.mask_env_value(+ env_var.key, env_var.value, bool(env_var.is_secret),+ )+++def capture(scope_id, server_id=None):+ """Capture a deterministic, secret-safe per-key environment mapping."""+ del server_id # Environment variables are scoped by application today.+ application_id = _require_application(scope_id)+ rows = EnvironmentVariable.query.filter_by(+ application_id=application_id,+ ).order_by(EnvironmentVariable.key).all()++ env = {}+ for row in rows:+ env[row.key] = {+ 'value': _masked_value(row),+ 'is_secret': bool(row.is_secret),+ 'description': row.description,+ 'target_service': row.target_service,+ # References contain source identity, never the resolved secret.+ 'value_from': row.get_reference(),+ }+ return {'env': env}+++def _env_mapping(payload):+ if not isinstance(payload, dict):+ raise ValueError('Environment restore payload must be an object')+ env = payload.get('env', {})+ if not isinstance(env, dict):+ raise ValueError('Environment restore payload.env must be an object')+ return env+++def diff(old_payload, new_payload):+ """Return the shared added/removed/changed vocabulary at key granularity."""+ old = _env_mapping(old_payload)+ new = _env_mapping(new_payload)+ old_keys = set(old)+ new_keys = set(new)+ return {+ 'added': {key: new[key] for key in sorted(new_keys - old_keys)},+ 'removed': {key: old[key] for key in sorted(old_keys - new_keys)},+ 'changed': {+ key: {'old': old[key], 'new': new[key]}+ for key in sorted(old_keys & new_keys)+ if old[key] != new[key]+ },+ }+++def _validate_target(target):+ """Validate the full target before the first replay write."""+ for key, item in target.items():+ if not isinstance(key, str) or not isinstance(item, dict):+ raise ValueError('Environment restore entries must be keyed objects')+ valid, error = _env_service().validate_key(key)+ if not valid:+ raise ValueError(f'{key}: {error}')+ reference = item.get('value_from')+ if reference is not None and not isinstance(reference, dict):+ raise ValueError(f'{key}: value_from must be an object or null')+++def _env_service():+ # Lazy to avoid coupling the normal environment-service import path back+ # through the adapter registry during application startup.+ from app.services.env_service import EnvService++ return EnvService+++def _actor_id(actor):+ return getattr(actor, 'id', actor)+++def restore(scope_id, payload, actor=None, server_id=None):+ """Re-converge local env state without clobbering masked live material."""+ del server_id+ application_id = _require_application(scope_id)+ target = _env_mapping(payload)+ _validate_target(target)++ from app.services.env_service import _new_batch_id+ from app.services.restore_point_service import suppress_auto_capture++ EnvService = _env_service()+ actor_id = _actor_id(actor)+ batch_id = _new_batch_id()+ current = {+ row.key: row for row in EnvironmentVariable.query.filter_by(+ application_id=application_id,+ ).all()+ }++ restored = []+ removed = []+ skipped_secrets = []+ preserved_references = []++ # The generic restore service already suppresses nested auto-captures.+ # Keep the adapter safe when exercised directly as well.+ with suppress_auto_capture():+ for key in sorted(target):+ item = target[key]+ reference = item.get('value_from')+ value = item.get('value', '')++ if reference is not None:+ _, _, error = EnvService.set_env_reference(+ application_id,+ key,+ reference,+ user_id=actor_id,+ target_service=item.get('target_service'),+ description=item.get('description'),+ batch_id=batch_id,+ )+ if error:+ raise ValueError(f'{key}: {error}')+ restored.append(key)+ continue++ if value == MASK:+ # There is no recoverable value in the checkpoint. If a live+ # row exists, leave its literal/reference and metadata intact;+ # if it is missing, do not manufacture a row containing MASK.+ skipped_secrets.append(key)+ if current.get(key) and current[key].get_reference():+ preserved_references.append(key)+ continue++ _, _, error = EnvService.set_env_var(+ application_id,+ key,+ value,+ is_secret=bool(item.get('is_secret', False)),+ description=item.get('description'),+ user_id=actor_id,+ target_service=item.get('target_service'),+ batch_id=batch_id,+ )+ if error:+ raise ValueError(f'{key}: {error}')+ # ``set_env_var`` deliberately treats description=None as+ # "leave unchanged" for its longstanding callers. A checkpoint's+ # explicit null means clear it, so finish that metadata convergence+ # through the partial-update service door.+ if (+ item.get('description') is None+ and current.get(key)+ and current[key].description is not None+ ):+ _, error = EnvService.update_env_var(+ application_id,+ key,+ description=None,+ user_id=actor_id,+ batch_id=batch_id,+ )+ if error:+ raise ValueError(f'{key}: {error}')+ restored.append(key)++ for key in sorted(set(current) - set(target)):+ row = current[key]+ reference = row.get_reference()+ if reference is not None:+ preserved_references.append(key)+ continue+ if ConfigurationService.mask_env_value(+ key, '', bool(row.is_secret),+ ) == MASK:+ skipped_secrets.append(key)+ continue+ success, error = EnvService.delete_env_var(+ application_id, key, user_id=actor_id, batch_id=batch_id,+ )+ if not success:+ raise ValueError(f'{key}: {error}')+ removed.append(key)++ return {+ 'success': True,+ 'application_id': application_id,+ 'batch_id': batch_id,+ 'restored': restored,+ 'removed': removed,+ 'skipped_secrets': sorted(set(skipped_secrets)),+ 'preserved_references': sorted(set(preserved_references)),+ }diff --git a/backend/app/services/restore_point_adapter_firewall.py b/backend/app/services/restore_point_adapter_firewall.pynew file mode 100644index 00000000..c12b3d08--- /dev/null+++ b/backend/app/services/restore_point_adapter_firewall.py@@ -0,0 +1,324 @@+"""Restore-point adapter for the local host firewall.++The payload intentionally contains only the panel's supported, replayable+firewall vocabulary. Runtime bans and Docker-managed chains remain outside+the checkpoint, as stated by the frozen coverage text.+"""++import re++from flask import has_request_context++from app.services.firewall_service import FirewallService+from app.utils.system import PROBE_TIMEOUT, run_privileged+++coverage = [+ 'Restore converges persisted panel-supported UFW rules and firewalld '+ 'service, port, and rich-rule families, including matching manually '+ 'created rules. Other firewalld families, interfaces, sources, runtime '+ 'bans, and Docker-managed iptables chains are left alone.',+]+++def _run(argv):+ result = run_privileged(argv, timeout=PROBE_TIMEOUT)+ if result.returncode != 0:+ message = (result.stderr or result.stdout or 'command failed').strip()+ raise RuntimeError(f'{" ".join(argv)}: {message}')+ return result.stdout or ''+++def _ufw_rules():+ lines = _run(['ufw', 'show', 'added']).splitlines()+ rules = []+ for line in lines:+ line = line.strip()+ if not line.lower().startswith('ufw '):+ continue+ argv = line.split()[1:]+ if argv:+ rules.append({'kind': 'ufw', 'argv': argv})+ return sorted(rules, key=_rule_key)+++def _firewalld_rules(running, zones):+ command = 'firewall-cmd' if running else 'firewall-offline-cmd'+ persistent = ['--permanent'] if running else []+ rules = []+ for zone_name in sorted(set(zones)):+ zone = [f'--zone={zone_name}']+ for value in _run([command] + persistent + zone + ['--list-services']).split():+ rules.append({+ 'kind': 'service', 'service': value, 'zone': zone_name,+ 'permanent': True,+ })+ for value in _run([command] + persistent + zone + ['--list-ports']).split():+ port, _, protocol = value.partition('/')+ rules.append({+ 'kind': 'port', 'port': port, 'protocol': protocol or 'tcp',+ 'zone': zone_name, 'permanent': True,+ })+ rich = _run([command] + persistent + zone + ['--list-rich-rules'])+ for value in rich.splitlines():+ if value.strip():+ rules.append({+ 'kind': 'rich', 'rule': value.strip(), 'zone': zone_name,+ 'permanent': True,+ })+ return sorted(rules, key=_rule_key)+++def capture(scope_id, server_id=None):+ if str(scope_id) != 'firewall':+ raise ValueError('the firewall adapter only supports scope_id=firewall')+ if server_id is not None:+ raise ValueError('remote firewall restore points are not supported')+ status = FirewallService.get_status()+ firewall = status.get('active_firewall')+ if firewall not in ('ufw', 'firewalld'):+ raise RuntimeError('no supported local firewall is installed')++ if firewall == 'ufw':+ active = status.get('ufw', {}).get('active')+ if active is None:+ raise RuntimeError('could not determine whether ufw is active')+ default_policy = FirewallService._ufw_default_incoming_policy()+ if default_policy is None:+ raise RuntimeError('could not read the UFW default incoming policy')+ return {+ 'version': 1,+ 'firewall': 'ufw',+ 'enabled': bool(active),+ 'default_zone': None,+ 'default_incoming_allow': default_policy,+ 'rules': _ufw_rules(),+ }++ running = status.get('firewalld', {}).get('running')+ if running is None:+ raise RuntimeError('could not determine whether firewalld is running')+ command = 'firewall-cmd' if running else 'firewall-offline-cmd'+ default_zone = (status.get('firewalld', {}).get('default_zone') or+ _run([command, '--get-default-zone']).strip())+ if not default_zone:+ raise RuntimeError('could not determine the firewalld default zone')+ zones = _run([command] + (['--permanent'] if running else []) + [+ '--get-zones',+ ]).split()+ if default_zone not in zones:+ zones.append(default_zone)+ return {+ 'version': 1,+ 'firewall': 'firewalld',+ 'enabled': bool(running),+ 'default_zone': default_zone,+ 'default_incoming_allow': None,+ 'rules': _firewalld_rules(bool(running), zones),+ }+++def _rule_key(rule):+ return repr(sorted(rule.items()))+++def _ufw_spec(rule):+ argv = list(rule.get('argv') or [])+ if not argv:+ return None+ action = argv[0].lower()+ if action in ('allow', 'deny') and len(argv) == 2:+ target = argv[1]+ match = re.fullmatch(r'(\d{1,5})(?:/(tcp|udp))?', target, re.I)+ if match:+ return ('port', {+ 'port': int(match.group(1)),+ 'protocol': (match.group(2) or 'tcp').lower(),+ 'action': action,+ })+ return ('service', {'service': target, 'action': action})+ if len(argv) >= 3 and argv[1].lower() == 'from':+ address = argv[2]+ if action == 'deny' and len(argv) == 3:+ return ('block_ip', {'ip': address})+ if action == 'allow':+ values = {'ip': address}+ if 'port' in [part.lower() for part in argv]:+ index = [part.lower() for part in argv].index('port')+ if index + 1 < len(argv):+ values['port'] = int(argv[index + 1])+ return ('allow_ip', values)+ return None+++def _door_spec(rule):+ if rule.get('kind') == 'ufw':+ return _ufw_spec(rule)+ kind = rule.get('kind')+ values = {+ key: rule[key]+ for key in ('service', 'port', 'protocol', 'rule', 'zone', 'permanent')+ if key in rule+ }+ return (kind, values) if kind in ('service', 'port', 'rich') else None+++def _ssh_coverage(payload, ssh_ports):+ if payload.get('firewall') == 'ufw':+ if payload.get('default_incoming_allow'):+ return set(ssh_ports)+ covered = set()+ for rule in payload.get('rules') or []:+ spec = _ufw_spec(rule)+ if not spec:+ continue+ kind, values = spec+ if values.get('action', 'allow') != 'allow':+ continue+ if kind == 'port' and int(values['port']) in ssh_ports:+ covered.add(int(values['port']))+ elif kind == 'service':+ covered.update(+ FirewallService._app_profile_ports(values['service']) & set(ssh_ports)+ )+ return covered++ covered = set()+ for rule in payload.get('rules') or []:+ if rule.get('zone') != payload.get('default_zone'):+ continue+ if rule.get('kind') == 'service' and rule.get('service') == 'ssh':+ covered.update(ssh_ports)+ elif rule.get('kind') == 'port':+ try:+ port = int(rule.get('port'))+ except (TypeError, ValueError):+ continue+ if port in ssh_ports:+ covered.add(port)+ return covered+++def _blocked_networks(payload):+ for rule in payload.get('rules') or []:+ if rule.get('kind') == 'ufw':+ spec = _ufw_spec(rule)+ if spec and spec[0] == 'block_ip':+ yield spec[1]['ip']+ elif rule.get('kind') == 'rich':+ text = rule.get('rule') or ''+ if re.search(r'\b(reject|drop)\b', text, re.I):+ match = re.search(r'source\s+address="([^"]+)"', text, re.I)+ if match:+ yield match.group(1)+++def validate_restore(scope_id, payload, current_payload, actor=None, server_id=None):+ refusals = []+ if payload.get('version') != 1:+ refusals.append('The firewall restore-point format is unsupported.')+ if payload.get('firewall') not in ('ufw', 'firewalld'):+ refusals.append('The checkpoint does not name a supported firewall.')+ if payload.get('firewall') != current_payload.get('firewall'):+ refusals.append('Restoring across different firewall implementations is refused.')+ unsupported = [rule for rule in payload.get('rules') or [] if not _door_spec(rule)]+ if unsupported:+ refusals.append('The checkpoint contains firewall rules the panel cannot replay safely.')++ if payload.get('enabled'):+ ssh_ports = FirewallService.ssh_ports()+ if ssh_ports is None:+ refusals.append(+ 'Could not determine the live SSH ports, so enabling this ruleset is unsafe.'+ )+ elif set(ssh_ports) - _ssh_coverage(payload, ssh_ports):+ missing = ', '.join(str(port) for port in sorted(+ set(ssh_ports) - _ssh_coverage(payload, ssh_ports)+ ))+ refusals.append(f'The target ruleset does not admit SSH on port {missing}.')++ protected = {'127.0.0.1', '::1'} | FirewallService.active_ssh_peers()+ if has_request_context():+ from app.utils.client_ip import get_client_ip+ if get_client_ip():+ protected.add(get_client_ip())+ for network in _blocked_networks(payload):+ conflicts = [address for address in sorted(protected)+ if FirewallService._covers_address(network, address)]+ if conflicts:+ refusals.append(+ f'The target ruleset blocks a protected live address ({", ".join(conflicts)}).'+ )+ return refusals+++def _apply(rule, removing=False):+ spec = _door_spec(rule)+ if spec is None:+ raise RuntimeError('firewall rule is not replayable')+ kind, values = spec+ operation = FirewallService.remove_rule if removing else FirewallService.add_rule+ if removing:+ result = operation(kind, force=True, **values)+ else:+ result = operation(kind, **values)+ if not result.get('success'):+ raise RuntimeError(result.get('error') or 'firewall rule replay failed')+++def _is_ssh_admission(rule, ssh_ports):+ if rule.get('kind') == 'service' and rule.get('service') == 'ssh':+ return True+ spec = _door_spec(rule)+ if not spec:+ return False+ kind, values = spec+ return (kind == 'port' and values.get('action', 'allow') == 'allow'+ and int(values.get('port')) in set(ssh_ports or []))+++def restore(scope_id, payload, actor=None, server_id=None):+ current = capture(scope_id, server_id=server_id)+ target_rules = {_rule_key(rule): rule for rule in payload.get('rules') or []}+ current_rules = {_rule_key(rule): rule for rule in current.get('rules') or []}+ additions = [target_rules[key] for key in sorted(target_rules.keys() - current_rules.keys())]+ removals = [current_rules[key] for key in sorted(current_rules.keys() - target_rules.keys())]++ disabled_first = False+ if not payload.get('enabled') and current.get('enabled'):+ result = FirewallService.disable(payload.get('firewall'))+ if not result.get('success'):+ raise RuntimeError(result.get('error') or 'firewall disable failed')+ disabled_first = True++ ssh_ports = FirewallService.ssh_ports() or []+ additions.sort(key=lambda rule: (not _is_ssh_admission(rule, ssh_ports), _rule_key(rule)))+ for rule in additions:+ _apply(rule)++ if payload.get('firewall') == 'firewalld' \+ and payload.get('default_zone') != current.get('default_zone'):+ result = FirewallService.set_default_zone(payload['default_zone'], force=True)+ if not result.get('success'):+ raise RuntimeError(result.get('error') or 'default-zone restore failed')+ elif payload.get('firewall') == 'ufw' \+ and payload.get('default_incoming_allow') != current.get('default_incoming_allow'):+ result = FirewallService.set_default_incoming(+ bool(payload.get('default_incoming_allow')),+ )+ if not result.get('success'):+ raise RuntimeError(result.get('error') or 'default-policy restore failed')++ for rule in removals:+ _apply(rule, removing=True)++ if bool(payload.get('enabled')) != bool(current.get('enabled')):+ operation = FirewallService.enable if payload.get('enabled') else FirewallService.disable+ result = operation(payload.get('firewall'), force=True) \+ if payload.get('enabled') else (+ {'success': True} if disabled_first else operation(payload.get('firewall'))+ )+ if not result.get('success'):+ raise RuntimeError(result.get('error') or 'firewall state restore failed')++ return {'success': True, 'rules_added': len(additions), 'rules_removed': len(removals)}diff --git a/backend/app/services/restore_point_adapter_nginx.py b/backend/app/services/restore_point_adapter_nginx.pynew file mode 100644index 00000000..0757d8d3--- /dev/null+++ b/backend/app/services/restore_point_adapter_nginx.py@@ -0,0 +1,79 @@+"""Restore-point adapter for one local nginx vhost lifecycle."""++import os++from app.services.nginx_service import NginxService+++def _validate_scope(scope_id, server_id):+ name = str(scope_id or '')+ if (+ not name+ or name in ('.', '..')+ or os.path.isabs(name)+ or os.path.basename(name) != name+ or '/' in name+ or '\\' in name+ or '\x00' in name+ ):+ raise ValueError('nginx vhost scope must be one safe filename')+ if server_id is not None:+ raise ValueError('Remote nginx vhost restore points are not supported')+ return name+++def capture(scope_id, server_id=None):+ """Capture file existence, enablement, and exact vhost bytes.++ A present-but-unreadable file is not represented as an empty or absent+ vhost. Refusing that capture prevents a later restore from deleting state+ that merely could not be observed.+ """+ name = _validate_scope(scope_id, server_id)+ available_path = os.path.join(NginxService.SITES_AVAILABLE, name)+ enabled_path = os.path.join(NginxService.SITES_ENABLED, name)+ exists = os.path.exists(available_path)+ content = NginxService.read_vhost(name) if exists else None+ if exists and content is None:+ raise RuntimeError(f'Existing nginx vhost {name} could not be read')+ return {+ 'exists': exists,+ 'enabled': os.path.exists(enabled_path),+ 'content': content,+ }+++def _validate_payload(payload):+ if not isinstance(payload, dict):+ raise ValueError('nginx restore payload must be an object')+ if not isinstance(payload.get('exists'), bool):+ raise ValueError('nginx restore payload requires an exists flag')+ if not isinstance(payload.get('enabled'), bool):+ raise ValueError('nginx restore payload requires an enabled flag')+ content = payload.get('content')+ if payload['exists'] and not isinstance(content, str):+ raise ValueError('Existing nginx restore payload requires vhost content')+ return payload['exists'], payload['enabled'], content+++def restore(scope_id, payload, actor=None, server_id=None):+ """Re-converge exclusively through nginx lifecycle service doors."""+ del actor # Actor attribution belongs to the generic restore-point service.+ name = _validate_scope(scope_id, server_id)+ exists, enabled, content = _validate_payload(payload)++ if not exists:+ return NginxService.delete_site(name)++ written = NginxService.write_vhost(name, content, enable=enabled)+ if not written.get('success'):+ return written++ # write_vhost(enable=False) deliberately preserves a currently enabled+ # site. A restore target is stronger: reproduce the captured enabled bit.+ if not enabled:+ disabled = NginxService.disable_site(name)+ if not disabled.get('success'):+ return disabled++ return {'success': True, 'message': f'nginx vhost {name} restored'}diff --git a/backend/app/services/restore_point_adapters.py b/backend/app/services/restore_point_adapters.pynew file mode 100644index 00000000..43a49d01--- /dev/null+++ b/backend/app/services/restore_point_adapters.py@@ -0,0 +1,29 @@+"""Registration for the restore-point adapters shipped by core."""+++def register_builtin_restore_point_adapters():+ """Register core surfaces on every app-factory invocation.++ Registration is deliberately idempotent: tests and plugin reloads may+ rebuild the Flask app in the same process, and replacing an adapter with+ the same module is harmless.+ """+ from app.services import (+ restore_point_adapter_cron,+ restore_point_adapter_dns,+ restore_point_adapter_env,+ restore_point_adapter_firewall,+ restore_point_adapter_nginx,+ restore_point_service,+ )++ adapters = {+ 'cron': restore_point_adapter_cron,+ 'dns': restore_point_adapter_dns,+ 'env': restore_point_adapter_env,+ 'firewall': restore_point_adapter_firewall,+ 'nginx_vhost': restore_point_adapter_nginx,+ }+ for scope_type, adapter in adapters.items():+ restore_point_service.register_adapter(scope_type, adapter)+ return adaptersdiff --git a/backend/app/services/restore_point_service.py b/backend/app/services/restore_point_service.pyindex 1687f55d..ce516bc6 100644--- a/backend/app/services/restore_point_service.py+++ b/backend/app/services/restore_point_service.py@@ -47,8 +47,10 @@ BASE_COVERAGE = (SCOPE_COVERAGE = {'firewall': (- "Rules added outside the panel (fail2ban runtime bans, Docker's "- 'iptables chains) are not captured.',+ 'Persisted panel-supported UFW rules and firewalld service, port, and '+ 'rich-rule families are part of this checkpoint, including matching '+ 'rules created outside the panel. Other firewalld families, interfaces, '+ 'sources, and runtime-only fail2ban/Docker chains are not captured.',),'dns': ('Records that exist only at the provider and were never managed by 'diff --git a/backend/app/services/site_domain_service.py b/backend/app/services/site_domain_service.pyindex cddab812..4d767360 100644--- a/backend/app/services/site_domain_service.py+++ b/backend/app/services/site_domain_service.py@@ -571,9 +571,6 @@ class SiteDomainService:return {'nginx': None, 'warning': str(e)}if not res.get('success'):return {'nginx': res, 'warning': f"nginx vhost not created: {res.get('error')}"}- en = NginxService.enable_site(app.name)- if not en.get('success'):- return {'nginx': res, 'warning': f"vhost written but not enabled: {en.get('error')}"}return {'nginx': res, 'warning': None}@classmethoddiff --git a/backend/migrations/versions/092_restore_point_adapter_ledgers.py b/backend/migrations/versions/092_restore_point_adapter_ledgers.pynew file mode 100644index 00000000..61bca39b--- /dev/null+++ b/backend/migrations/versions/092_restore_point_adapter_ledgers.py@@ -0,0 +1,71 @@+"""Add restore-point replay metadata to environment and DNS ledgers.++Revision ID: 092_restore_point_ledgers+Revises: 091_restore_points+"""++import sqlalchemy as sa+from alembic import op++revision = '092_restore_point_ledgers'+down_revision = '091_restore_points'+branch_labels = None+depends_on = None+++def _has_column(table, column):+ return column in {+ item['name'] for item in sa.inspect(op.get_bind()).get_columns(table)+ }+++def upgrade():+ if not _has_column('environment_variable_history', 'batch_id'):+ op.add_column(+ 'environment_variable_history',+ sa.Column('batch_id', sa.String(length=36), nullable=True),+ )+ op.create_index(+ 'ix_environment_variable_history_batch_id',+ 'environment_variable_history',+ ['batch_id'],+ )++ if not _has_column('dns_changes', 'before_json'):+ op.add_column(+ 'dns_changes',+ sa.Column('before_json', sa.Text(), nullable=True),+ )++ if not _has_column('managed_dns_records', 'ttl'):+ op.add_column(+ 'managed_dns_records',+ sa.Column('ttl', sa.Integer(), nullable=True),+ )+ if not _has_column('managed_dns_records', 'priority'):+ op.add_column(+ 'managed_dns_records',+ sa.Column('priority', sa.Integer(), nullable=True),+ )+ if not _has_column('managed_dns_records', 'proxied'):+ op.add_column(+ 'managed_dns_records',+ sa.Column('proxied', sa.Boolean(), nullable=True),+ )+++def downgrade():+ if _has_column('managed_dns_records', 'proxied'):+ op.drop_column('managed_dns_records', 'proxied')+ if _has_column('managed_dns_records', 'priority'):+ op.drop_column('managed_dns_records', 'priority')+ if _has_column('managed_dns_records', 'ttl'):+ op.drop_column('managed_dns_records', 'ttl')+ if _has_column('dns_changes', 'before_json'):+ op.drop_column('dns_changes', 'before_json')+ if _has_column('environment_variable_history', 'batch_id'):+ op.drop_index(+ 'ix_environment_variable_history_batch_id',+ table_name='environment_variable_history',+ )+ op.drop_column('environment_variable_history', 'batch_id')diff --git a/backend/tests/api_controller_boundary_baseline.json b/backend/tests/api_controller_boundary_baseline.jsonindex 106cbf1e..2e264e84 100644--- a/backend/tests/api_controller_boundary_baseline.json+++ b/backend/tests/api_controller_boundary_baseline.json@@ -3,7 +3,7 @@"policy": "Exact reviewed inventory of direct persistence, subprocess, and filesystem mutation calls in Flask API controllers. New calls are forbidden; remove entries as controllers delegate to services.","counts": {"filesystem": 11,- "persistence": 504+ "persistence": 503},"owners": {"api/admin.py": {@@ -533,7 +533,6 @@"api/domains.py::verify_domain::persistence::Domain.query_active().filter_by(id=domain_id).first()::1","api/env_vars.py::check_app_access::persistence::Application.query_active().filter_by(id=app_id).first()::1","api/env_vars.py::check_app_access::persistence::User.query.get(user_id)::1",- "api/env_vars.py::update_env_var::persistence::db.session.commit()::1","api/environments.py::_accessible_workspace_ids::persistence::Workspace.query.all()::1","api/environments.py::create_environment::persistence::db.session.commit()::1","api/files.py::upload_file::filesystem::os.makedirs(parent)::1",diff --git a/backend/tests/test_dns_change_log.py b/backend/tests/test_dns_change_log.pyindex 9330e5b3..0d70a42b 100644--- a/backend/tests/test_dns_change_log.py+++ b/backend/tests/test_dns_change_log.py@@ -69,7 +69,8 @@ def test_failed_write_logs_error_and_notifies(app, monkeypatch):def test_delete_is_logged(app):from app.services.dns_ownership_service import DnsOwnershipService as Ofrom app.models.dns_change import DnsChange- O.record_write('cloudflare', 'z1', 'A', 'www.example.com', provider_record_id='R1', source='zone')+ O.record_write('cloudflare', 'z1', 'A', 'www.example.com',+ provider_record_id='R1', source='zone', config_id=3)O.guarded_delete(FakeClient(), provider_zone_id='z1', record_type='A',name='www.example.com', provider_record_id='R1', source='zone', config_id=3)row = DnsChange.query.filter_by(provider_zone_id='z1', action='delete').first()diff --git a/backend/tests/test_dns_cloudflare_client.py b/backend/tests/test_dns_cloudflare_client.pyindex 3c4e5875..8d11afd3 100644--- a/backend/tests/test_dns_cloudflare_client.py+++ b/backend/tests/test_dns_cloudflare_client.py@@ -162,6 +162,19 @@ def test_delete_missing_is_success(monkeypatch):assert res['success'] is True and 'already deleted' in res['message']+def test_delete_stale_record_id_is_idempotent(monkeypatch):+ from app.services.dns import cloudflare as cf+ monkeypatch.setattr(+ cf.requests, 'delete',+ lambda *a, **k: _Resp({+ 'success': False,+ 'errors': [{'code': 81044, 'message': 'DNS record does not exist'}],+ }),+ )+ res = _client().delete('z', record_id='stale')+ assert res['success'] is True++# ── zone layer regression: capture provider_record_id on create ──────────────def test_zone_create_record_persists_provider_record_id(app, monkeypatch):diff --git a/backend/tests/test_dns_restore_points.py b/backend/tests/test_dns_restore_points.pynew file mode 100644index 00000000..52cb2a27--- /dev/null+++ b/backend/tests/test_dns_restore_points.py@@ -0,0 +1,655 @@+"""Plan 81 M2: DNS guarded doors, complete ledger, and restore adapter."""+import json++import pytest+++class FakeRecordClient:+ def __init__(self, records=None, *, delete_result=None):+ self.records = records or {}+ self.delete_result = delete_result+ self.calls = []+ self._next_id = 1++ @staticmethod+ def _key(record_type, name):+ return record_type.upper(), name.lower().rstrip('.')++ def list_records(self, zone_id):+ return {'success': True, 'records': list(self.records.values())}++ def find_record_id(self, zone_id, record_type, name, caa=None):+ self.calls.append(('find', zone_id, record_type, name))+ row = self.records.get(self._key(record_type, name))+ return row.get('id') if row else None++ def upsert(self, zone_id, spec, record_id=None):+ self.calls.append(('upsert', zone_id, spec, record_id))+ record_id = record_id or f'R{self._next_id}'+ self._next_id += 1+ self.records[self._key(spec.record_type, spec.name)] = {+ 'id': record_id,+ 'type': spec.record_type,+ 'name': spec.name,+ 'content': spec.content,+ 'ttl': spec.ttl,+ 'priority': spec.priority,+ 'proxied': spec.proxied,+ }+ return {'success': True, 'record_id': record_id, 'message': 'set'}++ def delete(self, zone_id, record_id=None, record_type=None, name=None):+ self.calls.append(('delete', zone_id, record_id, record_type, name))+ if self.delete_result is not None:+ return self.delete_result+ self.records.pop(self._key(record_type, name), None)+ return {'success': True, 'message': 'deleted'}+++class RejectStaleIdClient(FakeRecordClient):+ """Models Cloudflare/DO: PUT to a deleted record id fails with not-found."""++ def upsert(self, zone_id, spec, record_id=None):+ live_ids = {row.get('id') for row in self.records.values()}+ if record_id is not None and record_id not in live_ids:+ self.calls.append(('stale-upsert', zone_id, spec, record_id))+ return {'success': False, 'error': 'record id not found'}+ return super().upsert(zone_id, spec, record_id=record_id)+++def _config(db, provider):+ from app.models.email import DNSProviderConfig+ row = DNSProviderConfig(+ name=f'{provider}-connection', provider=provider,+ api_key='key', api_secret='secret',+ )+ db.session.add(row)+ db.session.commit()+ return row+++ 'provider', ['cloudflare', 'route53', 'digitalocean', 'godaddy'],+)+def test_provider_service_writes_all_providers_through_guarded_door(+ app, monkeypatch, provider):+ from app import db+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services import restore_point_service+ from app.services.dns_provider_service import DNSProviderService++ config = _config(db, provider)+ client = FakeRecordClient()+ scopes = []+ monkeypatch.setattr(+ DNSProviderService, 'record_client',+ classmethod(lambda cls, cfg: client),+ )+ monkeypatch.setattr(+ restore_point_service, 'auto_capture',+ lambda scope_type, scope_id, action, **kwargs:+ scopes.append((scope_type, scope_id, action)),+ )++ result = DNSProviderService.set_record(+ config.id, 'zone-1', 'MX', 'example.com', 'mail.example.com',+ ttl=120, priority=10, proxied=True,+ )++ assert result['success'] is True+ row = ManagedDnsRecord.query.one()+ assert (row.provider, row.dns_provider_config_id, row.provider_zone_id) == (+ provider, config.id, 'zone-1',+ )+ assert (row.ttl, row.priority, row.proxied) == (120, 10, True)+ assert scopes == [(+ 'dns', f'{provider}:{config.id}:zone-1',+ 'upsert MX example.com',+ )]+++ 'provider', ['cloudflare', 'route53', 'digitalocean', 'godaddy'],+)+def test_supported_clients_share_record_contract(provider):+ from app.services.dns import get_record_client+ from app.services.dns.base import DnsCredential++ client = get_record_client(DnsCredential(+ provider=provider, token='key', secret='secret',+ ))+ assert all(callable(getattr(client, method)) for method in (+ 'list_records', 'find_record_id', 'upsert', 'delete',+ ))+++def test_rrset_ownership_is_scoped_by_provider_connection(app):+ from app import db+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services.dns_ownership_service import DnsOwnershipService as O++ first = _config(db, 'cloudflare')+ second = _config(db, 'cloudflare')+ O.record_write(+ 'cloudflare', 'shared-zone-id', 'A', 'WWW.Example.com.',+ provider_record_id='FIRST', content='1.1.1.1', config_id=first.id,+ )+ O.record_write(+ 'cloudflare', 'shared-zone-id', 'A', 'www.example.com',+ provider_record_id='SECOND', content='2.2.2.2', config_id=second.id,+ )++ assert ManagedDnsRecord.query.count() == 2+ assert O.owns(+ 'shared-zone-id', provider_record_id='FIRST',+ provider='cloudflare', config_id=first.id,+ )+ assert not O.owns(+ 'shared-zone-id', provider_record_id='FIRST',+ provider='cloudflare', config_id=second.id,+ )+++def test_change_log_keeps_complete_before_value(app, monkeypatch):+ from app import db+ from app.models.dns_change import DnsChange+ from app.services import restore_point_service+ from app.services.dns.base import DnsRecordSpec+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'cloudflare')+ client = FakeRecordClient()+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)+ O.guarded_upsert(+ client, provider='cloudflare', provider_zone_id='zone',+ spec=DnsRecordSpec('A', 'www.example.com', '1.1.1.1', 300,+ priority=None, proxied=True),+ source='zone', config_id=config.id,+ )+ O.guarded_upsert(+ client, provider='cloudflare', provider_zone_id='zone',+ spec=DnsRecordSpec('A', 'www.example.com', '2.2.2.2', 60,+ priority=None, proxied=False),+ source='zone', config_id=config.id,+ )++ change = DnsChange.query.filter_by(action='update').one()+ assert json.loads(change.before_json) == {+ 'app_id': None,+ 'content': '1.1.1.1',+ 'name': 'www.example.com',+ 'priority': None,+ 'proxied': True,+ 'record_type': 'A',+ 'source': 'zone',+ 'ttl': 300,+ }+++def test_guarded_door_canonicalizes_embedded_mx_priority(app, monkeypatch):+ from app import db+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services import restore_point_service+ from app.services.dns.base import DnsRecordSpec+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'route53')+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)+ O.guarded_upsert(+ FakeRecordClient(), provider='route53', provider_zone_id='zone',+ spec=DnsRecordSpec('MX', 'example.com', '10 mail.example.com', 300),+ source='email', config_id=config.id,+ )++ row = ManagedDnsRecord.query.one()+ assert row.content == 'mail.example.com'+ assert row.priority == 10+++def test_failed_delete_keeps_ownership_and_logs_preimage(app, monkeypatch):+ from app import db+ from app.models.dns_change import DnsChange+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services import restore_point_service+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'digitalocean')+ O.record_write(+ 'digitalocean', 'example.com', 'MX', 'example.com',+ provider_record_id='77', content='mail.example.com', ttl=600,+ priority=10, proxied=False, source='email', config_id=config.id,+ )+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)+ result = O.guarded_delete(+ FakeRecordClient(delete_result={'success': False, 'error': 'timeout'}),+ provider='digitalocean', provider_zone_id='example.com',+ record_type='MX', name='example.com', provider_record_id='77',+ source='email', config_id=config.id,+ )++ assert result['success'] is False+ assert ManagedDnsRecord.query.filter_by(provider_record_id='77').one()+ change = DnsChange.query.filter_by(action='delete').one()+ assert change.result == 'error'+ assert json.loads(change.before_json)['priority'] == 10+++def test_dns_capture_reads_managed_ledger_not_zone_mirror(app):+ from app import db+ from app.models.dns_zone import DNSRecord, DNSZone+ from app.services.dns_ownership_service import DnsOwnershipService as O+ from app.services.restore_point_adapter_dns import capture++ config = _config(db, 'cloudflare')+ zone = DNSZone(+ domain='example.com', provider='cloudflare', provider_zone_id='zone',+ dns_provider_config_id=config.id,+ )+ db.session.add(zone)+ db.session.flush()+ db.session.add(DNSRecord(+ zone_id=zone.id, record_type='A', name='foreign.example.com',+ content='9.9.9.9', ttl=60,+ ))+ db.session.commit()++ scope = f'cloudflare:{config.id}:zone'+ assert capture(scope)['records'] == []++ O.record_write(+ 'cloudflare', 'zone', 'A', 'owned.example.com',+ provider_record_id='OWNED', content='1.2.3.4', ttl=120,+ priority=None, proxied=True, source='zone', config_id=config.id,+ )+ payload = capture(scope)+ assert [row['name'] for row in payload['records']] == ['owned.example.com']+ assert payload['records'][0]['ttl'] == 120+ assert payload['records'][0]['proxied'] is True+++def test_dns_restore_round_trip_uses_guarded_calls(app, monkeypatch):+ from app import db+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services import restore_point_adapter_dns as adapter+ from app.services import restore_point_service+ from app.services.dns.base import DnsRecordSpec+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'cloudflare')+ client = FakeRecordClient()+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ scope = f'cloudflare:{config.id}:zone'++ O.guarded_upsert(+ client, provider='cloudflare', provider_zone_id='zone',+ spec=DnsRecordSpec('A', 'www.example.com', '1.1.1.1', 300,+ proxied=True),+ source='zone', config_id=config.id,+ )+ checkpoint = adapter.capture(scope)+ O.guarded_upsert(+ client, provider='cloudflare', provider_zone_id='zone',+ spec=DnsRecordSpec('A', 'www.example.com', '2.2.2.2', 60),+ source='zone', config_id=config.id,+ )+ O.guarded_upsert(+ client, provider='cloudflare', provider_zone_id='zone',+ spec=DnsRecordSpec('TXT', 'extra.example.com', 'remove-me', 60),+ source='zone', config_id=config.id,+ )++ result = adapter.restore(scope, checkpoint)+ assert result['success'] is True+ rows = ManagedDnsRecord.query.order_by(ManagedDnsRecord.record_type).all()+ assert [(row.record_type, row.content) for row in rows] == [+ ('A', '1.1.1.1'),+ ]+ assert rows[0].ttl == 300 and rows[0].proxied is True+ assert ('TXT', 'extra.example.com') not in client.records+++def test_dns_restore_refuses_provider_only_target(app, monkeypatch):+ from app import db+ from app.services import restore_point_adapter_dns as adapter++ config = _config(db, 'cloudflare')+ client = FakeRecordClient(records={+ ('A', 'foreign.example.com'): {+ 'id': 'FOREIGN', 'type': 'A', 'name': 'foreign.example.com',+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,+ 'proxied': False,+ },+ })+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ scope = f'cloudflare:{config.id}:zone'+ payload = {+ 'provider': 'cloudflare',+ 'config_id': config.id,+ 'provider_zone_id': 'zone',+ 'records': [{+ 'record_type': 'A', 'name': 'foreign.example.com',+ 'content': '1.2.3.4', 'ttl': 60, 'priority': None,+ 'proxied': False, 'source': 'restore', 'app_id': None,+ }],+ }++ result = adapter.restore(scope, payload)+ assert result['success'] is False and result['conflict'] is True+ assert not any(call[0] == 'upsert' for call in client.calls)+ assert client.records[('A', 'foreign.example.com')]['content'] == '9.9.9.9'+++def test_dns_validate_restore_surfaces_foreign_conflict(app, monkeypatch):+ from app import db+ from app.services import restore_point_adapter_dns as adapter++ config = _config(db, 'cloudflare')+ client = FakeRecordClient(records={+ ('A', 'foreign.example.com'): {+ 'id': 'FOREIGN', 'type': 'A', 'name': 'foreign.example.com',+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,+ 'proxied': False,+ },+ })+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ scope = f'cloudflare:{config.id}:zone'+ payload = {+ 'provider': 'cloudflare', 'config_id': config.id,+ 'provider_zone_id': 'zone',+ 'records': [{+ 'record_type': 'A', 'name': 'foreign.example.com',+ 'content': '1.2.3.4', 'ttl': 60, 'priority': None,+ 'proxied': False, 'source': 'restore', 'app_id': None,+ }],+ }++ refusals = adapter.validate_restore(scope, payload, {'records': []})+ assert len(refusals) == 1+ assert 'provider-only DNS record A foreign.example.com' in refusals[0]+++def test_restore_point_preview_disables_foreign_dns_restore(app, monkeypatch):+ from app import db+ from app.services import restore_point_adapter_dns as adapter+ from app.services import restore_point_service as service+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'cloudflare')+ scope = f'cloudflare:{config.id}:zone'+ O.record_write(+ 'cloudflare', 'zone', 'A', 'foreign.example.com',+ provider_record_id='FORMERLY-OURS', content='1.2.3.4', ttl=60,+ source='zone', config_id=config.id,+ )+ monkeypatch.setitem(service.ADAPTERS, 'dns', adapter)+ point = service.capture('dns', scope, 'manual')+ O.record_delete(+ 'zone', provider_record_id='FORMERLY-OURS', provider='cloudflare',+ config_id=config.id,+ )++ client = FakeRecordClient(records={+ ('A', 'foreign.example.com'): {+ 'id': 'FOREIGN', 'type': 'A', 'name': 'foreign.example.com',+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,+ 'proxied': False,+ },+ })+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)++ preview = service.preview(point.id)+ assert preview['can_restore'] is False+ assert 'provider-only DNS record' in preview['refusals'][0]+++def test_dns_restore_repairs_provider_when_ledger_already_matches(app, monkeypatch):+ from app import db+ from app.services import restore_point_adapter_dns as adapter+ from app.services import restore_point_service+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'cloudflare')+ client = RejectStaleIdClient() # provider record drifted away / was deleted+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ scope = f'cloudflare:{config.id}:zone'+ O.record_write(+ 'cloudflare', 'zone', 'A', 'www.example.com',+ provider_record_id='STALE', content='1.1.1.1', ttl=300,+ proxied=True, source='zone', config_id=config.id,+ )+ checkpoint = adapter.capture(scope)++ result = adapter.restore(scope, checkpoint)+ assert result['success'] is True+ assert any(call[0] == 'upsert' for call in client.calls)+ assert not any(call[0] == 'stale-upsert' for call in client.calls)+ assert client.records[('A', 'www.example.com')]['content'] == '1.1.1.1'+++def test_legacy_dns_attributes_remain_unknown_and_restore_refuses_to_guess(+ app, monkeypatch):+ from app import db+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services import restore_point_adapter_dns as adapter++ config = _config(db, 'cloudflare')+ db.session.add(ManagedDnsRecord(+ provider='cloudflare', dns_provider_config_id=config.id,+ provider_zone_id='zone', provider_record_id='OLD',+ record_type='A', name='legacy.example.com', content='1.2.3.4',+ ttl=None, priority=None, proxied=None, source='zone',+ ))+ db.session.commit()+ scope = f'cloudflare:{config.id}:zone'+ payload = adapter.capture(scope)+ record = payload['records'][0]+ assert record['ttl'] is None+ assert record['priority'] is None+ assert record['proxied'] is None++ client = FakeRecordClient() # live record is also gone; no safe hydration+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ refusals = adapter.validate_restore(scope, payload, payload)+ assert any('unknown legacy TTL' in refusal for refusal in refusals)+ assert any('unknown legacy proxy state' in refusal for refusal in refusals)++ result = adapter.restore(scope, payload)+ assert result['success'] is False and result['refused'] is True+ assert not any(call[0] == 'upsert' for call in client.calls)+++def test_legacy_dns_attributes_hydrate_from_live_provider(app, monkeypatch):+ from app import db+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services import restore_point_adapter_dns as adapter+ from app.services import restore_point_service++ config = _config(db, 'cloudflare')+ db.session.add(ManagedDnsRecord(+ provider='cloudflare', dns_provider_config_id=config.id,+ provider_zone_id='zone', provider_record_id='OLD',+ record_type='A', name='legacy.example.com', content='1.2.3.4',+ ttl=None, priority=None, proxied=None, source='zone',+ ))+ db.session.commit()+ scope = f'cloudflare:{config.id}:zone'+ payload = adapter.capture(scope)+ client = FakeRecordClient(records={+ ('A', 'legacy.example.com'): {+ 'id': 'OLD', 'type': 'A', 'name': 'legacy.example.com',+ 'content': '9.9.9.9', 'ttl': 120, 'priority': None,+ 'proxied': True,+ },+ })+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)++ assert adapter.validate_restore(scope, payload, payload) == []+ result = adapter.restore(scope, payload)+ assert result['success'] is True+ row = ManagedDnsRecord.query.one()+ assert row.ttl == 120 and row.proxied is True+ live = client.records[('A', 'legacy.example.com')]+ assert live['content'] == '1.2.3.4'+ assert live['ttl'] == 120 and live['proxied'] is True++[email protected]('provider', ['route53', 'godaddy'])+def test_dns_restore_refuses_delete_of_synthetic_id_replacement(+ app, monkeypatch, provider):+ from app import db+ from app.services import restore_point_adapter_dns as adapter+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, provider)+ zone_id = 'zone'+ synthetic_id = 'A:old.example.com'+ O.record_write(+ provider, zone_id, 'A', 'old.example.com',+ provider_record_id=synthetic_id, content='1.1.1.1', ttl=300,+ proxied=False, source='zone', config_id=config.id,+ )+ client = FakeRecordClient(records={+ ('A', 'old.example.com'): {+ 'id': synthetic_id, 'type': 'A', 'name': 'old.example.com',+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,+ 'proxied': False,+ },+ })+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ scope = f'{provider}:{config.id}:{zone_id}'+ empty_target = {+ 'provider': provider, 'config_id': config.id,+ 'provider_zone_id': zone_id, 'records': [],+ }++ refusals = adapter.validate_restore(scope, empty_target, empty_target)+ assert any('provider-only replacement' in item for item in refusals)+ result = adapter.restore(scope, empty_target)+ assert result['success'] is False and result['refused'] is True+ assert not any(call[0] == 'delete' for call in client.calls)+++def test_synthetic_mx_encoded_priority_is_same_owned_record(app, monkeypatch):+ from app import db+ from app.services import restore_point_adapter_dns as adapter+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'route53')+ O.record_write(+ 'route53', 'zone', 'MX', 'example.com',+ provider_record_id='MX:example.com', content='10 mail.example.com.',+ ttl=300, priority=None, proxied=False, source='legacy',+ config_id=config.id,+ )+ client = FakeRecordClient(records={+ ('MX', 'example.com'): {+ 'id': 'MX:example.com', 'type': 'MX', 'name': 'example.com',+ 'content': 'mail.example.com', 'ttl': 300, 'priority': 10,+ 'proxied': False,+ },+ })+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ scope = f'route53:{config.id}:zone'+ empty_target = {+ 'provider': 'route53', 'config_id': config.id,+ 'provider_zone_id': 'zone', 'records': [],+ }++ assert adapter.validate_restore(scope, empty_target, empty_target) == []+ result = adapter.restore(scope, empty_target)+ assert result['success'] is True+ assert any(call[0] == 'delete' for call in client.calls)+++def test_dns_restore_forgets_stale_ledger_when_provider_already_absent(+ app, monkeypatch):+ from app import db+ from app.models.managed_dns_record import ManagedDnsRecord+ from app.services import restore_point_adapter_dns as adapter+ from app.services.dns_ownership_service import DnsOwnershipService as O++ config = _config(db, 'cloudflare')+ O.record_write(+ 'cloudflare', 'zone', 'A', 'gone.example.com',+ provider_record_id='STALE', content='1.1.1.1', ttl=300,+ proxied=False, source='zone', config_id=config.id,+ )+ client = FakeRecordClient() # compliant delete treats missing id as success+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)+ scope = f'cloudflare:{config.id}:zone'+ empty_target = {+ 'provider': 'cloudflare', 'config_id': config.id,+ 'provider_zone_id': 'zone', 'records': [],+ }++ result = adapter.restore(scope, empty_target)+ assert result['success'] is True+ assert ManagedDnsRecord.query.count() == 0+++def test_digitalocean_delete_stale_record_id_is_idempotent(monkeypatch):+ from app.services.dns.base import DnsCredential+ from app.services.dns.providers import DigitalOceanClient+ from app.services.dns import providers++ class MissingResponse:+ status_code = 404++ @staticmethod+ def json():+ return {'id': 'not_found', 'message': 'record not found'}++ monkeypatch.setattr(+ providers.requests, 'delete', lambda *a, **k: MissingResponse(),+ )+ client = DigitalOceanClient(DnsCredential(+ provider='digitalocean', token='token',+ ))+ result = client.delete('example.com', record_id='stale')+ assert result['success'] is True++[email protected]('provider', ['route53', 'godaddy'])+def test_rrset_providers_detect_different_caa_as_existing(monkeypatch, provider):+ """A typed RRset PUT would replace other values, so strict guards must see it."""+ from app.services.dns.base import DnsCredential+ from app.services.dns.providers import GoDaddyClient, Route53Client+ from app.services.dns import providers++ caa = {'flags': 0, 'tag': 'issue', 'value': 'letsencrypt.org'}+ if provider == 'route53':+ class FakeBoto:+ @staticmethod+ def list_resource_record_sets(**kwargs):+ return {'ResourceRecordSets': [{+ 'Name': 'example.com.', 'Type': 'CAA', 'TTL': 300,+ 'ResourceRecords': [{'Value': '0 issue "digicert.com"'}],+ }]}++ client = Route53Client(+ DnsCredential(provider='route53'), client=FakeBoto(),+ )+ else:+ class Response:+ status_code = 200++ @staticmethod+ def json():+ return [{+ 'type': 'CAA', 'name': '@', 'data': 'digicert.com',+ 'flags': 0, 'tag': 'issue', 'ttl': 300,+ }]++ monkeypatch.setattr(+ providers.requests, 'get', lambda *a, **k: Response(),+ )+ client = GoDaddyClient(DnsCredential(+ provider='godaddy', token='key', secret='secret',+ ))++ assert client.find_record_id(+ 'example.com', 'CAA', 'example.com', caa=caa,+ ) is not Nonediff --git a/backend/tests/test_restore_point_adapters.py b/backend/tests/test_restore_point_adapters.pynew file mode 100644index 00000000..439f60f5--- /dev/null+++ b/backend/tests/test_restore_point_adapters.py@@ -0,0 +1,10 @@+"""Core restore-point adapter registration contract."""+++def test_app_factory_registers_every_builtin_restore_surface(app):+ from app.services.restore_point_service import get_adapter++ assert {+ scope for scope in ('cron', 'dns', 'env', 'firewall', 'nginx_vhost')+ if get_adapter(scope) is not None+ } == {'cron', 'dns', 'env', 'firewall', 'nginx_vhost'}diff --git a/backend/tests/test_restore_point_cron.py b/backend/tests/test_restore_point_cron.pynew file mode 100644index 00000000..c6ee6e38--- /dev/null+++ b/backend/tests/test_restore_point_cron.py@@ -0,0 +1,181 @@+"""Plan 81 M2: local CRON restore-point payloads and service hooks."""++from copy import deepcopy++import pytest++from app.services.cron_service import CronService+from app.services import restore_point_adapter_cron as adapter+++def cron_state(tmp_path, monkeypatch):+ import app.services.cron_service as module++ monkeypatch.setattr(module, 'JOBS_FILE', str(tmp_path / 'cron_jobs.json'))+ monkeypatch.setattr(CronService, 'is_linux', classmethod(lambda cls: True))+ state = {'crontab': '# hand-written\n0 1 * * * /usr/bin/original\n'}+ monkeypatch.setattr(+ CronService, '_read_crontab',+ classmethod(lambda cls: state['crontab']),+ )++ def install(cls, content):+ state['crontab'] = content+ return None++ monkeypatch.setattr(CronService, '_install_crontab', classmethod(install))+ CronService._save_jobs_metadata({'jobs': {+ 'job_1': {+ 'name': 'Original',+ 'schedule': '0 1 * * *',+ 'command': '/usr/bin/original',+ 'enabled': True,+ 'tracked': False,+ 'application_id': 7,+ },+ }})+ return state+++def test_capture_contains_full_crontab_and_metadata(cron_state):+ payload = adapter.capture('cron')++ assert payload['crontab'] == cron_state['crontab']+ assert payload['metadata']['jobs']['job_1']['application_id'] == 7+++def test_capture_fails_when_linux_crontab_is_unreadable(cron_state, monkeypatch):+ monkeypatch.setattr(+ CronService, '_read_crontab', classmethod(lambda cls: None),+ )++ with pytest.raises(RuntimeError, match='Could not read'):+ adapter.capture('cron')+++def test_capture_fails_when_metadata_is_corrupt(cron_state, monkeypatch):+ import app.services.cron_service as module++ with open(module.JOBS_FILE, 'w') as handle:+ handle.write('{not-json')++ with pytest.raises(RuntimeError, match='metadata is unreadable'):+ adapter.capture('cron')+++def test_restore_round_trip_reconverges_both_components(cron_state):+ saved = adapter.capture('cron')+ cron_state['crontab'] = '*/5 * * * * /usr/bin/changed\n'+ CronService._save_jobs_metadata({'jobs': {+ 'changed': {'schedule': '*/5 * * * *', 'command': '/usr/bin/changed'},+ }})++ result = adapter.restore('cron', saved)++ assert result['success'] is True+ assert adapter.capture('cron') == saved+++def test_restore_rolls_crontab_back_when_metadata_write_fails(+ cron_state, monkeypatch):+ target = {+ 'crontab': '0 4 * * * /usr/bin/target\n',+ 'metadata': {'jobs': {'target': {'command': '/usr/bin/target'}}},+ }+ before = adapter.capture('cron')+ real_save = CronService._save_jobs_metadata.__func__+ writes = []++ def fail_target_once(cls, metadata):+ writes.append(deepcopy(metadata))+ if len(writes) == 1:+ raise OSError('disk full')+ return real_save(cls, metadata)++ monkeypatch.setattr(+ CronService, '_save_jobs_metadata', classmethod(fail_target_once),+ )++ result = adapter.restore('cron', target)++ assert result['success'] is False+ assert result['rolled_back'] is True+ assert cron_state['crontab'] == before['crontab']+ assert CronService._load_jobs_metadata() == before['metadata']+++def test_metadata_only_mutators_checkpoint_and_alert_flag_is_in_service(+ app, tmp_path, monkeypatch):+ import app.services.cron_service as module+ from app.services import restore_point_service++ monkeypatch.setattr(module, 'JOBS_FILE', str(tmp_path / 'cron_jobs.json'))+ monkeypatch.setattr(CronService, 'is_linux', classmethod(lambda cls: False))+ existing = restore_point_service.get_adapter('cron')+ restore_point_service.register_adapter('cron', adapter)+ captured = []+ monkeypatch.setattr(+ restore_point_service, 'capture',+ lambda *args, **kwargs: captured.append((args, kwargs)),+ )++ try:+ created = CronService.add_job(+ '0 0 * * *', '/usr/bin/task', application_id=9,+ )+ job_id = created['job_id']+ CronService.update_job(job_id, description='metadata only')+ CronService.set_tracking(job_id, True, alert_on_failure=False)+ assert CronService.get_job(job_id)['alert_on_failure'] is False+ CronService.toggle_job(job_id, False)+ CronService.remove_job(job_id)+ finally:+ if existing is None:+ restore_point_service.ADAPTERS.pop('cron', None)+ else:+ restore_point_service.register_adapter('cron', existing)++ actions = [item[1]['label'] for item in captured]+ assert actions == [+ 'before cron.add_job',+ 'before cron.update_job',+ 'before cron.set_tracking',+ 'before cron.toggle_job',+ 'before cron.remove_job',+ ]+++def test_application_bulk_suspend_captures_once(app, tmp_path, monkeypatch):+ import app.services.cron_service as module+ from app.services import restore_point_service++ monkeypatch.setattr(module, 'JOBS_FILE', str(tmp_path / 'cron_jobs.json'))+ monkeypatch.setattr(CronService, 'is_linux', classmethod(lambda cls: False))+ CronService._save_jobs_metadata({'jobs': {+ 'one': {'application_id': 4, 'enabled': True},+ 'two': {'application_id': 4, 'enabled': True},+ }})+ existing = restore_point_service.get_adapter('cron')+ restore_point_service.register_adapter('cron', adapter)+ captured = []+ monkeypatch.setattr(+ restore_point_service, 'capture',+ lambda *args, **kwargs: captured.append((args, kwargs)),+ )++ try:+ assert CronService.suspend_for_application(4) == 2+ assert CronService.resume_for_application(4) == 2+ assert CronService.clear_application(4) == 2+ finally:+ if existing is None:+ restore_point_service.ADAPTERS.pop('cron', None)+ else:+ restore_point_service.register_adapter('cron', existing)++ assert [item[1]['label'] for item in captured] == [+ 'before cron.suspend_for_application',+ 'before cron.resume_for_application',+ 'before cron.clear_application',+ ]diff --git a/backend/tests/test_restore_point_env.py b/backend/tests/test_restore_point_env.pynew file mode 100644index 00000000..4bc05d94--- /dev/null+++ b/backend/tests/test_restore_point_env.py@@ -0,0 +1,260 @@+"""Plan 81 M2: environment restore-point adapter and mutation doors."""++import json++import pytest++from app.models import EnvironmentVariableHistory, RestorePoint+from app.services import restore_point_adapter_env as env_adapter+from app.utils.sensitive_data_filter import MASK+++def registered_env_adapter():+ from app.services import restore_point_service++ existing = dict(restore_point_service.ADAPTERS)+ restore_point_service.register_adapter('env', env_adapter)+ try:+ yield restore_point_service+ finally:+ restore_point_service.clear_adapters()+ restore_point_service.ADAPTERS.update(existing)+++def _make_app():+ from app import db+ from app.models import Application, User++ user = User(+ username='restore-env-owner',+ email='[email protected]',+ role='admin',+ )+ db.session.add(user)+ db.session.flush()+ application = Application(+ name='restore-env-app',+ app_type='docker',+ user_id=user.id,+ status='running',+ )+ db.session.add(application)+ db.session.commit()+ return application, user+++def test_capture_masks_flags_sensitive_names_and_keeps_reference_metadata(+ app, registered_env_adapter):+ from app.services.env_service import EnvService++ application, user = _make_app()+ EnvService.set_env_var(+ application.id, 'PUBLIC_URL', 'https://example.test', user_id=user.id,+ )+ EnvService.set_env_var(+ application.id, 'API_TOKEN', 'raw-token', is_secret=False,+ user_id=user.id,+ )+ EnvService.set_env_var(+ application.id, 'INTERNAL', 'raw-secret', is_secret=True,+ user_id=user.id,+ )+ reference = {'kind': 'secret', 'secret': 'stripe_prod'}+ EnvService.set_env_reference(+ application.id, 'STRIPE_KEY', reference, user.id,+ target_service='web', description='Stripe credential',+ )++ point = registered_env_adapter.capture(+ 'env', application.id, 'manual', label='mask-proof', actor=user.id,+ )+ payload = json.loads(point.payload_json)+ assert payload['env']['PUBLIC_URL']['value'] == 'https://example.test'+ assert payload['env']['API_TOKEN']['value'] == MASK+ assert payload['env']['INTERNAL']['value'] == MASK+ assert payload['env']['STRIPE_KEY'] == {+ 'value': MASK,+ 'is_secret': True,+ 'description': 'Stripe credential',+ 'target_service': 'web',+ 'value_from': reference,+ }+ serialized = json.dumps(payload)+ assert 'raw-token' not in serialized+ assert 'raw-secret' not in serialized+++def test_every_env_mutation_door_auto_captures_once(+ app, monkeypatch, registered_env_adapter):+ from app.services import restore_point_service+ from app.services.env_service import EnvService++ application, user = _make_app()+ captures = []++ def fake_capture(scope_type, scope_id, trigger, **kwargs):+ captures.append((scope_type, scope_id, trigger, kwargs.get('label')))+ return object()++ monkeypatch.setattr(restore_point_service, 'capture', fake_capture)++ first, _, _ = EnvService.set_env_var(+ application.id, 'FIRST', '1', user_id=user.id,+ )+ EnvService.update_env_var(+ application.id, 'FIRST', value='2', user_id=user.id,+ )+ EnvService.set_env_reference(+ application.id, 'REF', {'kind': 'secret', 'secret': 'one'}, user.id,+ )+ EnvService.delete_env_var(application.id, 'REF', user.id)+ EnvService.delete_env_var_by_id(first.id, user.id)+ EnvService.bulk_set_env_vars(+ application.id, {'SECOND': '2', 'THIRD': '3'}, user.id,+ )+ EnvService.clear_all(application.id, user.id)++ assert [item[3] for item in captures] == [+ 'before env.set_env_var',+ 'before env.update_env_var',+ 'before env.set_env_reference',+ 'before env.delete_env_var',+ 'before env.delete_env_var_by_id',+ 'before env.bulk_set_env_vars',+ 'before env.clear_all',+ ]+ assert all(item[:3] == (+ 'env', str(application.id), 'pre_mutation',+ ) for item in captures)+++def test_bulk_and_clear_history_rows_share_operation_batch(+ app, registered_env_adapter):+ from app.services.env_service import EnvService++ application, user = _make_app()+ EnvService.bulk_set_env_vars(+ application.id, {'ONE': '1', 'TWO': '2'}, user.id,+ )++ created = EnvironmentVariableHistory.query.filter_by(+ application_id=application.id,+ action='created',+ ).order_by(EnvironmentVariableHistory.id).all()+ assert len(created) == 2+ assert created[0].batch_id+ assert {row.batch_id for row in created} == {created[0].batch_id}++ EnvService.clear_all(application.id, user.id)+ deleted = EnvironmentVariableHistory.query.filter_by(+ application_id=application.id,+ action='deleted',+ ).order_by(EnvironmentVariableHistory.id).all()+ assert len(deleted) == 2+ assert deleted[0].batch_id+ assert {row.batch_id for row in deleted} == {deleted[0].batch_id}+ assert deleted[0].batch_id != created[0].batch_id+ assert all(row.to_dict()['batch_id'] == row.batch_id for row in deleted)+++def test_restore_round_trip_reconverges_and_groups_history(+ app, registered_env_adapter):+ from app.services.env_service import EnvService++ application, user = _make_app()+ EnvService.set_env_var(+ application.id, 'FEATURE_FLAG', 'on', user_id=user.id,+ )+ point = registered_env_adapter.capture(+ 'env', application.id, 'manual', label='known-good', actor=user.id,+ )++ EnvService.set_env_var(+ application.id, 'FEATURE_FLAG', 'off', user_id=user.id,+ )+ EnvService.set_env_var(+ application.id, 'TEMPORARY', 'remove-me', user_id=user.id,+ )+ points_before_restore = RestorePoint.query.filter_by(+ scope_type='env', scope_id=str(application.id),+ ).count()++ result = registered_env_adapter.restore(point.id, actor=user)++ assert result['success'] is True+ assert EnvService.get_env_var(application.id, 'FEATURE_FLAG').value == 'on'+ assert EnvService.get_env_var(application.id, 'TEMPORARY') is None+ assert RestorePoint.query.filter_by(+ scope_type='env', scope_id=str(application.id),+ ).count() == points_before_restore + 1++ replay_rows = EnvironmentVariableHistory.query.filter_by(+ application_id=application.id,+ batch_id=result['batch_id'],+ ).all()+ assert {row.key for row in replay_rows} == {'FEATURE_FLAG', 'TEMPORARY'}+ assert {row.batch_id for row in replay_rows} == {result['batch_id']}+++def test_restore_keeps_live_masked_values_and_replays_references(+ app, registered_env_adapter):+ from app.services.env_service import EnvService++ application, user = _make_app()+ EnvService.set_env_var(+ application.id, 'API_TOKEN', 'old-token', is_secret=True,+ user_id=user.id,+ )+ original_reference = {'kind': 'secret', 'secret': 'stripe_old'}+ EnvService.set_env_reference(+ application.id, 'STRIPE_KEY', original_reference, user.id,+ )+ point = registered_env_adapter.capture(+ 'env', application.id, 'manual', label='with-secrets', actor=user.id,+ )++ EnvService.set_env_var(+ application.id, 'API_TOKEN', 'rotated-token', is_secret=True,+ user_id=user.id,+ )+ EnvService.set_env_reference(+ application.id, 'STRIPE_KEY',+ {'kind': 'secret', 'secret': 'stripe_new'}, user.id,+ )+ EnvService.set_env_reference(+ application.id, 'LIVE_ONLY_REF',+ {'kind': 'secret', 'secret': 'keep_me'}, user.id,+ )++ result = registered_env_adapter.restore(point.id, actor=user)++ token = EnvService.get_env_var(application.id, 'API_TOKEN')+ stripe = EnvService.get_env_var(application.id, 'STRIPE_KEY')+ live_only = EnvService.get_env_var(application.id, 'LIVE_ONLY_REF')+ assert token.value == 'rotated-token'+ assert stripe.get_reference() == original_reference+ assert live_only.get_reference() == {+ 'kind': 'secret', 'secret': 'keep_me',+ }+ assert 'API_TOKEN' in result['skipped_secrets']+ assert 'LIVE_ONLY_REF' in result['preserved_references']+ assert MASK not in {token.value, stripe.value, live_only.value}+++def test_env_diff_is_secret_safe_and_key_granular():+ old = {'env': {+ 'TOKEN': {'value': MASK, 'is_secret': True},+ 'FLAG': {'value': 'on', 'is_secret': False},+ }}+ new = {'env': {+ 'TOKEN': {'value': MASK, 'is_secret': True},+ 'FLAG': {'value': 'off', 'is_secret': False},+ 'ADDED': {'value': 'yes', 'is_secret': False},+ }}++ result = env_adapter.diff(old, new)+ assert set(result['added']) == {'ADDED'}+ assert set(result['changed']) == {'FLAG'}+ assert result['removed'] == {}+ assert 'TOKEN' not in result['changed']diff --git a/backend/tests/test_restore_point_firewall.py b/backend/tests/test_restore_point_firewall.pynew file mode 100644index 00000000..ad8189c8--- /dev/null+++ b/backend/tests/test_restore_point_firewall.py@@ -0,0 +1,206 @@+"""Plan 81 firewall checkpoint adapter and mutation-door coverage."""++from types import SimpleNamespace++import pytest+++def _ufw_payload(*, enabled=True, allow_default=False, rules=None):+ return {+ 'version': 1,+ 'firewall': 'ufw',+ 'enabled': enabled,+ 'default_zone': None,+ 'default_incoming_allow': allow_default,+ 'rules': rules or [],+ }+++def test_capture_uses_replayable_ufw_rules(monkeypatch):+ from app.services import restore_point_adapter_firewall as adapter++ monkeypatch.setattr(adapter.FirewallService, 'get_status', classmethod(+ lambda cls: {+ 'active_firewall': 'ufw',+ 'ufw': {'installed': True, 'active': False},+ 'firewalld': {'installed': False, 'running': False},+ }))+ monkeypatch.setattr(+ adapter.FirewallService, '_ufw_default_incoming_policy',+ classmethod(lambda cls: False),+ )+ monkeypatch.setattr(adapter, 'run_privileged', lambda argv, timeout=None: SimpleNamespace(+ returncode=0,+ stdout=('Added user rules\n'+ 'ufw deny from 203.0.113.9\n'+ 'ufw allow 2222/tcp\n'),+ stderr='',+ ))++ payload = adapter.capture('firewall')++ assert payload['enabled'] is False+ assert payload['default_incoming_allow'] is False+ assert payload['rules'] == sorted([+ {'kind': 'ufw', 'argv': ['deny', 'from', '203.0.113.9']},+ {'kind': 'ufw', 'argv': ['allow', '2222/tcp']},+ ], key=adapter._rule_key)+++def test_capture_refuses_unknown_ufw_policy_and_remote_scope(monkeypatch):+ from app.services import restore_point_adapter_firewall as adapter++ monkeypatch.setattr(adapter.FirewallService, 'get_status', classmethod(+ lambda cls: {+ 'active_firewall': 'ufw',+ 'ufw': {'installed': True, 'active': False},+ 'firewalld': {'installed': False, 'running': False},+ }))+ monkeypatch.setattr(+ adapter.FirewallService, '_ufw_default_incoming_policy',+ classmethod(lambda cls: None),+ )++ with pytest.raises(RuntimeError, match='default incoming policy'):+ adapter.capture('firewall')+ with pytest.raises(ValueError, match='remote firewall'):+ adapter.capture('firewall', server_id='remote-1')+++def test_firewalld_capture_includes_non_default_zones(monkeypatch):+ from app.services import restore_point_adapter_firewall as adapter++ monkeypatch.setattr(adapter.FirewallService, 'get_status', classmethod(+ lambda cls: {+ 'active_firewall': 'firewalld',+ 'firewalld': {+ 'installed': True, 'running': True, 'default_zone': 'public',+ },+ 'ufw': {'installed': False, 'active': False},+ }))++ def output(argv):+ if argv[-1] == '--get-zones':+ return 'public internal'+ zone = next((part.split('=', 1)[1] for part in argv if part.startswith('--zone=')), '')+ if argv[-1] == '--list-services':+ return 'ssh' if zone == 'public' else 'postgresql'+ if argv[-1] == '--list-ports':+ return ''+ if argv[-1] == '--list-rich-rules':+ return ''+ raise AssertionError(argv)++ monkeypatch.setattr(adapter, '_run', output)++ payload = adapter.capture('firewall')++ assert {(rule['zone'], rule['service']) for rule in payload['rules']} == {+ ('public', 'ssh'), ('internal', 'postgresql'),+ }+++def test_validate_restore_refuses_ssh_lockout_and_protected_address(monkeypatch):+ from app.services import restore_point_adapter_firewall as adapter++ target = _ufw_payload(rules=[+ {'kind': 'ufw', 'argv': ['deny', 'from', '127.0.0.0/8']},+ ])+ monkeypatch.setattr(+ adapter.FirewallService, 'ssh_ports', classmethod(lambda cls: [2222]),+ )+ monkeypatch.setattr(+ adapter.FirewallService, 'active_ssh_peers', classmethod(lambda cls: set()),+ )++ refusals = adapter.validate_restore('firewall', target, _ufw_payload())++ assert any('does not admit SSH on port 2222' in item for item in refusals)+ assert any('protected live address' in item for item in refusals)+++def test_restore_replays_additions_before_default_and_removals(monkeypatch):+ from app.services import restore_point_adapter_firewall as adapter++ current = _ufw_payload(rules=[+ {'kind': 'ufw', 'argv': ['allow', '80/tcp']},+ ])+ target = _ufw_payload(rules=[+ {'kind': 'ufw', 'argv': ['allow', '2222/tcp']},+ ])+ monkeypatch.setattr(adapter, 'capture', lambda *_a, **_k: current)+ monkeypatch.setattr(+ adapter.FirewallService, 'ssh_ports', classmethod(lambda cls: [2222]),+ )+ calls = []+ monkeypatch.setattr(+ adapter.FirewallService, 'add_rule', classmethod(+ lambda cls, kind, **values: calls.append(('add', kind, values)) or {'success': True}+ ),+ )+ monkeypatch.setattr(+ adapter.FirewallService, 'remove_rule', classmethod(+ lambda cls, kind, **values: calls.append(('remove', kind, values)) or {'success': True}+ ),+ )++ result = adapter.restore('firewall', target)++ assert result == {'success': True, 'rules_added': 1, 'rules_removed': 1}+ assert [call[0] for call in calls] == ['add', 'remove']+ assert calls[0][2]['port'] == 2222+ assert calls[1][2]['port'] == 80+++def test_restore_disables_before_removing_last_rule(monkeypatch):+ from app.services import restore_point_adapter_firewall as adapter++ current = _ufw_payload(enabled=True, rules=[+ {'kind': 'ufw', 'argv': ['allow', '2222/tcp']},+ ])+ target = _ufw_payload(enabled=False)+ monkeypatch.setattr(adapter, 'capture', lambda *_a, **_k: current)+ monkeypatch.setattr(+ adapter.FirewallService, 'ssh_ports', classmethod(lambda cls: [2222]),+ )+ calls = []+ monkeypatch.setattr(+ adapter.FirewallService, 'disable', classmethod(+ lambda cls, firewall=None: calls.append('disable') or {'success': True}+ ),+ )+ monkeypatch.setattr(+ adapter.FirewallService, 'remove_rule', classmethod(+ lambda cls, kind, **values: calls.append('remove') or {'success': True}+ ),+ )++ assert adapter.restore('firewall', target)['success'] is True+ assert calls == ['disable', 'remove']+++def test_firewall_door_checkpoints_only_after_request_validation(app, monkeypatch):+ from app.services.firewall_service import FirewallService+ from app.services import restore_point_service++ monkeypatch.setattr(FirewallService, 'get_status', classmethod(lambda cls: {+ 'active_firewall': 'ufw',+ 'any_active': False,+ 'ufw': {'installed': True, 'active': False},+ 'firewalld': {'installed': False, 'running': False},+ }))+ monkeypatch.setattr(+ FirewallService, '_add_ufw_rule',+ classmethod(lambda cls, kind, **values: {'success': True}),+ )+ captures = []+ monkeypatch.setattr(+ restore_point_service, 'auto_capture',+ lambda *args, **kwargs: captures.append((args, kwargs)),+ )+ monkeypatch.setattr(restore_point_service, 'get_adapter', lambda scope: object())++ assert FirewallService.add_rule('port')['success'] is False+ assert captures == []+ assert FirewallService.add_rule('port', port=443)['success'] is True+ assert captures[0][0][:3] == ('firewall', 'firewall', 'add_rule')diff --git a/backend/tests/test_restore_point_nginx.py b/backend/tests/test_restore_point_nginx.pynew file mode 100644index 00000000..f5ac1035--- /dev/null+++ b/backend/tests/test_restore_point_nginx.py@@ -0,0 +1,189 @@+"""Plan 81 M2: nginx vhost restore-point payloads and lifecycle hooks."""++import os+from types import SimpleNamespace++import pytest++from app.services.nginx_service import NginxService+from app.services import restore_point_adapter_nginx as adapter+++def nginx_tree(tmp_path, monkeypatch, fake_subprocess):+ available = tmp_path / 'sites-available'+ enabled = tmp_path / 'sites-enabled'+ available.mkdir()+ enabled.mkdir()+ monkeypatch.setattr(NginxService, 'SITES_AVAILABLE', str(available))+ monkeypatch.setattr(NginxService, 'SITES_ENABLED', str(enabled))+ monkeypatch.setattr(+ 'app.services.nginx_service.is_command_available', lambda *a, **k: True,+ )++ from subprocess_stub import FakeProc++ def tee(argv, kwargs):+ path = argv[2] if argv[1] == '-a' else argv[1]+ with open(path, 'a' if argv[1] == '-a' else 'w') as stream:+ stream.write(kwargs.get('input', ''))+ return FakeProc()++ def cat(argv, _kwargs):+ try:+ with open(argv[1]) as stream:+ return FakeProc(stdout=stream.read())+ except OSError:+ return FakeProc(returncode=1, stderr='unreadable')++ def ln(argv, _kwargs):+ target, link = argv[-2], argv[-1]+ with open(link, 'w') as stream:+ stream.write(target)+ return FakeProc()++ def rm(argv, _kwargs):+ for path in argv[1:]:+ if not path.startswith('-') and os.path.exists(path):+ os.remove(path)+ return FakeProc()++ fake_subprocess.when(['tee'], tee)+ fake_subprocess.when(['cat'], cat)+ fake_subprocess.when(['ln'], ln)+ fake_subprocess.when(['rm'], rm)+ fake_subprocess.script(['nginx', '-t'])+ fake_subprocess.script(['systemctl'])+ return available, enabled+++def test_capture_includes_exists_enabled_and_content(nginx_tree):+ available, enabled = nginx_tree+ (available / 'shop').write_text('server { listen 80; }')+ (enabled / 'shop').write_text(str(available / 'shop'))++ assert adapter.capture('shop') == {+ 'exists': True,+ 'enabled': True,+ 'content': 'server { listen 80; }',+ }+++def test_capture_refuses_unreadable_existing_vhost(nginx_tree, monkeypatch):+ available, _ = nginx_tree+ (available / 'shop').write_text('present')+ monkeypatch.setattr(+ NginxService, 'read_vhost', classmethod(lambda cls, name: None),+ )++ with pytest.raises(RuntimeError, match='could not be read'):+ adapter.capture('shop')++[email protected]('name', [+ '../outside', '..\\outside', '/etc/nginx/nginx.conf', 'C:\\Windows\\win.ini',+])+def test_scope_rejects_paths_outside_the_vhost_directory(nginx_tree, name):+ with pytest.raises(ValueError, match='safe filename'):+ adapter.capture(name)+++def test_restore_round_trip_reproduces_content_and_disabled_state(nginx_tree):+ available, enabled = nginx_tree+ saved = {+ 'exists': True,+ 'enabled': False,+ 'content': 'server { listen 80; server_name saved.test; }',+ }+ assert adapter.restore('shop', saved)['success'] is True+ assert adapter.capture('shop') == saved++ changed = {+ 'exists': True,+ 'enabled': True,+ 'content': 'server { listen 80; server_name changed.test; }',+ }+ assert adapter.restore('shop', changed)['success'] is True+ assert (enabled / 'shop').exists()++ assert adapter.restore('shop', saved)['success'] is True+ assert (available / 'shop').read_text() == saved['content']+ assert not (enabled / 'shop').exists()+++def test_restore_absent_uses_delete_lifecycle_door(monkeypatch):+ calls = []+ monkeypatch.setattr(+ NginxService, 'delete_site',+ classmethod(lambda cls, name: calls.append(('delete', name)) or {+ 'success': True,+ }),+ )++ result = adapter.restore('shop', {+ 'exists': False, 'enabled': False, 'content': None,+ })++ assert result['success'] is True+ assert calls == [('delete', 'shop')]+++def test_lifecycle_hooks_capture_once_per_public_action(+ app, nginx_tree, monkeypatch):+ from app.services import restore_point_service++ available, _ = nginx_tree+ existing = restore_point_service.get_adapter('nginx_vhost')+ restore_point_service.register_adapter('nginx_vhost', adapter)+ captured = []+ monkeypatch.setattr(+ restore_point_service, 'capture',+ lambda *args, **kwargs: captured.append((args, kwargs)),+ )++ try:+ assert NginxService.write_vhost('shop', 'server {}')['success']+ assert NginxService.disable_site('shop')['success']+ assert NginxService.enable_site('shop')['success']+ assert NginxService.delete_site('shop')['success']+ finally:+ if existing is None:+ restore_point_service.ADAPTERS.pop('nginx_vhost', None)+ else:+ restore_point_service.register_adapter('nginx_vhost', existing)++ assert not (available / 'shop').exists()+ assert [item[1]['label'] for item in captured] == [+ 'before nginx_vhost.write_vhost',+ 'before nginx_vhost.disable_site',+ 'before nginx_vhost.enable_site',+ 'before nginx_vhost.delete_site',+ ]+++def test_site_domain_writer_does_not_enable_twice(monkeypatch):+ from app.services.site_domain_service import SiteDomainService++ app = SimpleNamespace(name='shop')+ monkeypatch.setattr(+ SiteDomainService, 'app_vhost_kwargs',+ classmethod(lambda cls, target, force_type=None: ({+ 'name': target.name,+ 'app_type': 'docker',+ 'domains': ['shop.test'],+ 'port': 8080,+ }, None)),+ )+ monkeypatch.setattr(+ NginxService, 'create_site',+ classmethod(lambda cls, **kwargs: {'success': True}),+ )+ monkeypatch.setattr(+ NginxService, 'enable_site',+ classmethod(lambda cls, name: pytest.fail('redundant enable_site call')),+ )++ assert SiteDomainService.write_app_vhost(app) == {+ 'nginx': {'success': True},+ 'warning': None,+ }diff --git a/backend/tests/test_serializable_mixin.py b/backend/tests/test_serializable_mixin.pyindex 09118073..658e2262 100644--- a/backend/tests/test_serializable_mixin.py+++ b/backend/tests/test_serializable_mixin.py@@ -23,10 +23,10 @@ EXPECTED = {'CloudflareTunnel': {'account_id', 'created_at', 'dns_provider_config_id', 'id', 'name', 'tunnel_id'},'CronRun': {'created_at', 'duration_seconds', 'exit_code', 'finished_at', 'id', 'job_id', 'output_tail', 'started_at', 'status'},'DNSRecord': {'content', 'created_at', 'id', 'name', 'priority', 'provider_record_id', 'proxied', 'record_type', 'ttl', 'zone_id'},- 'DnsChange': {'action', 'content', 'created_at', 'dns_provider_config_id', 'error', 'id', 'name', 'provider', 'provider_record_id', 'provider_zone_id', 'record_type', 'result', 'source'},+ 'DnsChange': {'action', 'before_json', 'content', 'created_at', 'dns_provider_config_id', 'error', 'id', 'name', 'provider', 'provider_record_id', 'provider_zone_id', 'record_type', 'result', 'source'},'HealthCheck': {'checked_at', 'component_id', 'error', 'id', 'response_time', 'status', 'status_code'},'ImageUpdateCheck': {'application_id', 'checked_at', 'current_digest', 'error_message', 'id', 'image_ref', 'latest_digest', 'status', 'update_available'},- 'ManagedDnsRecord': {'app_id', 'content', 'created_at', 'id', 'name', 'provider', 'provider_record_id', 'provider_zone_id', 'record_type', 'source', 'updated_at'},+ 'ManagedDnsRecord': {'app_id', 'content', 'created_at', 'id', 'name', 'priority', 'provider', 'provider_record_id', 'provider_zone_id', 'proxied', 'record_type', 'source', 'ttl', 'updated_at'},'ResourceTag': {'created_at', 'id', 'resource_id', 'resource_type', 'tag'},'ServerCommand': {'command_data', 'command_type', 'completed_at', 'created_at', 'error', 'exit_code', 'id', 'max_retries', 'queued', 'result', 'retry_count', 'server_id', 'started_at', 'status', 'user_id'},'ServerMetrics': {'container_count', 'container_running', 'cpu_percent', 'disk_percent', 'disk_used', 'extra', 'id', 'memory_percent', 'memory_used', 'network_rx', 'network_rx_rate', 'network_tx', 'network_tx_rate', 'server_id', 'timestamp'},