Skip to content

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.

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.py
index 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__.py
index 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, AgentPluginInstall
from app.models.server_template import ServerTemplate, ServerTemplateAssignment
from app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey, ResourceGrant
from app.models.dns_zone import DNSZone, DNSRecord
+from app.models.managed_dns_record import ManagedDnsRecord
from app.models.tunnel import Tunnel
from app.models.exposed_service import ExposedService
from 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.py
new file mode 100644
index 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.py
index 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.py
new file mode 100644
index 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 res
diff --git a/backend/app/services/dns_provider_service.py b/backend/app/services/dns_provider_service.py
index 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:
@classmethod
def 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 record
dkim_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 record
spf_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 record
dmarc_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:
@classmethod
def _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 DnsOwnershipService
spec = 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
@classmethod
def _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)
@staticmethod
def _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.py
index 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'),
+ },
+ }
+
@staticmethod
def create_record(zone_id, data):
zone = DNSZone.query.get(zone_id)
@@ -379,20 +412,25 @@ class DNSZoneService:
@staticmethod
def _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 CloudflareClient
from app.services.dns.base import DnsRecordSpec
+ from app.services.dns_ownership_service import DnsOwnershipService
client = CloudflareClient(credential)
zone_id = zone.provider_zone_id
if 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.py
new file mode 100644
index 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.py
index 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.py
index 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.py
new file mode 100644
index 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