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(dns): ownership ledger + never-touch-foreign guard + zone mirror (Phase 1)
Juan Denisb1b5ed116149
diff --git a/backend/app/api/dns_zones.py b/backend/app/api/dns_zones.pyindex f0aa0a83..b0380867 100644--- a/backend/app/api/dns_zones.py+++ b/backend/app/api/dns_zones.py@@ -131,6 +131,16 @@ def check_propagation(domain):return jsonify({'domain': domain, 'record_type': record_type, 'results': results})+@dns_zones_bp.route('/<int:zone_id>/mirror', methods=['GET'])+@jwt_required()+def zone_mirror(zone_id):+ """Live provider records for a zone, each tagged serverkit-owned vs external."""+ zone = DNSZoneService.get_zone(zone_id)+ if not zone:+ return jsonify({'error': 'Zone not found'}), 404+ return jsonify(DNSZoneService.list_provider_records(zone))++@dns_zones_bp.route('/<int:zone_id>/export', methods=['GET'])@jwt_required()def export_zone(zone_id):diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex 0ad55943..62fb85aa 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -29,6 +29,7 @@ from app.models.agent_plugin import AgentPlugin, AgentPluginInstallfrom app.models.server_template import ServerTemplate, ServerTemplateAssignmentfrom app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey, ResourceGrantfrom app.models.dns_zone import DNSZone, DNSRecord+from app.models.managed_dns_record import ManagedDnsRecordfrom app.models.tunnel import Tunnelfrom app.models.exposed_service import ExposedServicefrom app.models.status_page import StatusPage, StatusComponent, HealthCheck, StatusIncident, StatusIncidentUpdate@@ -61,7 +62,7 @@ __all__ = ['AgentPlugin', 'AgentPluginInstall','ServerTemplate', 'ServerTemplateAssignment','Workspace', 'WorkspaceMember', 'WorkspaceApiKey', 'ResourceGrant',- 'DNSZone', 'DNSRecord',+ 'DNSZone', 'DNSRecord', 'ManagedDnsRecord','Tunnel', 'ExposedService','StatusPage', 'StatusComponent', 'HealthCheck', 'StatusIncident', 'StatusIncidentUpdate','CloudProvider', 'CloudServer', 'CloudSnapshot',diff --git a/backend/app/models/managed_dns_record.py b/backend/app/models/managed_dns_record.pynew file mode 100644index 00000000..7457d4e8--- /dev/null+++ b/backend/app/models/managed_dns_record.py@@ -0,0 +1,47 @@+from datetime import datetime+from app import db+++class ManagedDnsRecord(db.Model):+ """Ledger of DNS records ServerKit created in an external provider zone.++ The single source of truth for "we own this record". It's written whenever the+ panel creates/updates a record through a connected provider — the /dns Zones+ page, Dynamic DNS, WordPress custom-domain auto-DNS, and email — and removed on+ delete.++ The never-touch-foreign guard and the live zone mirror read from here to tell+ ServerKit's own records apart from the user's pre-existing ones (their "Maria &+ Pedro" records), which the panel must never mutate.+ """+ __tablename__ = 'managed_dns_records'++ id = db.Column(db.Integer, primary_key=True)+ dns_provider_config_id = db.Column(+ db.Integer, db.ForeignKey('dns_provider_configs.id'), nullable=True)+ provider = db.Column(db.String(64), nullable=False) # cloudflare, ...+ provider_zone_id = db.Column(db.String(128), nullable=False, index=True)+ provider_record_id = db.Column(db.String(128), index=True) # set once known+ record_type = db.Column(db.String(10), nullable=False)+ name = db.Column(db.String(256), nullable=False) # FQDN+ content = db.Column(db.Text)+ source = db.Column(db.String(40)) # zone|ddns|preset|wordpress|email+ app_id = db.Column(db.Integer, db.ForeignKey('applications.id'), nullable=True)++ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ def to_dict(self):+ return {+ 'id': self.id,+ 'provider': self.provider,+ 'provider_zone_id': self.provider_zone_id,+ 'provider_record_id': self.provider_record_id,+ 'record_type': self.record_type,+ 'name': self.name,+ 'content': self.content,+ 'source': self.source,+ 'app_id': self.app_id,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,+ }diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.pyindex 5bfc1a13..a6f55827 100644--- a/backend/app/services/dns/cloudflare.py+++ b/backend/app/services/dns/cloudflare.py@@ -88,6 +88,36 @@ class CloudflareClient:except Exception as e:return {'success': False, 'error': str(e)}+ def list_records(self, zone_id: str) -> dict:+ """List every record in a zone (paginated) — the live state the mirror+ classifies into ServerKit-owned vs the user's own records."""+ try:+ out, page = [], 1+ while True:+ resp = requests.get(+ f'{API_BASE}/zones/{zone_id}/dns_records?per_page=100&page={page}',+ headers=self._headers(), timeout=15)+ data = resp.json()+ if not data.get('success'):+ return {'success': False, 'error': _first_error(data)}+ for r in data.get('result', []):+ out.append({+ 'id': r.get('id'),+ 'type': r.get('type'),+ 'name': r.get('name'),+ 'content': r.get('content', ''),+ 'ttl': r.get('ttl'),+ 'proxied': bool(r.get('proxied', False)),+ 'priority': r.get('priority'),+ })+ info = data.get('result_info') or {}+ if page >= (info.get('total_pages') or 1):+ break+ page += 1+ return {'success': True, 'records': out}+ except Exception as e:+ return {'success': False, 'error': str(e)}+# ── records ─────────────────────────────────────────────────────────────def _payload(self, spec: DnsRecordSpec) -> dict:"""Render a record spec into a Cloudflare ``dns_records`` payload."""diff --git a/backend/app/services/dns_ownership_service.py b/backend/app/services/dns_ownership_service.pynew file mode 100644index 00000000..dbbb2ff6--- /dev/null+++ b/backend/app/services/dns_ownership_service.py@@ -0,0 +1,149 @@+"""Ownership ledger + the never-touch-foreign guard for provider DNS writes.++Every record ServerKit creates through a connected provider is recorded in+``managed_dns_records``. Before the panel overwrites or deletes a provider record+it checks this ledger, so it never mutates a record the *user* created themselves+(their pre-existing "Maria & Pedro" records).++Two guard postures:++* **Automatic paths** (WordPress auto-DNS, wildcard setup, email) call with+ ``allow_foreign=False`` — they refuse to touch a record we didn't create.+* **Explicit management** (the /dns Zones page, where the user is deliberately+ editing their own zone) calls with ``allow_foreign=True`` — it adopts the+ existing record and records ownership from then on.+"""+import logging++from app import db+from app.models.managed_dns_record import ManagedDnsRecord++logger = logging.getLogger(__name__)+++class DnsOwnershipService:++ # ── 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()++ @staticmethod+ def owns(provider_zone_id, *, provider_record_id=None, record_type=None, name=None):+ """Whether ServerKit created the matching record (by provider record id, or+ by type+name)."""+ q = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_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)+ else:+ return False+ return q.first() is not None++ @staticmethod+ def owned_keys(provider_zone_id):+ """``(record_id set, (type, lower-name) set)`` for fast mirror classification."""+ rows = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_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}+ return ids, keys++ @staticmethod+ def list_for_zone(provider_zone_id):+ return ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id).all()++ @staticmethod+ def list_all():+ return ManagedDnsRecord.query.order_by(+ ManagedDnsRecord.provider_zone_id, ManagedDnsRecord.name).all()++ # ── ledger writes ────────────────────────────────────────────────────────+ @staticmethod+ def 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)+ if row is None:+ row = ManagedDnsRecord(provider=provider, provider_zone_id=provider_zone_id,+ record_type=record_type, name=name)+ db.session.add(row)+ if provider_record_id:+ row.provider_record_id = provider_record_id+ row.content = content+ if source:+ row.source = source+ if app_id is not None:+ row.app_id = app_id+ if config_id is not None:+ row.dns_provider_config_id = config_id+ db.session.commit()+ 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)+ 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)+ else:+ return 0+ n = q.delete()+ db.session.commit()+ return n++ # ── guarded provider writes ──────────────────────────────────────────────+ @staticmethod+ def guarded_upsert(client, *, provider, provider_zone_id, spec, source,+ app_id=None, config_id=None, known_record_id=None,+ allow_foreign=False):+ """Upsert via the provider client, refusing to overwrite a record ServerKit+ doesn't own (unless ``allow_foreign``), then record ownership on success.++ Returns the client result (``{success, record_id?, error?}``) with+ ``conflict=True`` when a foreign record blocked an automatic write.+ """+ from app.services.dns.cloudflare import parse_caa_value++ record_id = known_record_id+ if 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)+ if existing:+ if DnsOwnershipService.owns(provider_zone_id, provider_record_id=existing):+ record_id = existing # ours — update in place+ elif allow_foreign:+ record_id = existing # explicit management — adopt it+ else:+ logger.warning('Refusing to overwrite foreign DNS record %s %s in zone %s',+ spec.record_type, spec.name, provider_zone_id)+ return {'success': False, 'conflict': True,+ 'error': (f'{spec.record_type} record {spec.name} already exists in '+ f'this zone and was not created by ServerKit — left untouched.')}++ 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)+ return res++ @staticmethod+ def guarded_delete(client, *, provider_zone_id, record_type, name, provider_record_id=None):+ """Delete only a record ServerKit owns; never a foreign one. Clears our+ ledger entry on success."""+ if provider_record_id:+ owned = DnsOwnershipService.owns(provider_zone_id, provider_record_id=provider_record_id)+ else:+ owned = DnsOwnershipService.owns(provider_zone_id, record_type=record_type, name=name)+ if not owned:+ return {'success': True, 'skipped': True,+ 'message': 'No ServerKit-owned record to delete.'}+ 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)+ return resdiff --git a/backend/app/services/dns_provider_service.py b/backend/app/services/dns_provider_service.pyindex 09628c0c..e2a253fd 100644--- a/backend/app/services/dns_provider_service.py+++ b/backend/app/services/dns_provider_service.py@@ -143,16 +143,18 @@ class DNSProviderService:@classmethoddef set_record(cls, provider_id: int, zone_id: str, record_type: str,name: str, value: str, ttl: int = 3600,- proxied: bool = False, priority: int = None) -> Dict:+ 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."""+ the Cloudflare path; other providers ignore them. ``source`` tags the write+ in the ownership ledger."""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)+ 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':@@ -188,21 +190,21 @@ class DNSProviderService:# Deploy DKIM recorddkim_name = f'{selector}._domainkey.{domain}'dkim_value = f'v=DKIM1; k=rsa; p={dkim_public_key}'- results['dkim'] = cls.set_record(provider_id, zone_id, 'TXT', dkim_name, dkim_value)+ results['dkim'] = cls.set_record(provider_id, zone_id, 'TXT', dkim_name, dkim_value, source='email')# Deploy SPF recordspf_value = 'v=spf1 mx a ~all'if server_ip:spf_value = f'v=spf1 mx a ip4:{server_ip} ~all'- results['spf'] = cls.set_record(provider_id, zone_id, 'TXT', domain, spf_value)+ results['spf'] = cls.set_record(provider_id, zone_id, 'TXT', domain, spf_value, source='email')# Deploy DMARC recorddmarc_name = f'_dmarc.{domain}'dmarc_value = f'v=DMARC1; p=quarantine; rua=mailto:dmarc@{domain}; pct=100'- results['dmarc'] = cls.set_record(provider_id, zone_id, 'TXT', dmarc_name, dmarc_value)+ results['dmarc'] = cls.set_record(provider_id, zone_id, 'TXT', dmarc_name, dmarc_value, source='email')# Deploy MX record- results['mx'] = cls.set_record(provider_id, zone_id, 'MX', domain, f'10 mail.{domain}')+ results['mx'] = cls.set_record(provider_id, zone_id, 'MX', domain, f'10 mail.{domain}', source='email')all_ok = all(r.get('success') for r in results.values())return {@@ -250,10 +252,13 @@ class DNSProviderService:if not config:return {'created': False, 'reason': 'no_provider', 'record': record,'message': f'No connected DNS provider manages {domain} — add this record manually.'}- res = cls.set_record(config.id, zone['id'], 'A', domain, ip)+ res = cls.set_record(config.id, zone['id'], 'A', domain, ip, source='auto-dns')if res.get('success'):return {'created': True, 'provider': config.name, 'zone': zone.get('name'), 'record': record}- return {'created': False, 'reason': 'api_error', 'error': res.get('error'),+ # A foreign record we won't clobber surfaces as its own reason so the caller+ # can tell the user "you already have a record here" rather than a vague error.+ reason = 'foreign_record' if res.get('conflict') else 'api_error'+ return {'created': False, 'reason': reason, 'error': res.get('error'),'provider': config.name, 'record': record}@staticmethod@@ -293,7 +298,7 @@ class DNSProviderService:apex = (zone.get('name') or domain).strip().lower().rstrip('.')record = {'type': 'CAA', 'name': apex, 'value': value}- res = cls.set_record(config.id, zone['id'], 'CAA', apex, value)+ res = cls.set_record(config.id, zone['id'], 'CAA', apex, value, source='caa')if res.get('success'):return {'created': True, 'provider': config.name, 'zone': apex, 'record': record}return {'created': False, 'reason': 'api_error', 'error': res.get('error'),@@ -325,24 +330,36 @@ class DNSProviderService:@classmethoddef _cloudflare_set_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str, value: str, ttl: int,- proxied: bool = False, priority: int = None) -> Dict:- """Create or update a Cloudflare DNS record (idempotent upsert by name)."""+ 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 DnsOwnershipServicespec = DnsRecordSpec(record_type=record_type, name=name, content=value,ttl=ttl, priority=priority, proxied=proxied)- res = cls._cloudflare_client(config).upsert(zone_id, spec)+ 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}')}- return {'success': False, 'error': res.get('error', 'Unknown error')}+ out = {'success': False, 'error': res.get('error', 'Unknown error')}+ if res.get('conflict'):+ out['conflict'] = True+ return out@classmethoddef _cloudflare_delete_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str) -> Dict:- """Delete a Cloudflare DNS record (by type+name)."""- return cls._cloudflare_client(config).delete(- zone_id, record_type=record_type, name=name)+ """Delete a Cloudflare DNS record ServerKit owns (by type+name); a foreign+ record 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)@staticmethoddef _host_relative_to_zone(name: str, zone: str) -> str:diff --git a/backend/app/services/dns_zone_service.py b/backend/app/services/dns_zone_service.pyindex 2ceb2671..32fc163f 100644--- a/backend/app/services/dns_zone_service.py+++ b/backend/app/services/dns_zone_service.py@@ -148,6 +148,39 @@ class DNSZoneService:DNSRecord.record_type, DNSRecord.name).all()+ @staticmethod+ def list_provider_records(zone):+ """The live provider record list for a zone, each tagged ``serverkit`` or+ ``external`` — so the UI can show everything in the user's zone while making+ clear which records ServerKit owns (and may touch) vs the user's own."""+ if zone.provider != 'cloudflare':+ return {'success': False, 'error': 'Mirror is only available for Cloudflare zones'}+ credential = DNSZoneService._resolve_credential(zone)+ if not credential:+ return {'success': False, 'error': 'No connected credential resolves for this zone'}++ from app.services.dns import CloudflareClient+ from app.services.dns_ownership_service import DnsOwnershipService++ res = CloudflareClient(credential).list_records(zone.provider_zone_id)+ if not res.get('success'):+ return res++ owned_ids, owned_keys = DnsOwnershipService.owned_keys(zone.provider_zone_id)+ records = []+ for r in res['records']:+ owned = (r['id'] in owned_ids) or \+ ((r['type'], (r['name'] or '').lower().rstrip('.')) in owned_keys)+ records.append({**r, 'managed_by': 'serverkit' if owned else 'external'})+ return {+ 'success': True,+ 'records': records,+ 'counts': {+ 'serverkit': sum(1 for x in records if x['managed_by'] == 'serverkit'),+ 'external': sum(1 for x in records if x['managed_by'] == 'external'),+ },+ }+@staticmethoddef create_record(zone_id, data):zone = DNSZone.query.get(zone_id)@@ -379,20 +412,25 @@ class DNSZoneService:@staticmethoddef _cloudflare_sync(zone, record, action, credential):- """Push a single record change to Cloudflare via the shared client.+ """Push a single record change to Cloudflare via the shared client, gated by+ the ownership ledger.- ``upsert`` is idempotent: it updates by ``provider_record_id`` when known,- otherwise finds the record by name (so a re-create doesn't duplicate and an- update doesn't silently no-op when the id was never captured)."""+ ``upsert`` is idempotent (updates by ``provider_record_id`` when known, else+ by name). The Zones page is explicit zone management, so it adopts a matching+ record and records ServerKit ownership (``allow_foreign=True``)."""from app.services.dns import CloudflareClientfrom app.services.dns.base import DnsRecordSpec+ from app.services.dns_ownership_service import DnsOwnershipServiceclient = CloudflareClient(credential)zone_id = zone.provider_zone_idif action in ('create', 'update'):- res = client.upsert(zone_id, DnsRecordSpec.from_record(record),- record_id=record.provider_record_id)+ res = DnsOwnershipService.guarded_upsert(+ client, provider='cloudflare', provider_zone_id=zone_id,+ spec=DnsRecordSpec.from_record(record), source='zone',+ config_id=zone.dns_provider_config_id,+ known_record_id=record.provider_record_id, allow_foreign=True)if res.get('success'):rid = res.get('record_id')if rid and rid != record.provider_record_id:@@ -402,4 +440,6 @@ class DNSZoneService:logger.error('Cloudflare sync %s failed for %s: %s',action, record.name, res.get('error'))elif action == 'delete' and record.provider_record_id:- client.delete(zone_id, record_id=record.provider_record_id)+ DnsOwnershipService.guarded_delete(+ client, provider_zone_id=zone_id, record_type=record.record_type,+ name=record.name, provider_record_id=record.provider_record_id)diff --git a/backend/migrations/versions/026_managed_dns_records.py b/backend/migrations/versions/026_managed_dns_records.pynew file mode 100644index 00000000..e8722687--- /dev/null+++ b/backend/migrations/versions/026_managed_dns_records.py@@ -0,0 +1,58 @@+"""DNS record ownership ledger.++Adds:+- managed_dns_records++The single source of truth for "this provider DNS record was created by ServerKit",+so the never-touch-foreign guard and the zone mirror can tell our records apart from+the user's own. Written by every connected-provider write path; removed on delete.++Idempotent: MigrationService runs _fix_missing_columns() + db.create_all() on boot+before Alembic, so guard on the live schema.++Revision ID: 026_managed_dns_records+Revises: 025_dns_provider_link+Create Date: 2026-06-22+"""+from alembic import op+import sqlalchemy as sa++revision = '026_managed_dns_records'+down_revision = '025_dns_provider_link'+branch_labels = None+depends_on = None+++def upgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ if 'managed_dns_records' in set(inspector.get_table_names()):+ return+ op.create_table(+ 'managed_dns_records',+ sa.Column('id', sa.Integer, nullable=False),+ sa.Column('dns_provider_config_id', sa.Integer, nullable=True),+ sa.Column('provider', sa.String(64), nullable=False),+ sa.Column('provider_zone_id', sa.String(128), nullable=False),+ sa.Column('provider_record_id', sa.String(128), nullable=True),+ sa.Column('record_type', sa.String(10), nullable=False),+ sa.Column('name', sa.String(256), nullable=False),+ sa.Column('content', sa.Text, nullable=True),+ sa.Column('source', sa.String(40), nullable=True),+ sa.Column('app_id', sa.Integer, nullable=True),+ sa.Column('created_at', sa.DateTime, nullable=True),+ sa.Column('updated_at', sa.DateTime, nullable=True),+ sa.PrimaryKeyConstraint('id'),+ )+ op.create_index('ix_managed_dns_records_provider_zone_id',+ 'managed_dns_records', ['provider_zone_id'])+ op.create_index('ix_managed_dns_records_provider_record_id',+ 'managed_dns_records', ['provider_record_id'])+++def downgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ if 'managed_dns_records' not in set(inspector.get_table_names()):+ return+ op.drop_table('managed_dns_records')diff --git a/backend/tests/test_attach_domain.py b/backend/tests/test_attach_domain.pyindex 1f7ecfa4..4a81f8fb 100644--- a/backend/tests/test_attach_domain.py+++ b/backend/tests/test_attach_domain.py@@ -67,7 +67,7 @@ def test_ensure_a_record_auto_creates(app, monkeypatch):classmethod(lambda cls, pid: {'success': True, 'zones': [{'id': 'z1', 'name': 'example.com'}]}))captured = {}- def fake_set(cls, pid, zid, rtype, name, value, ttl=3600):+ def fake_set(cls, pid, zid, rtype, name, value, ttl=3600, **kwargs):captured.update({'zid': zid, 'rtype': rtype, 'name': name, 'value': value})return {'success': True}diff --git a/backend/tests/test_dns_caa.py b/backend/tests/test_dns_caa.pyindex 2cc9ad37..e8b7b8d4 100644--- a/backend/tests/test_dns_caa.py+++ b/backend/tests/test_dns_caa.py@@ -56,7 +56,7 @@ def test_ensure_caa_record_writes_at_zone_apex(app, monkeypatch):lambda cls, d: (type('C', (), {'id': 1, 'name': 'cf'})(),{'id': 'zoneABC', 'name': 'Example.COM'})))monkeypatch.setattr(S, 'set_record', classmethod(- lambda cls, pid, zid, rtype, name, value, ttl=3600:+ lambda cls, pid, zid, rtype, name, value, ttl=3600, **kw:(calls.update(zid=zid, rtype=rtype, name=name, value=value) or {'success': True})))r = S.ensure_caa_record('panel.example.com')diff --git a/backend/tests/test_dns_ownership.py b/backend/tests/test_dns_ownership.pynew file mode 100644index 00000000..2945e98b--- /dev/null+++ b/backend/tests/test_dns_ownership.py@@ -0,0 +1,195 @@+"""Proving tests for DNS ownership + the never-touch-foreign guard (Phase 1).++ServerKit records every provider DNS record it creates in managed_dns_records, and+gates writes so it never overwrites or deletes a record the *user* created (their+own "Maria & Pedro" records). Automatic paths refuse foreign records; the explicit+Zones page adopts them. The mirror classifies a zone's live records accordingly.+"""+++class _Resp:+ def __init__(self, js):+ self._js = js++ def json(self):+ return self._js+++class FakeClient:+ """Duck-typed CloudflareClient for guard tests (no HTTP)."""+ def __init__(self, existing_id=None, upsert_result=None):+ self.existing_id = existing_id+ self.upsert_result = upsert_result or {'success': True, 'record_id': 'NEW'}+ self.calls = []++ def find_record_id(self, zone_id, record_type, name, caa=None):+ self.calls.append(('find', record_type, name))+ return self.existing_id++ def upsert(self, zone_id, spec, record_id=None):+ self.calls.append(('upsert', spec.record_type, spec.name, record_id))+ return self.upsert_result++ def delete(self, zone_id, record_id=None, record_type=None, name=None):+ self.calls.append(('delete', record_id, record_type, name))+ return {'success': True}+++def _verbs(client):+ return [c[0] for c in client.calls]+++# ── ledger reads/writes ──────────────────────────────────────────────────────++def test_record_write_and_owns(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ O.record_write('cloudflare', 'z1', 'A', 'www.example.com',+ provider_record_id='R1', content='1.2.3.4', source='zone')+ assert O.owns('z1', provider_record_id='R1')+ assert O.owns('z1', record_type='A', name='www.example.com')+ assert not O.owns('z1', record_type='A', name='maria.example.com')+ assert not O.owns('other-zone', provider_record_id='R1')+++def test_record_write_is_upsert(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ from app.models.managed_dns_record import ManagedDnsRecord+ 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',+ content='9.9.9.9', source='zone')+ rows = ManagedDnsRecord.query.filter_by(provider_zone_id='z1', name='www.example.com').all()+ assert len(rows) == 1 and rows[0].content == '9.9.9.9'+++def test_record_delete(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ O.record_write('cloudflare', 'z1', 'A', 'www.example.com', provider_record_id='R1', source='zone')+ assert O.record_delete('z1', provider_record_id='R1') == 1+ assert not O.owns('z1', provider_record_id='R1')+++# ── guarded_upsert ───────────────────────────────────────────────────────────++def test_guarded_upsert_creates_and_records_ownership(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ from app.services.dns.base import DnsRecordSpec+ client = FakeClient(existing_id=None, upsert_result={'success': True, 'record_id': 'CF1'})+ res = O.guarded_upsert(client, provider='cloudflare', provider_zone_id='z1',+ spec=DnsRecordSpec('A', 'www.example.com', '1.2.3.4'),+ source='zone', allow_foreign=False)+ assert res['success'] and res['record_id'] == 'CF1'+ assert O.owns('z1', provider_record_id='CF1')+ assert O.owns('z1', record_type='A', name='www.example.com')+++def test_guarded_upsert_refuses_foreign(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ from app.services.dns.base import DnsRecordSpec+ client = FakeClient(existing_id='FOREIGN') # exists in CF, not in our ledger+ res = O.guarded_upsert(client, provider='cloudflare', provider_zone_id='z1',+ spec=DnsRecordSpec('A', 'maria.example.com', '9.9.9.9'),+ source='auto-dns', allow_foreign=False)+ assert res['success'] is False and res.get('conflict') is True+ assert 'upsert' not in _verbs(client) # never wrote+ assert not O.owns('z1', record_type='A', name='maria.example.com')+++def test_guarded_upsert_adopts_foreign_when_allowed(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ from app.services.dns.base import DnsRecordSpec+ client = FakeClient(existing_id='ADOPT', upsert_result={'success': True, 'record_id': 'ADOPT'})+ res = O.guarded_upsert(client, provider='cloudflare', provider_zone_id='z1',+ spec=DnsRecordSpec('A', 'www.example.com', '1.1.1.1'),+ source='zone', allow_foreign=True)+ assert res['success']+ upsert_call = next(c for c in client.calls if c[0] == 'upsert')+ assert upsert_call[3] == 'ADOPT' # updated the existing record in place+ assert O.owns('z1', provider_record_id='ADOPT')+++def test_guarded_upsert_updates_owned_without_conflict(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ from app.services.dns.base import DnsRecordSpec+ O.record_write('cloudflare', 'z1', 'A', 'www.example.com', provider_record_id='OURS', source='zone')+ client = FakeClient(existing_id='OURS', upsert_result={'success': True, 'record_id': 'OURS'})+ res = O.guarded_upsert(client, provider='cloudflare', provider_zone_id='z1',+ spec=DnsRecordSpec('A', 'www.example.com', '2.2.2.2'),+ source='auto-dns', allow_foreign=False)+ assert res['success'] # owned -> updates even on the strict path+++# ── guarded_delete ───────────────────────────────────────────────────────────++def test_guarded_delete_owned_then_foreign(app):+ from app.services.dns_ownership_service import DnsOwnershipService as O+ O.record_write('cloudflare', 'z1', 'A', 'www.example.com', provider_record_id='R1', source='zone')++ owned = FakeClient()+ res = O.guarded_delete(owned, provider_zone_id='z1', record_type='A',+ name='www.example.com', provider_record_id='R1')+ assert res['success'] and 'delete' in _verbs(owned)+ assert not O.owns('z1', provider_record_id='R1') # ledger cleared++ foreign = FakeClient()+ res2 = O.guarded_delete(foreign, provider_zone_id='z1', record_type='A',+ name='maria.example.com', provider_record_id='RX')+ assert res2.get('skipped') and 'delete' not in _verbs(foreign)+++# ── mirror classification ────────────────────────────────────────────────────++def test_mirror_classifies_owned_vs_external(app, monkeypatch):+ from app import db+ from app.models.dns_zone import DNSZone+ from app.models.email import DNSProviderConfig+ from app.services.dns_provider_service import DNSProviderService+ from app.services.dns_zone_service import DNSZoneService+ from app.services.dns_ownership_service import DnsOwnershipService as O+ from app.services.dns import cloudflare as cf++ DNSProviderService.add_provider(name='cf', provider='cloudflare', api_key='tok')+ conn = DNSProviderConfig.query.filter_by(name='cf').first()+ zone = DNSZone(domain='example.com', provider='cloudflare',+ provider_zone_id='Z', dns_provider_config_id=conn.id)+ db.session.add(zone)+ db.session.commit()++ O.record_write('cloudflare', 'Z', 'A', 'www.example.com', provider_record_id='MINE', source='zone')++ monkeypatch.setattr(cf.CloudflareClient, 'list_records', lambda self, zid: {'success': True, 'records': [+ {'id': 'MINE', 'type': 'A', 'name': 'www.example.com', 'content': '1.2.3.4',+ 'ttl': 1, 'proxied': False, 'priority': None},+ {'id': 'THEIRS', 'type': 'A', 'name': 'maria.example.com', 'content': '5.6.7.8',+ 'ttl': 1, 'proxied': False, 'priority': None},+ ]})++ out = DNSZoneService.list_provider_records(zone)+ assert out['success']+ by_name = {r['name']: r['managed_by'] for r in out['records']}+ assert by_name['www.example.com'] == 'serverkit'+ assert by_name['maria.example.com'] == 'external'+ assert out['counts'] == {'serverkit': 1, 'external': 1}+++# ── end-to-end: the auto path refuses to clobber a foreign record ────────────++def test_provider_set_record_refuses_foreign(app, monkeypatch):+ from app.models.email import DNSProviderConfig+ from app.services.dns_provider_service import DNSProviderService+ from app.services.dns import cloudflare as cf++ DNSProviderService.add_provider(name='cf', provider='cloudflare', api_key='tok')+ cfg = DNSProviderConfig.query.filter_by(name='cf').first()++ # Cloudflare already has a record at this name that ServerKit didn't create.+ monkeypatch.setattr(cf.requests, 'get',+ lambda url, headers=None, timeout=None: _Resp({'result': [{'id': 'FOREIGN'}]}))+ writes = {'n': 0}+ monkeypatch.setattr(cf.requests, 'post',+ lambda *a, **k: (writes.update(n=writes['n'] + 1) or _Resp({'success': True})))+ monkeypatch.setattr(cf.requests, 'put',+ lambda *a, **k: (writes.update(n=writes['n'] + 1) or _Resp({'success': True})))++ res = DNSProviderService.set_record(cfg.id, 'Z', 'A', 'maria.example.com', '1.2.3.4')+ assert res['success'] is False and res.get('conflict') is True+ assert writes['n'] == 0 # never touched Cloudflare