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): unify Cloudflare credentials behind one connection + shared client
Juan Denis1127243d1d06
diff --git a/.gitignore b/.gitignoreindex 5fb1d6fb..ff9f7468 100644--- a/.gitignore+++ b/.gitignore@@ -142,3 +142,4 @@ docs/UI_CONSISTENCY_AUDIT.mddocs/REMOTE_ACCESS_ROADMAP.mddocs/NOTIFICATIONS_ROADMAP.mddocs/ORCHESTRATION_ROADMAP.md+docs/DNS_ROADMAP.mddiff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex abf6d105..1ec09286 100644--- a/backend/app/__init__.py+++ b/backend/app/__init__.py@@ -391,12 +391,17 @@ def create_app(config_name=None):n_store = StorageProviderService.encrypt_legacy_secrets()n_cloud = CloudProvisioningService.encrypt_legacy_secrets()n_settings = SettingsService.migrate_legacy_secrets()- if n_dns or n_store or n_cloud or n_settings:+ # Migrate DNS zones with an inline Cloudflare token onto the canonical+ # connection store (idempotent), so every zone resolves creds the same way.+ from app.services.dns_zone_service import DNSZoneService+ n_zones = DNSZoneService.link_legacy_zones()+ if n_dns or n_store or n_cloud or n_settings or n_zones:import logging as _logging_logging.getLogger(__name__).info(f'Encrypted legacy secrets at rest: {n_dns} DNS provider(s), 'f'{n_store} storage field(s), {n_cloud} cloud provider(s), '- f'{n_settings} system setting(s)')+ f'{n_settings} system setting(s); linked {n_zones} DNS zone(s) '+ f'to a connection')except Exception as e:import logging as _logging_logging.getLogger(__name__).warning(f'Legacy secret encryption skipped: {e}')diff --git a/backend/app/models/dns_zone.py b/backend/app/models/dns_zone.pyindex 63743190..f2e29aee 100644--- a/backend/app/models/dns_zone.py+++ b/backend/app/models/dns_zone.py@@ -11,7 +11,13 @@ class DNSZone(db.Model):domain = db.Column(db.String(256), nullable=False, unique=True)provider = db.Column(db.String(64)) # cloudflare, route53, digitalocean, manualprovider_zone_id = db.Column(db.String(128))- provider_config_json = db.Column(db.Text) # encrypted credentials+ provider_config_json = db.Column(db.Text) # legacy inline credentials (pre-unification)++ # Canonical credential link: the DNSProviderConfig (Settings -> Connections)+ # whose API token manages this zone. Supersedes the inline token in+ # provider_config_json; nullable so manual zones and not-yet-migrated rows work.+ dns_provider_config_id = db.Column(+ db.Integer, db.ForeignKey('dns_provider_configs.id'), nullable=True)status = db.Column(db.String(32), default='active')last_sync_at = db.Column(db.DateTime)@@ -35,6 +41,7 @@ class DNSZone(db.Model):'domain': self.domain,'provider': self.provider,'provider_zone_id': self.provider_zone_id,+ 'dns_provider_config_id': self.dns_provider_config_id,'status': self.status,'record_count': self.records.count(),'last_sync_at': self.last_sync_at.isoformat() if self.last_sync_at else None,diff --git a/backend/app/services/dns/__init__.py b/backend/app/services/dns/__init__.pynew file mode 100644index 00000000..0fdd69b8--- /dev/null+++ b/backend/app/services/dns/__init__.py@@ -0,0 +1,23 @@+"""Shared, provider-agnostic DNS client layer.++Both ``DNSProviderService`` (provider/credentials layer) and ``DNSZoneService``+(zone/records layer) build a :class:`DnsCredential` + :class:`DnsRecordSpec` and+talk to a provider through :func:`get_client`, so the API wire format for a given+provider lives in exactly one module.+"""+from app.services.dns.base import DnsCredential, DnsRecordSpec+from app.services.dns.cloudflare import CloudflareClient++__all__ = ['DnsCredential', 'DnsRecordSpec', 'CloudflareClient', 'get_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.+ """+ if credential.provider == 'cloudflare':+ return CloudflareClient(credential)+ raise ValueError(f'No shared DNS client for provider: {credential.provider}')diff --git a/backend/app/services/dns/base.py b/backend/app/services/dns/base.pynew file mode 100644index 00000000..b9e338b0--- /dev/null+++ b/backend/app/services/dns/base.py@@ -0,0 +1,68 @@+"""Provider-agnostic DNS primitives shared by both Cloudflare code paths.++A single :class:`~app.services.dns.cloudflare.CloudflareClient` is driven from+*both* layers that talk to Cloudflare:++* ``DNSProviderService`` — credentials in the ``DNSProviderConfig`` table+ (email DKIM/SPF/DMARC + WordPress custom-domain auto-DNS), and+* ``DNSZoneService`` — the ``/dns`` Zones page and Dynamic DNS.++Before this, each maintained its *own* Cloudflare request/payload code, so+wire-format fixes (e.g. CAA's structured ``data`` object) had to be made twice+and drifted apart. These dataclasses are the normalized inputs both callers+build, so the API specifics live in exactly one place.+"""+from dataclasses import dataclass+from typing import Optional+++@dataclass+class DnsCredential:+ """Normalized DNS-provider credential, decoupled from where it's stored."""++ provider: str+ token: Optional[str] = None # bearer token / primary API key+ email: Optional[str] = None # set => Cloudflare global-key auth mode+ secret: Optional[str] = None # second secret (Route53 / GoDaddy)++ @classmethod+ def from_provider_config(cls, config) -> 'DnsCredential':+ """Build from a ``DNSProviderConfig`` row, decrypting secrets at point of+ use (never read ``config.api_key`` directly — it's encrypted at rest)."""+ from app.services.dns_provider_service import DNSProviderService+ creds = DNSProviderService.decrypted_credentials(config)+ return cls(+ provider=config.provider,+ token=creds.get('api_key'),+ email=creds.get('api_email'),+ secret=creds.get('api_secret'),+ )++ @classmethod+ def cloudflare_token(cls, token: str) -> 'DnsCredential':+ """Build a scoped-token Cloudflare credential (legacy zone-config path)."""+ return cls(provider='cloudflare', token=token)+++@dataclass+class DnsRecordSpec:+ """A DNS record to create/update, independent of the provider wire format."""++ record_type: str+ name: str # FQDN (e.g. "www.example.com" or the apex)+ content: str+ ttl: int = 3600+ priority: Optional[int] = None # MX / SRV+ proxied: bool = False # Cloudflare orange-cloud++ @classmethod+ def from_record(cls, record) -> 'DnsRecordSpec':+ """Build from a ``DNSRecord`` ORM row."""+ return cls(+ record_type=record.record_type,+ name=record.name,+ content=record.content,+ ttl=record.ttl or 3600,+ priority=record.priority,+ proxied=bool(record.proxied),+ )diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.pynew file mode 100644index 00000000..5bfc1a13--- /dev/null+++ b/backend/app/services/dns/cloudflare.py@@ -0,0 +1,184 @@+"""The single Cloudflare DNS API client used by every Cloudflare path in ServerKit.++Centralizes, in one place:++* **auth** — scoped API token (``Authorization: Bearer``) *or* global key+ (``X-Auth-Email`` + ``X-Auth-Key``),+* the **CAA** structured-``data`` wire format (Cloudflare rejects a flat+ ``content`` string for CAA),+* **MX/SRV priority** parsing (a leading integer in the value), and+* **idempotent upsert** — update an existing record (by id when known, else by+ name) instead of blindly POSTing a duplicate.++Both ``DNSProviderService`` (provider layer) and ``DNSZoneService`` (zone layer)+delegate here, so a wire-format fix is made once rather than twice.+"""+import logging++import requests++from app.services.dns.base import DnsCredential, DnsRecordSpec++logger = logging.getLogger(__name__)++API_BASE = 'https://api.cloudflare.com/client/v4'+++def parse_caa_value(value: str) -> dict:+ """Parse a BIND-style CAA value (``0 issue "letsencrypt.org"``) into the+ ``{flags, tag, value}`` object Cloudflare expects. The CA value is unquoted.+ Kept here so the CAA wire format lives in exactly one place."""+ parts = (value or '').strip().split(None, 2)+ flags = int(parts[0]) if parts and parts[0].lstrip('-').isdigit() else 0+ tag = parts[1] if len(parts) > 1 else 'issue'+ ca = parts[2].strip().strip('"') if len(parts) > 2 else ''+ return {'flags': flags, 'tag': tag, 'value': ca}+++def _first_error(data: dict) -> str:+ try:+ return (data.get('errors') or [{}])[0].get('message', 'Unknown error')+ except Exception:+ return 'Unknown error'+++class CloudflareClient:+ """Stateless wrapper around the Cloudflare v4 DNS API for one credential."""++ def __init__(self, credential: DnsCredential):+ self.cred = credential++ # ── auth ────────────────────────────────────────────────────────────────+ def _headers(self) -> dict:+ if self.cred.email:+ return {+ 'X-Auth-Email': self.cred.email,+ 'X-Auth-Key': self.cred.token or '',+ 'Content-Type': 'application/json',+ }+ return {+ 'Authorization': f'Bearer {self.cred.token or ""}',+ 'Content-Type': 'application/json',+ }++ # ── connection / zones ──────────────────────────────────────────────────+ def verify(self) -> dict:+ """Verify the credential (token scope check)."""+ try:+ resp = requests.get(f'{API_BASE}/user/tokens/verify',+ headers=self._headers(), timeout=15)+ data = resp.json()+ if data.get('success'):+ return {'success': True, 'message': 'Cloudflare connection successful'}+ return {'success': False, 'error': _first_error(data)}+ except Exception as e:+ return {'success': False, 'error': str(e)}++ def list_zones(self) -> dict:+ """List the zones this credential can manage."""+ try:+ resp = requests.get(f'{API_BASE}/zones?per_page=50',+ headers=self._headers(), timeout=15)+ data = resp.json()+ if not data.get('success'):+ return {'success': False, 'error': _first_error(data) or 'Failed to list zones'}+ zones = [{'id': z['id'], 'name': z['name'], 'status': z['status']}+ for z in data.get('result', [])]+ return {'success': True, 'zones': zones}+ 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."""+ payload = {'type': spec.record_type, 'name': spec.name, 'ttl': spec.ttl}++ # CAA needs Cloudflare's structured `data` object, not a flat `content`+ # string (and `proxied`/`priority` are meaningless for it).+ if spec.record_type == 'CAA':+ payload['data'] = parse_caa_value(spec.content)+ return payload++ content, priority = spec.content, spec.priority+ # MX/SRV may carry a leading priority in the value ("10 mail.example.com")+ # — split it out so Cloudflare gets a separate `priority` field.+ if spec.record_type in ('MX', 'SRV') and priority is None:+ head, _, rest = (spec.content or '').strip().partition(' ')+ if head.isdigit() and rest.strip():+ priority, content = int(head), rest.strip()++ payload['content'] = content+ payload['proxied'] = bool(spec.proxied)+ if priority is not None:+ payload['priority'] = priority+ return payload++ def find_record_id(self, zone_id: str, record_type: str, name: str,+ caa: dict = None):+ """Return the id of an existing record matching ``type``+``name`` (and, for+ CAA, the same CA), or ``None``. CAA is matched on tag+value so a *different*+ CA's authorization is never clobbered."""+ resp = requests.get(+ 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 []+ if caa is not None:+ existing = [+ r for r in existing+ if (r.get('data') or {}).get('tag') == caa['tag']+ and str((r.get('data') or {}).get('value', '')).strip('"').rstrip('.').lower()+ == caa['value'].rstrip('.').lower()+ ]+ return existing[0]['id'] if existing else None++ def upsert(self, zone_id: str, spec: DnsRecordSpec, record_id: str = None) -> dict:+ """Create or update a record idempotently.++ If ``record_id`` is known, PUT it directly; otherwise look up a matching+ record by name and PUT it, else POST a new one. Returns+ ``{success, record_id?, error?}`` so callers can persist the id.+ """+ try:+ base = f'{API_BASE}/zones/{zone_id}/dns_records'+ payload = self._payload(spec)++ if record_id is None:+ caa = payload.get('data') if spec.record_type == 'CAA' else None+ record_id = self.find_record_id(zone_id, spec.record_type, spec.name, caa=caa)++ if record_id:+ resp = requests.put(f'{base}/{record_id}', headers=self._headers(),+ json=payload, timeout=15)+ else:+ resp = requests.post(base, headers=self._headers(),+ json=payload, timeout=15)++ data = resp.json()+ if data.get('success'):+ rid = (data.get('result') or {}).get('id') or record_id+ return {'success': True, 'record_id': rid,+ 'message': f'{spec.record_type} record set for {spec.name}'}+ return {'success': False, 'error': _first_error(data)}+ except Exception as e:+ return {'success': False, 'error': str(e)}++ def delete(self, zone_id: str, *, record_id: str = None,+ record_type: str = None, name: str = None) -> dict:+ """Delete by ``record_id`` when known, else by ``type``+``name`` (removes+ every match). A missing record is treated as success (already gone)."""+ try:+ base = f'{API_BASE}/zones/{zone_id}/dns_records'+ if record_id:+ ids = [record_id]+ 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 []]+ 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)+ return {'success': True, 'message': 'Record deleted'}+ except Exception as e:+ return {'success': False, 'error': str(e)}diff --git a/backend/app/services/dns_provider_service.py b/backend/app/services/dns_provider_service.pyindex 05973ec7..09628c0c 100644--- a/backend/app/services/dns_provider_service.py+++ b/backend/app/services/dns_provider_service.py@@ -142,14 +142,17 @@ class DNSProviderService:@classmethoddef set_record(cls, provider_id: int, zone_id: str, record_type: str,- name: str, value: str, ttl: int = 3600) -> Dict:- """Create or update a DNS record."""+ name: str, value: str, ttl: int = 3600,+ proxied: bool = False, priority: int = None) -> Dict:+ """Create or update a DNS record. ``proxied``/``priority`` are honored by+ the Cloudflare path; other providers ignore them."""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)+ return cls._cloudflare_set_record(config, zone_id, record_type, name, value, ttl,+ proxied=proxied, priority=priority)elif config.provider == 'route53':return cls._route53_set_record(config, zone_id, record_type, name, value, ttl)elif config.provider == 'digitalocean':@@ -257,12 +260,10 @@ class DNSProviderService:def parse_caa_value(value: str) -> Dict:"""Parse a BIND-style CAA value (``0 issue "letsencrypt.org"``) into the``{flags, tag, value}`` object that Cloudflare/DigitalOcean expect. The- CA value is returned unquoted."""- parts = (value or '').strip().split(None, 2)- flags = int(parts[0]) if parts and parts[0].lstrip('-').isdigit() else 0- tag = parts[1] if len(parts) > 1 else 'issue'- ca = parts[2].strip().strip('"') if len(parts) > 2 else ''- return {'flags': flags, 'tag': tag, 'value': ca}+ CA value is returned unquoted. Delegates to the shared Cloudflare client+ so the CAA wire format is defined in exactly one place."""+ from app.services.dns.cloudflare import parse_caa_value as _parse+ return _parse(value)@classmethoddef ensure_caa_record(cls, domain: str, ca: str = 'letsencrypt.org') -> Dict:@@ -300,130 +301,48 @@ class DNSProviderService:# ── Cloudflare Implementation ──+ # The Cloudflare API calls live in the shared CloudflareClient so the+ # provider layer (here) and the zone layer (DNSZoneService) share one+ # implementation — auth, the CAA `data` wire format, and idempotent upsert+ # are defined once rather than maintained in two places.+@classmethod- def _cloudflare_headers(cls, config: DNSProviderConfig) -> Dict:- """Build Cloudflare API headers."""- if config.api_email:- return {- 'X-Auth-Email': config.api_email,- 'X-Auth-Key': cls._api_key(config),- 'Content-Type': 'application/json',- }- return {- 'Authorization': f'Bearer {cls._api_key(config)}',- 'Content-Type': 'application/json',- }+ def _cloudflare_client(cls, config: DNSProviderConfig):+ from app.services.dns import CloudflareClient+ from app.services.dns.base import DnsCredential+ return CloudflareClient(DnsCredential.from_provider_config(config))@classmethoddef _test_cloudflare(cls, config: DNSProviderConfig) -> Dict:"""Test Cloudflare API connection."""- try:- resp = requests.get(- 'https://api.cloudflare.com/client/v4/user/tokens/verify',- headers=cls._cloudflare_headers(config),- timeout=15,- )- data = resp.json()- if data.get('success'):- return {'success': True, 'message': 'Cloudflare connection successful'}- return {'success': False, 'error': data.get('errors', [{}])[0].get('message', 'Unknown error')}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._cloudflare_client(config).verify()@classmethoddef _cloudflare_list_zones(cls, config: DNSProviderConfig) -> Dict:"""List Cloudflare zones."""- try:- resp = requests.get(- 'https://api.cloudflare.com/client/v4/zones?per_page=50',- headers=cls._cloudflare_headers(config),- timeout=15,- )- data = resp.json()- if not data.get('success'):- return {'success': False, 'error': 'Failed to list zones'}- zones = [{'id': z['id'], 'name': z['name'], 'status': z['status']}- for z in data.get('result', [])]- return {'success': True, 'zones': zones}- except Exception as e:- return {'success': False, 'error': str(e)}+ return cls._cloudflare_client(config).list_zones()@classmethoddef _cloudflare_set_record(cls, config: DNSProviderConfig, zone_id: str,- record_type: str, name: str, value: str, ttl: int) -> Dict:- """Create or update a Cloudflare DNS record."""- try:- headers = cls._cloudflare_headers(config)- base = f'https://api.cloudflare.com/client/v4/zones/{zone_id}/dns_records'-- # CAA records need Cloudflare's structured `data` object, not a flat- # `content` string — sending `content` for a CAA record is rejected.- caa = cls.parse_caa_value(value) if record_type == 'CAA' else None- payload = {'type': record_type, 'name': name, 'ttl': ttl}- if caa is not None:- payload['data'] = caa- else:- payload['content'] = value-- # Check if a matching record exists. For CAA there can legitimately be- # several records at the same name (one per CA), so match on tag+value- # to avoid overwriting a *different* CA's authorization.- resp = requests.get(- f'{base}?type={record_type}&name={name}',- headers=headers, timeout=15,- )- data = resp.json()- existing = data.get('result', [])- if caa is not None:- existing = [- r for r in existing- if (r.get('data') or {}).get('tag') == caa['tag']- and str((r.get('data') or {}).get('value', '')).strip('"').rstrip('.').lower()- == caa['value'].rstrip('.').lower()- ]-- if existing:- # Update existing record- record_id = existing[0]['id']- resp = requests.put(- f'{base}/{record_id}',- headers=headers, json=payload, timeout=15,- )- else:- # Create new record- resp = requests.post(base, headers=headers, json=payload, timeout=15)-- data = resp.json()- if data.get('success'):- return {'success': True, 'message': f'{record_type} record set for {name}'}- return {'success': False, 'error': data.get('errors', [{}])[0].get('message', 'Unknown error')}- except Exception as e:- return {'success': False, 'error': str(e)}+ 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)."""+ from app.services.dns.base import DnsRecordSpec+ 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)+ # 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')}@classmethoddef _cloudflare_delete_record(cls, config: DNSProviderConfig, zone_id: str,record_type: str, name: str) -> Dict:- """Delete a Cloudflare DNS record."""- try:- headers = cls._cloudflare_headers(config)- base = f'https://api.cloudflare.com/client/v4/zones/{zone_id}/dns_records'-- resp = requests.get(- f'{base}?type={record_type}&name={name}',- headers=headers, timeout=15,- )- data = resp.json()- existing = data.get('result', [])-- 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)}+ """Delete a Cloudflare DNS record (by type+name)."""+ return cls._cloudflare_client(config).delete(+ 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 5ebf9640..2ceb2671 100644--- a/backend/app/services/dns_zone_service.py+++ b/backend/app/services/dns_zone_service.py@@ -55,13 +55,82 @@ class DNSZoneService:provider=data.get('provider', 'manual'),provider_zone_id=data.get('provider_zone_id'),)- if data.get('provider_config'):++ # Preferred path: link an existing connection (Settings -> Connections).+ # The zone adopts its provider, and we look up the provider-side zone id+ # for this domain so records sync without a second token.+ config_id = data.get('dns_provider_config_id')+ if config_id:+ from app.models.email import DNSProviderConfig+ from app.services.dns_provider_service import DNSProviderService+ config = DNSProviderConfig.query.get(int(config_id))+ if not config:+ raise ValueError('Selected DNS connection not found')+ zone.provider = config.provider+ zone.dns_provider_config_id = config.id+ if not zone.provider_zone_id:+ zres = DNSProviderService.list_zones(config.id)+ if not zres.get('success'):+ raise ValueError(+ f"Couldn't reach {config.name}: {zres.get('error', 'unknown error')}")+ match = next((z for z in zres.get('zones', [])+ if (z.get('name') or '').lower().rstrip('.') == domain), None)+ if not match:+ raise ValueError(f'{config.name} does not manage {domain}')+ zone.provider_zone_id = match['id']+ elif data.get('provider_config'):+ # Legacy inline-token path, kept for backward compatibility.zone.provider_config = data['provider_config']db.session.add(zone)db.session.commit()return zone+ @classmethod+ def link_legacy_zones(cls):+ """One-time, idempotent: migrate Cloudflare zones that still carry an inline+ token in ``provider_config_json`` onto the canonical ``DNSProviderConfig``+ store, so every zone resolves its credentials the same way.++ For each such zone: reuse an existing connection whose decrypted key matches+ the token, else mint one (encrypted at rest), link it, and strip the now+ redundant plaintext token from the zone. API-free — uses the token already+ on the zone. Returns the number of zones migrated."""+ from app.models.email import DNSProviderConfig+ from app.services.dns_provider_service import DNSProviderService+ from app.utils.crypto import encrypt_secret++ migrated = 0+ zones = DNSZone.query.filter(+ DNSZone.provider == 'cloudflare',+ DNSZone.dns_provider_config_id.is_(None),+ ).all()+ for zone in zones:+ token = (zone.provider_config or {}).get('api_token')+ if not token:+ continue+ match = None+ for cfg in DNSProviderConfig.query.filter_by(provider='cloudflare').all():+ if DNSProviderService._api_key(cfg) == token:+ match = cfg+ break+ if match is None:+ match = DNSProviderConfig(+ name=f'Cloudflare ({zone.domain})',+ provider='cloudflare',+ api_key=encrypt_secret(token),+ )+ db.session.add(match)+ db.session.flush() # assign id+ zone.dns_provider_config_id = match.id+ cfg_json = dict(zone.provider_config or {})+ cfg_json.pop('api_token', None)+ zone.provider_config = cfg_json+ migrated += 1+ if migrated:+ db.session.commit()+ return migrated+@staticmethoddef delete_zone(zone_id):zone = DNSZone.query.get(zone_id)@@ -255,53 +324,82 @@ class DNSZoneService:@staticmethoddef _sync_record_to_provider(zone, record, action):- """Sync a DNS record change to the configured provider."""- provider = zone.provider- config = zone.provider_config-+ """Sync a DNS record change to Cloudflare (the only provider the zone layer+ syncs — Route53/DigitalOcean/GoDaddy are managed via DNSProviderService)."""+ if zone.provider != 'cloudflare':+ return+ credential = DNSZoneService._resolve_credential(zone)+ if not credential:+ returntry:- if provider == 'cloudflare':- DNSZoneService._cloudflare_sync(zone, record, action, config)+ DNSZoneService._cloudflare_sync(zone, record, action, credential)except Exception as e:logger.error(f'DNS provider sync failed: {e}')@staticmethod- def _cloudflare_sync(zone, record, action, config):- """Sync record to Cloudflare API."""- import requests+ def _resolve_credential(zone):+ """Resolve the Cloudflare credential for a zone, preferring the canonical+ connection store and persisting the discovered link.++ Order:+ 1. The linked DNSProviderConfig (``zone.dns_provider_config_id``).+ 2. Auto-discovery — the connected provider whose account contains this+ domain; the link + ``provider_zone_id`` are backfilled so step 1 wins+ next time (no repeat API call).+ 3. Legacy fallback — a token still stored inline on the zone.+ Returns a :class:`DnsCredential`, or ``None`` when nothing manages the zone.+ """+ from app.models.email import DNSProviderConfigfrom app.services.dns_provider_service import DNSProviderService+ from app.services.dns.base import DnsCredential- api_token = config.get('api_token')- if not api_token:- return-- headers = {'Authorization': f'Bearer {api_token}', 'Content-Type': 'application/json'}- base_url = f'https://api.cloudflare.com/client/v4/zones/{zone.provider_zone_id}/dns_records'+ if zone.dns_provider_config_id:+ config = DNSProviderConfig.query.get(zone.dns_provider_config_id)+ if config:+ return DnsCredential.from_provider_config(config)- def _payload():- # CAA needs Cloudflare's structured `data` object, not a flat- # `content` string (and `proxied` is meaningless for it).- p = {'type': record.record_type, 'name': record.name, 'ttl': record.ttl}- if record.record_type == 'CAA':- p['data'] = DNSProviderService.parse_caa_value(record.content)- else:- p['content'] = record.content- p['proxied'] = record.proxied- if record.priority is not None:- p['priority'] = record.priority- return p-- if action == 'create':- resp = requests.post(base_url, json=_payload(), headers=headers, timeout=10)- if resp.ok:- data = resp.json()- record.provider_record_id = data.get('result', {}).get('id')+ try:+ config, zinfo = DNSProviderService.find_zone_for_domain(zone.domain)+ except Exception:+ config, zinfo = None, None+ if config:+ zone.dns_provider_config_id = config.id+ if zinfo and not zone.provider_zone_id:+ zone.provider_zone_id = zinfo.get('id')+ try:db.session.commit()+ except Exception:+ db.session.rollback()+ return DnsCredential.from_provider_config(config)- elif action == 'update' and record.provider_record_id:- url = f'{base_url}/{record.provider_record_id}'- requests.put(url, json=_payload(), headers=headers, timeout=10)+ token = (zone.provider_config or {}).get('api_token')+ if token:+ return DnsCredential.cloudflare_token(token)+ return None+ @staticmethod+ def _cloudflare_sync(zone, record, action, credential):+ """Push a single record change to Cloudflare via the shared client.++ ``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)."""+ from app.services.dns import CloudflareClient+ from app.services.dns.base import DnsRecordSpec++ 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)+ if res.get('success'):+ rid = res.get('record_id')+ if rid and rid != record.provider_record_id:+ record.provider_record_id = rid+ db.session.commit()+ else:+ logger.error('Cloudflare sync %s failed for %s: %s',+ action, record.name, res.get('error'))elif action == 'delete' and record.provider_record_id:- url = f'{base_url}/{record.provider_record_id}'- requests.delete(url, headers=headers, timeout=10)+ client.delete(zone_id, record_id=record.provider_record_id)diff --git a/backend/migrations/versions/025_dns_provider_link.py b/backend/migrations/versions/025_dns_provider_link.pynew file mode 100644index 00000000..779cb317--- /dev/null+++ b/backend/migrations/versions/025_dns_provider_link.py@@ -0,0 +1,46 @@+"""Link DNS zones to a canonical DNS provider connection.++Adds:+- dns_zones.dns_provider_config_id (-> dns_provider_configs.id)++So the /dns Zones page and Dynamic DNS resolve Cloudflare credentials from the+same DNSProviderConfig store used by Settings -> Connections, instead of a second+token stashed inline in dns_zones.provider_config_json.++Idempotent: MigrationService runs _fix_missing_columns() + db.create_all() on boot+before Alembic, so guard on the live schema. The column is added without a DB-level+FK constraint (SQLite can't ALTER one in), matching how the boot column-sync adds+it; the ORM model carries the ForeignKey for relationship metadata.++Revision ID: 025_dns_provider_link+Revises: 024_email_providers+Create Date: 2026-06-22+"""+from alembic import op+import sqlalchemy as sa++revision = '025_dns_provider_link'+down_revision = '024_email_providers'+branch_labels = None+depends_on = None+++def upgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ if 'dns_zones' not in set(inspector.get_table_names()):+ return+ cols = {c['name'] for c in inspector.get_columns('dns_zones')}+ if 'dns_provider_config_id' not in cols:+ op.add_column('dns_zones',+ sa.Column('dns_provider_config_id', sa.Integer, nullable=True))+++def downgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ if 'dns_zones' not in set(inspector.get_table_names()):+ return+ cols = {c['name'] for c in inspector.get_columns('dns_zones')}+ if 'dns_provider_config_id' in cols:+ op.drop_column('dns_zones', 'dns_provider_config_id')diff --git a/backend/tests/test_dns_cloudflare_client.py b/backend/tests/test_dns_cloudflare_client.pynew file mode 100644index 00000000..3c4e5875--- /dev/null+++ b/backend/tests/test_dns_cloudflare_client.py@@ -0,0 +1,188 @@+"""Proving tests for the shared Cloudflare client (DNS unification #2).++Both the provider layer (DNSProviderService) and the zone layer (DNSZoneService)+now talk to Cloudflare through ``app.services.dns.cloudflare.CloudflareClient``.+These tests pin the behavior that used to be duplicated (and had drifted):++* auth header shape — scoped token vs global key,+* CAA structured ``data`` (never a flat ``content``),+* MX priority parsed out of the value,+* idempotent upsert — PUT an existing record instead of POSTing a duplicate,+* delete by id (no lookup) vs by name (lookup-then-delete),+* and the zone path capturing ``provider_record_id`` after a create.++Requests are stubbed by monkeypatching the ``requests`` object the client+imported; ``requests`` is a shared module, so this also covers the provider+layer's delegations.+"""+++class _Resp:+ def __init__(self, js):+ self._js = js++ def json(self):+ return self._js+++def _client(token='tok', email=None):+ from app.services.dns import cloudflare as cf+ from app.services.dns.base import DnsCredential+ return cf.CloudflareClient(DnsCredential(provider='cloudflare', token=token, email=email))+++# ── auth headers ─────────────────────────────────────────────────────────────++def test_headers_scoped_token_vs_global_key():+ bearer = _client(token='tok')._headers()+ assert bearer['Authorization'] == 'Bearer tok'+ assert 'X-Auth-Email' not in bearer++ gk = _client(token='globalkey', email='[email protected]')._headers()+ assert gk['X-Auth-Email'] == '[email protected]' and gk['X-Auth-Key'] == 'globalkey'+ assert 'Authorization' not in gk+++# ── payload wire format ──────────────────────────────────────────────────────++def test_payload_a_record_carries_proxied_not_data():+ from app.services.dns.base import DnsRecordSpec+ p = _client()._payload(DnsRecordSpec('A', 'www.example.com', '1.2.3.4', proxied=True))+ assert p['content'] == '1.2.3.4' and p['proxied'] is True+ assert 'data' not in p+++def test_payload_caa_uses_structured_data():+ from app.services.dns.base import DnsRecordSpec+ p = _client()._payload(DnsRecordSpec('CAA', 'example.com', '0 issue "letsencrypt.org"'))+ assert p['data'] == {'flags': 0, 'tag': 'issue', 'value': 'letsencrypt.org'}+ assert 'content' not in p and 'proxied' not in p+++def test_payload_mx_priority_parsed_from_value():+ from app.services.dns.base import DnsRecordSpec+ p = _client()._payload(DnsRecordSpec('MX', 'example.com', '10 mail.example.com'))+ assert p['priority'] == 10 and p['content'] == 'mail.example.com'+++def test_payload_mx_explicit_priority_wins():+ from app.services.dns.base import DnsRecordSpec+ p = _client()._payload(DnsRecordSpec('MX', 'example.com', 'mail.example.com', priority=20))+ assert p['priority'] == 20 and p['content'] == 'mail.example.com'+++# ── upsert (idempotent) ──────────────────────────────────────────────────────++def test_upsert_posts_when_absent(monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services.dns.base import DnsRecordSpec+ monkeypatch.setattr(cf.requests, 'get',+ lambda url, headers=None, timeout=None: _Resp({'result': []}))+ seen = {}+ monkeypatch.setattr(cf.requests, 'post',+ lambda url, headers=None, json=None, timeout=None:+ (seen.update(verb='post', url=url) or+ _Resp({'success': True, 'result': {'id': 'NEW'}})))+ monkeypatch.setattr(cf.requests, 'put',+ lambda *a, **k: (seen.update(verb='put') or _Resp({'success': False})))++ res = _client().upsert('zoneABC', DnsRecordSpec('A', 'www.example.com', '1.2.3.4'))+ assert res['success'] is True and res['record_id'] == 'NEW'+ assert seen['verb'] == 'post' and seen['url'].endswith('/zones/zoneABC/dns_records')+++def test_upsert_puts_existing_match_by_name(monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services.dns.base import DnsRecordSpec+ monkeypatch.setattr(cf.requests, 'get',+ lambda url, headers=None, timeout=None: _Resp({'result': [{'id': 'rec1'}]}))+ seen = {}+ monkeypatch.setattr(cf.requests, 'put',+ lambda url, headers=None, json=None, timeout=None:+ (seen.update(url=url) or _Resp({'success': True, 'result': {'id': 'rec1'}})))+ monkeypatch.setattr(cf.requests, 'post',+ lambda *a, **k: (seen.update(verb='post') or _Resp({'success': False})))++ res = _client().upsert('z', DnsRecordSpec('A', 'www.example.com', '5.6.7.8'))+ assert res['record_id'] == 'rec1'+ assert seen.get('verb') != 'post' and seen['url'].endswith('/rec1')+++def test_upsert_by_record_id_skips_lookup(monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services.dns.base import DnsRecordSpec+ counters = {'get': 0}+ monkeypatch.setattr(cf.requests, 'get',+ lambda *a, **k: (counters.update(get=counters['get'] + 1) or _Resp({'result': []})))+ seen = {}+ monkeypatch.setattr(cf.requests, 'put',+ lambda url, headers=None, json=None, timeout=None:+ (seen.update(url=url) or _Resp({'success': True, 'result': {'id': 'rid'}})))++ res = _client().upsert('z', DnsRecordSpec('A', 'www.example.com', '1.2.3.4'), record_id='rid')+ assert res['success'] is True and counters['get'] == 0+ assert seen['url'].endswith('/rid')+++# ── delete ───────────────────────────────────────────────────────────────────++def test_delete_by_record_id_skips_lookup(monkeypatch):+ from app.services.dns import cloudflare as cf+ counters = {'get': 0}+ monkeypatch.setattr(cf.requests, 'get',+ lambda *a, **k: (counters.update(get=counters['get'] + 1) or _Resp({'result': []})))+ deleted = []+ monkeypatch.setattr(cf.requests, 'delete',+ lambda url, headers=None, timeout=None: (deleted.append(url) or _Resp({'success': True})))++ res = _client().delete('z', record_id='rid')+ assert res['success'] is True and counters['get'] == 0+ assert deleted == ['https://api.cloudflare.com/client/v4/zones/z/dns_records/rid']+++def test_delete_by_name_removes_all_matches(monkeypatch):+ from app.services.dns import cloudflare as cf+ monkeypatch.setattr(cf.requests, 'get',+ lambda url, headers=None, timeout=None: _Resp({'result': [{'id': 'a'}, {'id': 'b'}]}))+ deleted = []+ monkeypatch.setattr(cf.requests, 'delete',+ lambda url, headers=None, timeout=None: (deleted.append(url) or _Resp({'success': True})))++ res = _client().delete('z', record_type='A', name='www.example.com')+ assert res['success'] is True and len(deleted) == 2+++def test_delete_missing_is_success(monkeypatch):+ from app.services.dns import cloudflare as cf+ monkeypatch.setattr(cf.requests, 'get',+ lambda url, headers=None, timeout=None: _Resp({'result': []}))+ monkeypatch.setattr(cf.requests, 'delete',+ lambda *a, **k: _Resp({'success': True}))+ res = _client().delete('z', record_type='A', name='gone.example.com')+ assert res['success'] is True and 'already deleted' in res['message']+++# ── zone layer regression: capture provider_record_id on create ──────────────++def test_zone_create_record_persists_provider_record_id(app, monkeypatch):+ """DNSZoneService.create_record on a Cloudflare zone must store the id Cloudflare+ returns, so later updates/deletes address the record directly."""+ from app import db+ from app.models.dns_zone import DNSZone+ from app.services.dns_zone_service import DNSZoneService+ from app.services.dns import cloudflare as cf++ zone = DNSZone(domain='example.com', provider='cloudflare', provider_zone_id='zoneABC')+ zone.provider_config = {'api_token': 'tok'}+ db.session.add(zone)+ db.session.commit()++ monkeypatch.setattr(cf.requests, 'get',+ lambda url, headers=None, timeout=None: _Resp({'result': []}))+ monkeypatch.setattr(cf.requests, 'post',+ lambda url, headers=None, json=None, timeout=None:+ _Resp({'success': True, 'result': {'id': 'CFREC'}}))++ rec = DNSZoneService.create_record(+ zone.id, {'record_type': 'A', 'name': 'www.example.com', 'content': '1.2.3.4'})+ assert rec.provider_record_id == 'CFREC'diff --git a/backend/tests/test_dns_credential_resolution.py b/backend/tests/test_dns_credential_resolution.pynew file mode 100644index 00000000..fac87fa3--- /dev/null+++ b/backend/tests/test_dns_credential_resolution.py@@ -0,0 +1,166 @@+"""Proving tests for single-source DNS credentials (DNS unification #1).++The /dns Zones page and Dynamic DNS used to keep their *own* Cloudflare token in+``dns_zones.provider_config_json`` — separate from the connection in+Settings -> Connections (``DNSProviderConfig``). These tests prove the zone layer+now resolves credentials from the canonical store:++* an explicit link wins,+* otherwise the connection managing the domain is auto-discovered and the link is+ persisted (with the provider-side zone id),+* a legacy inline token still works until migrated,+* ``link_legacy_zones`` converges inline tokens onto encrypted connections+ (reusing a matching one, else minting), and+* Dynamic DNS rides all of this for free — an IP update syncs through the linked+ connection.+"""+++class _Resp:+ def __init__(self, js):+ self._js = js++ def json(self):+ return self._js+++def _add_connection(name='cf', token='tok'):+ """Create an encrypted Cloudflare connection and return the row."""+ from app.models.email import DNSProviderConfig+ from app.services.dns_provider_service import DNSProviderService+ DNSProviderService.add_provider(name=name, provider='cloudflare', api_key=token)+ return DNSProviderConfig.query.filter_by(name=name).first()+++# ── _resolve_credential ──────────────────────────────────────────────────────++def test_resolve_prefers_linked_connection(app):+ from app import db+ from app.models.dns_zone import DNSZone+ from app.services.dns_zone_service import DNSZoneService++ conn = _add_connection(token='linked-token')+ zone = DNSZone(domain='example.com', provider='cloudflare',+ provider_zone_id='zoneABC', dns_provider_config_id=conn.id)+ db.session.add(zone)+ db.session.commit()++ cred = DNSZoneService._resolve_credential(zone)+ assert cred.provider == 'cloudflare' and cred.token == 'linked-token'+++def test_resolve_auto_discovers_and_persists_link(app, monkeypatch):+ from app import db+ from app.models.dns_zone import DNSZone+ from app.services.dns_zone_service import DNSZoneService+ from app.services.dns_provider_service import DNSProviderService++ conn = _add_connection(token='discovered')+ zone = DNSZone(domain='example.com', provider='cloudflare') # no link, no zone id+ db.session.add(zone)+ db.session.commit()++ monkeypatch.setattr(DNSProviderService, 'find_zone_for_domain', classmethod(+ lambda cls, d: (conn, {'id': 'zoneXYZ', 'name': 'example.com'})))++ cred = DNSZoneService._resolve_credential(zone)+ assert cred.token == 'discovered'+ # the discovered link + provider zone id are persisted for next time+ assert zone.dns_provider_config_id == conn.id+ assert zone.provider_zone_id == 'zoneXYZ'+++def test_resolve_falls_back_to_legacy_inline_token(app, monkeypatch):+ from app import db+ from app.models.dns_zone import DNSZone+ from app.services.dns_zone_service import DNSZoneService+ from app.services.dns_provider_service import DNSProviderService++ zone = DNSZone(domain='legacy.com', provider='cloudflare')+ zone.provider_config = {'api_token': 'legacy-token'}+ db.session.add(zone)+ db.session.commit()++ monkeypatch.setattr(DNSProviderService, 'find_zone_for_domain',+ classmethod(lambda cls, d: (None, None)))++ cred = DNSZoneService._resolve_credential(zone)+ assert cred.token == 'legacy-token'+ assert zone.dns_provider_config_id is None # nothing to link to yet+++# ── link_legacy_zones ────────────────────────────────────────────────────────++def test_link_legacy_zones_mints_encrypted_connection(app):+ from app import db+ from app.models.dns_zone import DNSZone+ from app.models.email import DNSProviderConfig+ from app.services.dns_zone_service import DNSZoneService+ from app.utils.crypto import is_encrypted, decrypt_secret_safe++ zone = DNSZone(domain='example.com', provider='cloudflare', provider_zone_id='zoneABC')+ zone.provider_config = {'api_token': 'mint-me'}+ db.session.add(zone)+ db.session.commit()++ n = DNSZoneService.link_legacy_zones()+ assert n == 1++ conn = DNSProviderConfig.query.filter_by(provider='cloudflare').one()+ assert is_encrypted(conn.api_key) and decrypt_secret_safe(conn.api_key) == 'mint-me'+ assert zone.dns_provider_config_id == conn.id+ assert 'api_token' not in zone.provider_config # plaintext token stripped++ # idempotent — the zone is now linked, so a second pass is a no-op+ assert DNSZoneService.link_legacy_zones() == 0+++def test_link_legacy_zones_reuses_matching_connection(app):+ from app import db+ from app.models.dns_zone import DNSZone+ from app.models.email import DNSProviderConfig+ from app.services.dns_zone_service import DNSZoneService++ conn = _add_connection(name='existing', token='shared-token')+ zone = DNSZone(domain='example.com', provider='cloudflare', provider_zone_id='zoneABC')+ zone.provider_config = {'api_token': 'shared-token'}+ db.session.add(zone)+ db.session.commit()++ n = DNSZoneService.link_legacy_zones()+ assert n == 1+ # linked to the existing connection — no duplicate minted+ assert zone.dns_provider_config_id == conn.id+ assert DNSProviderConfig.query.filter_by(provider='cloudflare').count() == 1+++# ── Dynamic DNS rides the unified credential path ────────────────────────────++def test_ddns_update_syncs_via_linked_connection(app, monkeypatch):+ """A DDNS IP update on a zone linked to a connection drives the shared+ Cloudflare client and captures the provider record id — no inline token."""+ from app import db+ from app.models.dns_zone import DNSZone, DNSRecord+ from app.services.ddns_service import DdnsService+ from app.services.dns import cloudflare as cf++ conn = _add_connection(token='tok')+ zone = DNSZone(domain='example.com', provider='cloudflare',+ provider_zone_id='zoneABC', dns_provider_config_id=conn.id)+ db.session.add(zone)+ db.session.commit()++ host = DdnsService.create_host({'zone_id': zone.id, 'record_name': 'home'})++ monkeypatch.setattr(cf.requests, 'get',+ lambda url, headers=None, timeout=None: _Resp({'result': []}))+ monkeypatch.setattr(cf.requests, 'post',+ lambda url, headers=None, json=None, timeout=None:+ _Resp({'success': True, 'result': {'id': 'CFREC'}}))++ status, updated = DdnsService.update_ip(host.token, '203.0.113.9')+ assert status == 'updated' and updated.last_ip == '203.0.113.9'++ rec = DNSRecord.query.filter_by(zone_id=zone.id, name='home', record_type='A').one()+ assert rec.content == '203.0.113.9'+ assert rec.provider_record_id == 'CFREC' # synced through the linked connectiondiff --git a/frontend/src/pages/DNSZones.jsx b/frontend/src/pages/DNSZones.jsxindex f2ed1710..078a347f 100644--- a/frontend/src/pages/DNSZones.jsx+++ b/frontend/src/pages/DNSZones.jsx@@ -32,41 +32,14 @@ const DNSZones = () => {const [propagationResults, setPropagationResults] = useState([]);const [deleteConfirm, setDeleteConfirm] = useState(null);- const [zoneForm, setZoneForm] = useState({ domain: '', provider: 'manual', provider_zone_id: '', api_token: '' });+ const [zoneForm, setZoneForm] = useState({ domain: '', dns_provider_config_id: '' });+ const [providers, setProviders] = useState([]);const [recordForm, setRecordForm] = useState({record_type: 'A', name: '@', content: '', ttl: 3600, priority: null});const RECORD_TYPES = ['A', 'AAAA', 'CNAME', 'MX', 'TXT', 'SRV', 'CAA', 'NS'];- const PROVIDER_CONFIG = {- cloudflare: {- zoneLabel: 'Cloudflare Zone ID',- zonePlaceholder: 'e.g. 023e105f4ecef8ad9ca31a8372d0c353',- tokenLabel: 'API Token',- tokenPlaceholder: 'Cloudflare API token (Edit zone permissions)',- helpText: 'Find your Zone ID in the Cloudflare dashboard under Overview → API.',- },- route53: {- zoneLabel: 'Hosted Zone ID',- zonePlaceholder: 'e.g. Z3M3LMPEXAMPLE',- tokenLabel: 'AWS Access Key',- tokenPlaceholder: 'AKIA... (needs Route 53 permissions)',- helpText: 'Use an IAM user with AmazonRoute53FullAccess policy.',- extraFields: [- { key: 'aws_secret_key', label: 'AWS Secret Key', placeholder: 'Secret access key', type: 'password' },- { key: 'aws_region', label: 'AWS Region', placeholder: 'us-east-1', type: 'text' },- ],- },- digitalocean: {- zoneLabel: 'Domain Name',- zonePlaceholder: 'e.g. example.com (must exist in your DO account)',- tokenLabel: 'Personal Access Token',- tokenPlaceholder: 'DigitalOcean personal access token',- helpText: 'Generate a token at API → Tokens with read+write scope.',- },- };-const loadZones = useCallback(async () => {try {const data = await api.getDNSZones();@@ -80,6 +53,16 @@ const DNSZones = () => {useEffect(() => { loadZones(); }, [loadZones]);+ // Lazily load connected DNS providers (Settings -> Connections) for the+ // zone picker the first time the modal opens.+ useEffect(() => {+ if (showCreateZone && providers.length === 0) {+ api.getEmailDNSProviders()+ .then(d => setProviders(d.providers || []))+ .catch(() => {});+ }+ }, [showCreateZone, providers.length]);+const loadRecords = async (zoneId) => {try {const data = await api.getDNSRecords(zoneId);@@ -92,18 +75,16 @@ const DNSZones = () => {const handleCreateZone = async () => {try {- const payload = {- domain: zoneForm.domain,- provider: zoneForm.provider,- };- if (zoneForm.provider !== 'manual') {- payload.provider_zone_id = zoneForm.provider_zone_id;- payload.provider_config = { api_token: zoneForm.api_token };+ const payload = { domain: zoneForm.domain };+ if (zoneForm.dns_provider_config_id) {+ payload.dns_provider_config_id = Number(zoneForm.dns_provider_config_id);+ } else {+ payload.provider = 'manual';}await api.createDNSZone(payload);toast.success('Zone created');setShowCreateZone(false);- setZoneForm({ domain: '', provider: 'manual', provider_zone_id: '', api_token: '' });+ setZoneForm({ domain: '', dns_provider_config_id: '' });loadZones();} catch (err) {toast.error(err.message);@@ -259,40 +240,36 @@ const DNSZones = () => {<FormField label="Domain" htmlFor="zone-domain"><Input id="zone-domain" value={zoneForm.domain} onChange={e => setZoneForm({...zoneForm, domain: e.target.value})} placeholder="example.com" /></FormField>- <FormField label="Provider">- <Select value={zoneForm.provider} onValueChange={v => setZoneForm({...zoneForm, provider: v})}>+ <FormField label="DNS Provider">+ <Select+ value={zoneForm.dns_provider_config_id || 'manual'}+ onValueChange={v => setZoneForm({ ...zoneForm, dns_provider_config_id: v === 'manual' ? '' : v })}+ ><SelectTrigger id="zone-provider"><SelectValue /></SelectTrigger><SelectContent>- <SelectItem value="manual">Manual</SelectItem>- <SelectItem value="cloudflare">Cloudflare</SelectItem>- <SelectItem value="route53">Route 53 (AWS)</SelectItem>- <SelectItem value="digitalocean">DigitalOcean</SelectItem>+ <SelectItem value="manual">Manual (no automatic sync)</SelectItem>+ {providers.map(p => (+ <SelectItem key={p.id} value={String(p.id)}>+ {p.name} — {p.provider}+ </SelectItem>+ ))}</SelectContent></Select></FormField>- {zoneForm.provider !== 'manual' && (() => {- const cfg = PROVIDER_CONFIG[zoneForm.provider];- return (- <>- {cfg.helpText && (- <p className="text-muted text-sm">{cfg.helpText}</p>- )}- <FormField label={cfg.zoneLabel} htmlFor="zone-provider-zone-id">- <Input id="zone-provider-zone-id" value={zoneForm.provider_zone_id} onChange={e => setZoneForm({...zoneForm, provider_zone_id: e.target.value})} placeholder={cfg.zonePlaceholder} />- </FormField>- <FormField label={cfg.tokenLabel} htmlFor="zone-api-token">- <Input id="zone-api-token" type="password" value={zoneForm.api_token} onChange={e => setZoneForm({...zoneForm, api_token: e.target.value})} placeholder={cfg.tokenPlaceholder} />- </FormField>- {cfg.extraFields?.map(field => (- <FormField key={field.key} label={field.label} htmlFor={`zone-${field.key}`}>- <Input id={`zone-${field.key}`} type={field.type} value={zoneForm[field.key] || ''} onChange={e => setZoneForm({...zoneForm, [field.key]: e.target.value})} placeholder={field.placeholder} />- </FormField>- ))}- </>- );- })()}+ {zoneForm.dns_provider_config_id ? (+ <p className="text-muted text-sm">+ Records added here sync to this connection. We will match{' '}+ <strong>{zoneForm.domain || 'your domain'}</strong> to a zone in that+ account automatically — no zone ID or token to paste.+ </p>+ ) : (+ <p className="text-muted text-sm">+ Manual zones are not pushed to a provider. To sync automatically,{' '}+ <a href="/settings?tab=connections">connect a DNS provider</a> first.+ </p>+ )}</div><div className="modal-footer"><Button variant="outline" onClick={() => setShowCreateZone(false)}>Cancel</Button>