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(cloudflare): restore Round 2 engine — DNSSEC, Origin CA, rules, activity (plan 42 ph2)
Juan Denisb9ee243ba202
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex 8af90415..08e31c91 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -44,6 +44,7 @@ from app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey, Refrom app.models.dns_zone import DNSZone, DNSRecordfrom app.models.managed_dns_record import ManagedDnsRecordfrom app.models.dns_change import DnsChange+from app.models.cf_ops_change import CfOpsChangefrom app.models.tunnel import Tunnelfrom app.models.exposed_service import ExposedServicefrom app.models.status_page import StatusPage, StatusComponent, HealthCheck, StatusIncident, StatusIncidentUpdate@@ -63,6 +64,7 @@ from app.models.backup_run import BackupRunfrom app.models.restore_drill import RestoreDrillfrom app.queue_bus.models import QueueGroup, Queue, QueueMessagefrom app.notifications.models import Notification, NotificationDelivery+from app.models.email_bounce import EmailBounceStatefrom app.models.email_provider import EmailProviderConnectionfrom app.models.chat_webhook import ChatWebhookConnectionfrom app.models.system_event import SystemEvent@@ -91,7 +93,7 @@ __all__ = ['AgentPlugin', 'AgentPluginInstall','ServerTemplate', 'ServerTemplateAssignment','Workspace', 'WorkspaceMember', 'WorkspaceApiKey', 'ResourceGrant',- 'DNSZone', 'DNSRecord', 'ManagedDnsRecord', 'DnsChange',+ 'DNSZone', 'DNSRecord', 'ManagedDnsRecord', 'DnsChange', 'CfOpsChange','Tunnel', 'ExposedService','StatusPage', 'StatusComponent', 'HealthCheck', 'StatusIncident', 'StatusIncidentUpdate','CloudProvider', 'CloudServer', 'CloudSnapshot',@@ -107,6 +109,7 @@ __all__ = ['BackupPolicy', 'BackupRun', 'RestoreDrill','QueueGroup', 'Queue', 'QueueMessage','Notification', 'NotificationDelivery',+ 'EmailBounceState','EmailProviderConnection','ChatWebhookConnection','SystemEvent',diff --git a/backend/app/models/cf_ops_change.py b/backend/app/models/cf_ops_change.pynew file mode 100644index 00000000..bc4a841a--- /dev/null+++ b/backend/app/models/cf_ops_change.py@@ -0,0 +1,45 @@+from datetime import datetime++from app import db+++class CfOpsChange(db.Model):+ """Audit trail of every Cloudflare *operations* write ServerKit makes to a zone+ (settings, DNSSEC, WAF, redirect/transform rules, Origin CA, Workers, Tunnels,+ R2/KV/D1) — the ops-layer sibling of :class:`DnsChange`, which only covers DNS+ *record* writes.++ Powers the per-zone Activity tab so an operator can see exactly what the panel+ changed on a Cloudflare zone (and what failed) without leaving ServerKit.+ Written best-effort at the extension's service layer via+ :meth:`CfOpsChangeService.record`, which never raises — an audit write must not+ break the operation it describes. Keyed by ``provider_zone_id`` for per-zone+ filtering.+ """+ __tablename__ = 'cf_ops_changes'++ id = db.Column(db.Integer, primary_key=True)+ dns_provider_config_id = db.Column(+ db.Integer, db.ForeignKey('dns_provider_configs.id'), nullable=True, index=True)+ provider_zone_id = db.Column(db.String(128), index=True)+ product = db.Column(db.String(32), nullable=False)+ action = db.Column(db.String(32), nullable=False)+ target = db.Column(db.String(256))+ result = db.Column(db.String(16), nullable=False, default='ok')+ error = db.Column(db.Text)+ user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)+ created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)++ def to_dict(self):+ return {+ 'id': self.id,+ 'dns_provider_config_id': self.dns_provider_config_id,+ 'provider_zone_id': self.provider_zone_id,+ 'product': self.product,+ 'action': self.action,+ 'target': self.target,+ 'result': self.result,+ 'error': self.error,+ 'user_id': self.user_id,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ }diff --git a/backend/app/services/cf_ops_change_service.py b/backend/app/services/cf_ops_change_service.pynew file mode 100644index 00000000..ca1173dd--- /dev/null+++ b/backend/app/services/cf_ops_change_service.py@@ -0,0 +1,64 @@+"""The Cloudflare-ops activity ledger — every zone-operations write ServerKit+makes (settings, DNSSEC, WAF, redirect/transform rules, Origin CA, Workers,+Tunnels, storage) is recorded here, keyed by ``provider_zone_id``.++The ops-layer sibling of :class:`DnsChangeService` (which covers DNS *record*+writes). Recording is best-effort and **never raises** — an audit write must not+break the operation it describes. The current user is captured opportunistically+from the JWT when called inside a request.+"""+import logging++from app import db+from app.models.cf_ops_change import CfOpsChange++logger = logging.getLogger(__name__)+++class CfOpsChangeService:++ @staticmethod+ def _current_user_id():+ """Best-effort current user id (None outside a request/JWT context)."""+ try:+ from flask_jwt_extended import get_jwt_identity+ return get_jwt_identity()+ except Exception:+ return None++ @staticmethod+ def record(*, provider_zone_id, product, action, target=None, result='ok',+ error=None, config_id=None, user_id=None):+ """Append a Cloudflare-ops change to the ledger. Never raises."""+ try:+ row = CfOpsChange(+ provider_zone_id=provider_zone_id,+ product=product,+ action=action,+ target=str(target)[:256] if target is not None else None,+ result=result,+ error=error,+ dns_provider_config_id=config_id,+ user_id=user_id if user_id is not None+ else CfOpsChangeService._current_user_id(),+ )+ db.session.add(row)+ db.session.commit()+ return row+ except Exception as e:+ db.session.rollback()+ logger.warning('Failed to record Cloudflare ops change: %s', e)+ return None++ @staticmethod+ def list(provider_zone_id=None, config_id=None, product=None, result=None, limit=100):+ q = CfOpsChange.query+ if provider_zone_id:+ q = q.filter_by(provider_zone_id=provider_zone_id)+ if config_id:+ q = q.filter_by(dns_provider_config_id=config_id)+ if product:+ q = q.filter_by(product=product)+ if result:+ q = q.filter_by(result=result)+ return q.order_by(CfOpsChange.created_at.desc(), CfOpsChange.id.desc()).limit(limit).all()diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.pyindex 3213367d..aced7f85 100644--- a/backend/app/services/dns/cloudflare.py+++ b/backend/app/services/dns/cloudflare.py@@ -252,14 +252,18 @@ class CloudflareClient:# helper rather than a bespoke method per call. It normalizes the envelope so# every caller can rely on ``{success, error?, result?}``.def request(self, method: str, path: str, json: dict = None,- params: dict = None, timeout: int = 20) -> dict:+ params: dict = None, timeout: int = 20, headers: dict = None) -> dict:"""Make a Cloudflare v4 call. ``path`` is relative to the API base (aleading slash is optional). Returns the parsed envelope dict (always witha ``success`` key and, on failure, a human ``error``), or a normalized- ``{success: False, error}`` on a transport error."""+ ``{success: False, error}`` on a transport error.++ ``headers`` overrides the default auth headers — used by the Origin CA+ endpoints, which authenticate with the account-level Origin CA service key+ (``X-Auth-User-Service-Key``) rather than the zone token."""try:url = f'{API_BASE}/{path.lstrip("/")}'- resp = requests.request(method.upper(), url, headers=self._headers(),+ resp = requests.request(method.upper(), url, headers=headers or self._headers(),json=json, params=params, timeout=timeout)try:data = resp.json()@@ -293,6 +297,57 @@ class CloudflareClient:``{purge_everything: true}`` or ``{files|hosts|prefixes|tags: [...]}``."""return self.request('POST', f'/zones/{zone_id}/purge_cache', json=payload)+ # ── DNSSEC ────────────────────────────────────────────────────────────────+ # DNSSEC is a per-zone toggle; enabling it returns the DS record payload the+ # operator must place at their registrar. No registrar automation — display.+ def get_dnssec(self, zone_id: str) -> dict:+ """The zone's DNSSEC status + DS record fields (``result`` carries ``status``,+ ``ds``, ``digest``, ``key_tag``, …)."""+ return self.request('GET', f'/zones/{zone_id}/dnssec')++ def set_dnssec(self, zone_id: str, status: str) -> dict:+ """Enable (``status='active'``) or disable (``status='disabled'``) DNSSEC."""+ return self.request('PATCH', f'/zones/{zone_id}/dnssec', json={'status': status})++ # ── Origin CA certificates ────────────────────────────────────────────────+ # Origin CA certs are valid ONLY behind the Cloudflare proxy. They authenticate+ # with the account-level Origin CA *service key* (``X-Auth-User-Service-Key``)+ # OR a token carrying the SSL and Certificates permission. The CSR is generated+ # panel-side; the private key never leaves the box.+ ORIGIN_CA_BASE = 'certificates'++ def _origin_ca_headers(self, service_key: str = None) -> dict:+ """Auth headers for the Origin CA endpoints. Prefer the dedicated service+ key when present; otherwise fall back to the zone's normal token headers+ (a suitably-scoped token also authenticates these calls)."""+ if service_key:+ return {'X-Auth-User-Service-Key': service_key,+ 'Content-Type': 'application/json'}+ return self._headers()++ def create_origin_certificate(self, *, csr: str, hostnames: list,+ requested_validity: int = 5475,+ request_type: str = 'origin-rsa',+ service_key: str = None) -> dict:+ """Sign a panel-generated CSR into an Origin CA certificate for ``hostnames``+ (``result.certificate`` is the signed PEM). ``requested_validity`` is in days+ (7, 30, 90, 365, 730, 1095 or 5475)."""+ return self.request(+ 'POST', f'/{self.ORIGIN_CA_BASE}',+ json={'csr': csr, 'hostnames': hostnames,+ 'requested_validity': requested_validity, 'request_type': request_type},+ headers=self._origin_ca_headers(service_key))++ def list_origin_certificates(self, zone_id: str, *, service_key: str = None) -> dict:+ """List Origin CA certificates for a zone (``result`` is a list)."""+ return self.request('GET', f'/{self.ORIGIN_CA_BASE}', params={'zone_id': zone_id},+ headers=self._origin_ca_headers(service_key))++ def revoke_origin_certificate(self, certificate_id: str, *, service_key: str = None) -> dict:+ """Revoke an Origin CA certificate by id."""+ return self.request('DELETE', f'/{self.ORIGIN_CA_BASE}/{certificate_id}',+ headers=self._origin_ca_headers(service_key))+# ── WAF / rulesets ────────────────────────────────────────────────────────# Custom firewall rules live in the zone's ``http_request_firewall_custom``# phase entry-point ruleset. We list rulesets to find it (cleanly tellingdiff --git a/backend/app/services/ssl_service.py b/backend/app/services/ssl_service.pyindex 37d5bb8f..65c2809d 100644--- a/backend/app/services/ssl_service.py+++ b/backend/app/services/ssl_service.py@@ -14,6 +14,9 @@ class SSLService:CERTBOT_BIN = os.environ.get('CERTBOT_BIN', '/usr/bin/certbot')CERTS_DIR = '/etc/letsencrypt/live'RENEWAL_DIR = '/etc/letsencrypt/renewal'+ # Custom-cert install location (e.g. issued Cloudflare Origin CA certs, written+ # by AdvancedSSLService.upload_custom_cert). certbot doesn't know about these.+ SERVERKIT_CERTS_DIR = '/etc/ssl/serverkit'@classmethoddef is_certbot_installed(cls) -> bool:@@ -159,45 +162,85 @@ class SSLService:try:result = run_privileged([cls.CERTBOT_BIN, 'certificates'], timeout=60)- if result.returncode != 0:- return certificates-- # Parse certbot output- current_cert = None- for line in result.stdout.split('\n'):- line = line.strip()-- if line.startswith('Certificate Name:'):- if current_cert:- certificates.append(current_cert)- current_cert = {'name': line.split(':', 1)[1].strip()}-- elif current_cert:- if line.startswith('Domains:'):- current_cert['domains'] = line.split(':', 1)[1].strip().split()- elif line.startswith('Expiry Date:'):- expiry_str = line.split(':', 1)[1].strip()- # Parse expiry date- try:- # Format: 2024-03-15 12:00:00+00:00- expiry_part = expiry_str.split(' (')[0]- current_cert['expiry'] = expiry_part- current_cert['expiry_valid'] = 'VALID' in expiry_str- except Exception:- current_cert['expiry'] = expiry_str- elif line.startswith('Certificate Path:'):- current_cert['cert_path'] = line.split(':', 1)[1].strip()- elif line.startswith('Private Key Path:'):- current_cert['key_path'] = line.split(':', 1)[1].strip()-- if current_cert:- certificates.append(current_cert)+ # Parse certbot output (skip on a non-zero exit, but still surface the+ # custom-installed certs below).+ if result.returncode == 0:+ current_cert = None+ for line in result.stdout.split('\n'):+ line = line.strip()++ if line.startswith('Certificate Name:'):+ if current_cert:+ certificates.append(current_cert)+ current_cert = {'name': line.split(':', 1)[1].strip()}++ elif current_cert:+ if line.startswith('Domains:'):+ current_cert['domains'] = line.split(':', 1)[1].strip().split()+ elif line.startswith('Expiry Date:'):+ expiry_str = line.split(':', 1)[1].strip()+ # Parse expiry date+ try:+ # Format: 2024-03-15 12:00:00+00:00+ expiry_part = expiry_str.split(' (')[0]+ current_cert['expiry'] = expiry_part+ current_cert['expiry_valid'] = 'VALID' in expiry_str+ except Exception:+ current_cert['expiry'] = expiry_str+ elif line.startswith('Certificate Path:'):+ current_cert['cert_path'] = line.split(':', 1)[1].strip()+ elif line.startswith('Private Key Path:'):+ current_cert['key_path'] = line.split(':', 1)[1].strip()++ if current_cert:+ certificates.append(current_cert)except Exception:pass+ # Also surface custom-installed certs (e.g. Cloudflare Origin CA), which+ # certbot doesn't track. Parse the x509 issuer to badge them.+ certificates.extend(cls._list_serverkit_certificates())+return certificates+ @classmethod+ def _list_serverkit_certificates(cls) -> List[Dict]:+ """Walk the custom-cert install dir (``/etc/ssl/serverkit/<domain>/cert.pem``)+ and describe each cert, badging Cloudflare Origin CA certs as proxy-only."""+ import glob+ out: List[Dict] = []+ try:+ from cryptography import x509+ from cryptography.hazmat.backends import default_backend+ except Exception:+ return out++ for cert_path in sorted(glob.glob(f'{cls.SERVERKIT_CERTS_DIR}/*/cert.pem')):+ try:+ domain = os.path.basename(os.path.dirname(cert_path))+ with open(cert_path, 'rb') as fh:+ cert = x509.load_pem_x509_certificate(fh.read(), default_backend())+ issuer = cert.issuer.rfc4514_string()+ is_origin_ca = 'origin' in issuer.lower() and 'cloudflare' in issuer.lower()+ try:+ expiry = cert.not_valid_after_utc+ except AttributeError: # cryptography < 42+ expiry = cert.not_valid_after+ out.append({+ 'name': domain,+ 'domains': [domain],+ 'cert_path': cert_path,+ 'key_path': os.path.join(os.path.dirname(cert_path), 'key.pem'),+ 'issuer': issuer,+ 'source': 'custom',+ 'badge': 'Origin CA (proxy-only)' if is_origin_ca else None,+ 'expiry': expiry.strftime('%Y-%m-%d %H:%M:%S%z') if expiry else None,+ })+ except Exception:+ continue+ return out+@classmethoddef get_certificate_info(cls, domain: str) -> Optional[Dict]:"""Get detailed information about a specific certificate."""diff --git a/backend/tests/test_cloudflare_round2.py b/backend/tests/test_cloudflare_round2.pynew file mode 100644index 00000000..6db54adf--- /dev/null+++ b/backend/tests/test_cloudflare_round2.py@@ -0,0 +1,566 @@+"""Proving tests for Cloudflare Round 2 (plan 36): DNSSEC, Origin CA, redirect/+transform rules, the per-zone activity ledger, and token scope diagnostics.++Reconstructed after the 2026-07-08 data loss (migrations 073/074 survived; the+model/service/routes/client code + this suite did not). Mirrors the conventions of+``test_cloudflare_zone_settings.py``: Cloudflare HTTP is stubbed by monkeypatching+``requests`` on the shared client module, and the extension's ``CloudflareService``+is reached through the ``cloudflare_ops_bridge`` importlib helper.+"""+import types++import pytest+++class _Resp:+ def __init__(self, js, status=200):+ self._js = js+ self.status_code = status++ def json(self):+ return self._js+++def _client(token='tok'):+ from app.services.dns import cloudflare as cf+ from app.services.dns.base import DnsCredential+ return cf.CloudflareClient(DnsCredential(provider='cloudflare', token=token))+++def _make_cf_zone(domain='example.com', provider='cloudflare', zid='zoneABC', token='tok'):+ from app import db+ from app.models.dns_zone import DNSZone+ zone = DNSZone(domain=domain, provider=provider, provider_zone_id=zid)+ if token:+ zone.provider_config = {'api_token': token}+ db.session.add(zone)+ db.session.commit()+ return zone+++# ── DNSSEC — client ───────────────────────────────────────────────────────────++def test_client_get_dnssec(monkeypatch):+ from app.services.dns import cloudflare as cf+ seen = {}++ def cap(method, url, headers=None, json=None, params=None, timeout=None):+ seen.update(method=method, url=url)+ return _Resp({'success': True, 'result': {'status': 'active'}})+ monkeypatch.setattr(cf.requests, 'request', cap)+ res = _client().get_dnssec('zoneA')+ assert res['success'] is True+ assert seen['method'] == 'GET' and seen['url'].endswith('/zones/zoneA/dnssec')+++def test_client_set_dnssec_patches_status(monkeypatch):+ from app.services.dns import cloudflare as cf+ seen = {}++ def cap(method, url, headers=None, json=None, params=None, timeout=None):+ seen.update(method=method, url=url, json=json)+ return _Resp({'success': True, 'result': {'status': 'pending'}})+ monkeypatch.setattr(cf.requests, 'request', cap)+ _client().set_dnssec('zoneA', 'active')+ assert seen['method'] == 'PATCH'+ assert seen['url'].endswith('/zones/zoneA/dnssec')+ assert seen['json'] == {'status': 'active'}+++# ── DNSSEC — service ──────────────────────────────────────────────────────────++def test_service_get_dnssec_normalizes(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': True, 'result': {+ 'status': 'active', 'ds': 'DSRECORD', 'key_tag': 42,+ 'digest_type': 2}}))+ res = CloudflareService.get_dnssec(zone.id)+ assert res['success'] is True+ assert res['dnssec']['status'] == 'active'+ assert res['dnssec']['ds'] == 'DSRECORD'+ assert res['dnssec']['key_tag'] == 42+++def test_service_set_dnssec_enables_and_records(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ from app.models.cf_ops_change import CfOpsChange+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': True,+ 'result': {'status': 'pending'}}))+ res = CloudflareService.set_dnssec(zone.id, True)+ assert res['success'] is True and res['dnssec']['status'] == 'pending'+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='dnssec').first()+ assert row is not None and row.action == 'enable' and row.result == 'ok'+++def test_service_set_dnssec_error_records_failure(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ from app.models.cf_ops_change import CfOpsChange+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': False,+ 'errors': [{'message': 'zone is not full'}]}))+ res = CloudflareService.set_dnssec(zone.id, True)+ assert res['success'] is False and 'not full' in res['error']+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='dnssec').first()+ assert row is not None and row.result == 'error' and 'not full' in (row.error or '')+++# ── Origin CA — client ────────────────────────────────────────────────────────++def test_client_origin_ca_uses_service_key_header(monkeypatch):+ from app.services.dns import cloudflare as cf+ seen = {}++ def cap(method, url, headers=None, json=None, params=None, timeout=None):+ seen.update(method=method, url=url, headers=headers, json=json)+ return _Resp({'success': True, 'result': {'id': 'c1', 'certificate': 'PEM'}})+ monkeypatch.setattr(cf.requests, 'request', cap)+ res = _client().create_origin_certificate(csr='CSR', hostnames=['a.example.com'],+ service_key='v1.0-SVCKEY')+ assert res['success'] is True+ assert seen['method'] == 'POST' and seen['url'].endswith('/certificates')+ assert seen['headers']['X-Auth-User-Service-Key'] == 'v1.0-SVCKEY'+ assert 'Authorization' not in seen['headers']+ assert seen['json']['csr'] == 'CSR' and seen['json']['hostnames'] == ['a.example.com']+++def test_client_origin_ca_falls_back_to_token(monkeypatch):+ from app.services.dns import cloudflare as cf+ seen = {}++ def cap(method, url, headers=None, json=None, params=None, timeout=None):+ seen.update(headers=headers, params=params)+ return _Resp({'success': True, 'result': []})+ monkeypatch.setattr(cf.requests, 'request', cap)+ _client().list_origin_certificates('zoneA')+ assert seen['headers']['Authorization'] == 'Bearer tok'+ assert 'X-Auth-User-Service-Key' not in seen['headers']+ assert seen['params'] == {'zone_id': 'zoneA'}+++def test_client_revoke_origin_certificate(monkeypatch):+ from app.services.dns import cloudflare as cf+ seen = {}++ def cap(method, url, headers=None, json=None, params=None, timeout=None):+ seen.update(method=method, url=url)+ return _Resp({'success': True, 'result': {'id': 'c1'}})+ monkeypatch.setattr(cf.requests, 'request', cap)+ _client().revoke_origin_certificate('c1')+ assert seen['method'] == 'DELETE' and seen['url'].endswith('/certificates/c1')+++# ── Origin CA — service ───────────────────────────────────────────────────────++def test_issue_origin_cert_returns_cert_and_warns_unproxied(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ from app.models.cf_ops_change import CfOpsChange+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()++ def req(method, url, headers=None, json=None, params=None, timeout=None):+ if method == 'POST' and url.endswith('/certificates'):+ # the CSR is generated panel-side and sent; the key is NOT+ assert 'csr' in (json or {}) and 'key' not in (json or {})+ return _Resp({'success': True, 'result': {+ 'id': 'cert1', 'certificate': 'CERTPEM', 'expires_on': '2027-01-01'}})+ return _Resp({'success': False})++ def get(url, headers=None, params=None, timeout=None):+ # DNS records lookup for the proxied-hostname warning: grey-cloud record+ return _Resp({'success': True, 'result': [+ {'id': 'r', 'type': 'A', 'name': 'app.example.com',+ 'content': '1.2.3.4', 'proxied': False}]})+ monkeypatch.setattr(cf.requests, 'request', req)+ monkeypatch.setattr(cf.requests, 'get', get)++ res = CloudflareService.issue_origin_certificate(+ zone.id, ['app.example.com'], validity_days=5475, install=False)+ assert res['success'] is True+ assert res['certificate'] == 'CERTPEM' and res['certificate_id'] == 'cert1'+ assert res['proxy_only'] is True+ assert any('not proxied' in w for w in res['warnings'])+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='origin_ca').first()+ assert row is not None and row.action == 'issue' and row.result == 'ok'+++def test_issue_origin_cert_validates_hostnames(app):+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()+ zone = _make_cf_zone()+ with pytest.raises(CloudflareError):+ CloudflareService.issue_origin_certificate(zone.id, [], install=False)+++def test_issue_origin_cert_validates_validity(app):+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()+ zone = _make_cf_zone()+ with pytest.raises(CloudflareError):+ CloudflareService.issue_origin_certificate(+ zone.id, ['a.example.com'], validity_days=999, install=False)+++def test_issue_origin_cert_scope_error_raises_400_not_502(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': False, 'errors': [+ {'message': 'You do not have permission to use Origin CA'}]}))+ with pytest.raises(CloudflareError):+ CloudflareService.issue_origin_certificate(+ zone.id, ['a.example.com'], install=False)+++def test_list_origin_certificates_maps(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': True, 'result': [+ {'id': 'c1', 'hostnames': ['a.example.com'],+ 'expires_on': '2027-01-01', 'requested_validity': 5475}]}))+ res = CloudflareService.list_origin_certificates(zone.id)+ assert res['success'] is True and res['proxy_only'] is True+ assert res['certificates'][0]['id'] == 'c1'+ assert res['certificates'][0]['hostnames'] == ['a.example.com']+++def test_list_origin_certificates_scope_error_raises(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': False, 'errors': [+ {'message': 'Authentication error'}]}))+ with pytest.raises(CloudflareError):+ CloudflareService.list_origin_certificates(zone.id)+++def test_revoke_origin_certificate_records(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ from app.models.cf_ops_change import CfOpsChange+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': True, 'result': {'id': 'c1'}}))+ res = CloudflareService.revoke_origin_certificate(zone.id, 'c1')+ assert res['success'] is True and res['certificate_id'] == 'c1'+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='origin_ca',+ action='revoke').first()+ assert row is not None and row.result == 'ok'+++def test_install_origin_cert_uses_upload_seam(app, monkeypatch):+ from app.services import advanced_ssl_service as adv+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ captured = {}++ def fake_upload(domain, cert_pem, key_pem, chain_pem=None):+ captured.update(domain=domain, cert=cert_pem, key=key_pem)+ return {'domain': domain, 'cert_path': f'/etc/ssl/serverkit/{domain}/cert.pem',+ 'key_path': f'/etc/ssl/serverkit/{domain}/key.pem'}+ monkeypatch.setattr(adv.AdvancedSSLService, 'upload_custom_cert',+ staticmethod(fake_upload))+ out = CloudflareService._install_origin_cert(['app.example.com'], 'CERTPEM', 'KEYPEM')+ assert out['success'] is True+ assert captured['domain'] == 'app.example.com'+ assert captured['cert'] == 'CERTPEM' and captured['key'] == 'KEYPEM'+++# ── SSL list: custom certs surfaced with Origin CA badge ──────────────────────++def _write_origin_cert(directory, domain):+ import os+ from datetime import datetime, timedelta+ from cryptography import x509+ from cryptography.x509.oid import NameOID+ from cryptography.hazmat.primitives import hashes, serialization+ from cryptography.hazmat.primitives.asymmetric import rsa++ key = rsa.generate_private_key(public_exponent=65537, key_size=2048)+ issuer = x509.Name([+ x509.NameAttribute(NameOID.ORGANIZATION_NAME, 'CloudFlare, Inc.'),+ x509.NameAttribute(NameOID.COMMON_NAME, 'CloudFlare Origin SSL Certificate Authority'),+ ])+ subject = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, domain)])+ cert = (x509.CertificateBuilder()+ .subject_name(subject).issuer_name(issuer)+ .public_key(key.public_key())+ .serial_number(x509.random_serial_number())+ .not_valid_before(datetime.utcnow() - timedelta(days=1))+ .not_valid_after(datetime.utcnow() + timedelta(days=365))+ .sign(key, hashes.SHA256()))+ cert_dir = os.path.join(directory, domain)+ os.makedirs(cert_dir, exist_ok=True)+ with open(os.path.join(cert_dir, 'cert.pem'), 'wb') as fh:+ fh.write(cert.public_bytes(serialization.Encoding.PEM))+++def test_ssl_list_certificates_includes_origin_ca_badge(app, monkeypatch, tmp_path):+ from app.services import ssl_service as sslmod+ _write_origin_cert(str(tmp_path), 'app.example.com')+ monkeypatch.setattr(sslmod.SSLService, 'SERVERKIT_CERTS_DIR', str(tmp_path))+ # Force the certbot branch to yield nothing so only the serverkit walk runs.+ monkeypatch.setattr(sslmod, 'run_privileged',+ lambda *a, **k: types.SimpleNamespace(returncode=1, stdout='', stderr=''))+ certs = sslmod.SSLService.list_certificates()+ origin = next((c for c in certs if c.get('name') == 'app.example.com'), None)+ assert origin is not None+ assert origin['source'] == 'custom'+ assert origin['badge'] == 'Origin CA (proxy-only)'+++# ── Redirect + Transform rules ────────────────────────────────────────────────++def test_rules_unknown_slug_raises(app):+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()+ zone = _make_cf_zone()+ with pytest.raises(CloudflareError):+ CloudflareService.list_rules(zone.id, 'bogus')+++def test_rules_list_empty_when_no_ruleset(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda method, url, **k:+ _Resp({'success': True, 'result': []})+ if url.endswith('/rulesets') else _Resp({'success': False}))+ res = CloudflareService.list_rules(zone.id, 'redirect')+ assert res['success'] is True and res['ruleset_id'] is None and res['rules'] == []+ assert any(p['key'] == 'force_www' for p in res['presets'])+++def test_rules_add_creates_phase_ruleset(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ seen = {}++ def stub(method, url, headers=None, json=None, params=None, timeout=None):+ if method == 'GET' and url.endswith('/rulesets'):+ return _Resp({'success': True, 'result': []})+ if method == 'PUT' and url.endswith('/phases/http_request_dynamic_redirect/entrypoint'):+ seen.update(json=json)+ return _Resp({'success': True, 'result': {'id': 'rsNew'}})+ return _Resp({'success': False})+ monkeypatch.setattr(cf.requests, 'request', stub)+ res = CloudflareService.add_rule(zone.id, 'redirect', description='d',+ expression='(http.host eq "example.com")',+ action='redirect')+ assert res['success'] is True+ assert seen['json']['rules'][0]['action'] == 'redirect'+++def test_rules_add_rejects_bad_action(app):+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()+ zone = _make_cf_zone()+ with pytest.raises(CloudflareError):+ CloudflareService.add_rule(zone.id, 'redirect', description='d',+ expression='x', action='block')+++def test_rules_preset_force_www_builds_expression(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ from app.models.cf_ops_change import CfOpsChange+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ seen = {}++ def stub(method, url, headers=None, json=None, params=None, timeout=None):+ if method == 'GET' and url.endswith('/rulesets'):+ return _Resp({'success': True, 'result': [+ {'id': 'rs1', 'phase': 'http_request_dynamic_redirect', 'kind': 'zone'}]})+ if method == 'POST' and url.endswith('/rulesets/rs1/rules'):+ seen.update(json=json)+ return _Resp({'success': True, 'result': {'id': 'rs1'}})+ return _Resp({'success': False})+ monkeypatch.setattr(cf.requests, 'request', stub)+ res = CloudflareService.apply_rule_preset(zone.id, 'redirect', 'force_www')+ assert res['success'] is True+ assert 'http.host eq "example.com"' in seen['json']['expression']+ assert seen['json']['action'] == 'redirect'+ assert 'www.example.com' in seen['json']['action_parameters']['from_value']['target_url']['expression']+ row = CfOpsChange.query.filter_by(provider_zone_id='zoneABC', product='redirect').first()+ assert row is not None and row.action == 'add-rule'+++def test_rules_preset_transform_strip_tracking(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ seen = {}++ def stub(method, url, headers=None, json=None, params=None, timeout=None):+ if method == 'GET' and url.endswith('/rulesets'):+ return _Resp({'success': True, 'result': []})+ if method == 'PUT' and url.endswith('/phases/http_request_transform/entrypoint'):+ seen.update(json=json)+ return _Resp({'success': True, 'result': {'id': 'rsT'}})+ return _Resp({'success': False})+ monkeypatch.setattr(cf.requests, 'request', stub)+ res = CloudflareService.apply_rule_preset(zone.id, 'transform', 'strip_tracking')+ assert res['success'] is True+ assert seen['json']['rules'][0]['action'] == 'rewrite'+ assert 'utm_' in seen['json']['rules'][0]['action_parameters']['uri']['query']['expression']+++def test_rules_update_validates_action(app):+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService, CloudflareError = _cfb.cloudflare_service(), _cfb.cloudflare_error()+ zone = _make_cf_zone()+ with pytest.raises(CloudflareError):+ CloudflareService.update_rule(zone.id, 'redirect', 'rs1', 'r1', {'action': 'block'})+++def test_rules_delete_calls_delete(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ deleted = {}++ def stub(method, url, headers=None, json=None, params=None, timeout=None):+ if method == 'DELETE':+ deleted.update(url=url)+ return _Resp({'success': True})+ return _Resp({'success': False})+ monkeypatch.setattr(cf.requests, 'request', stub)+ res = CloudflareService.delete_rule(zone.id, 'transform', 'rs1', 'r1')+ assert res['success'] is True+ assert deleted['url'].endswith('/rulesets/rs1/rules/r1')+++# ── Activity ledger ───────────────────────────────────────────────────────────++def test_activity_records_success_and_lists(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': True,+ 'result': {'id': 'ssl', 'value': 'strict'}}))+ CloudflareService.update_setting(zone.id, 'ssl', 'strict')+ res = CloudflareService.list_activity(zone.id)+ assert res['success'] is True+ assert any(c['product'] == 'settings' and c['action'] == 'update'+ for c in res['changes'])+++def test_activity_records_failure_row(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': False,+ 'errors': [{'message': 'nope'}]}))+ CloudflareService.update_setting(zone.id, 'ssl', 'strict')+ res = CloudflareService.list_activity(zone.id, result='error')+ assert any(c['result'] == 'error' and c['product'] == 'settings'+ for c in res['changes'])+++def test_activity_filters_by_product(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()+ monkeypatch.setattr(cf.requests, 'request',+ lambda *a, **k: _Resp({'success': True, 'result': {}}))+ CloudflareService.update_setting(zone.id, 'ssl', 'strict')+ CloudflareService.set_dnssec(zone.id, True)+ res = CloudflareService.list_activity(zone.id, product='dnssec')+ assert res['changes'] and all(c['product'] == 'dnssec' for c in res['changes'])+++# ── Scope diagnostics ─────────────────────────────────────────────────────────++def test_scope_check_classifies_per_product(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()++ def req(method, url, headers=None, json=None, params=None, timeout=None):+ # account resolution+ if url.endswith('/zones/zoneABC'):+ return _Resp({'success': True, 'result': {'account': {'id': 'acct1'}}})+ if url.endswith('/zones/zoneABC/settings'):+ return _Resp({'success': True, 'result': []})+ if url.endswith('/zones/zoneABC/dnssec'):+ return _Resp({'success': False, 'errors': [{'message': 'permission denied'}]})+ if url.endswith('/zones/zoneABC/rulesets'):+ return _Resp({'success': True, 'result': []})+ if url.endswith('/certificates'):+ return _Resp({'success': True, 'result': []})+ if url.endswith('/accounts/acct1/workers/scripts'):+ return _Resp({'success': True, 'result': []})+ if url.endswith('/accounts/acct1/cfd_tunnel'):+ return _Resp({'success': False, 'errors': [{'message': 'insufficient scope'}]})+ if url.endswith('/accounts/acct1/r2/buckets'):+ return _Resp({'success': True, 'result': {'buckets': []}})+ return _Resp({'success': False, 'errors': [{'message': 'boom'}]})++ def get(url, headers=None, params=None, timeout=None):+ # list_records (dns probe) uses requests.get+ return _Resp({'success': True, 'result': []})+ monkeypatch.setattr(cf.requests, 'request', req)+ monkeypatch.setattr(cf.requests, 'get', get)++ res = CloudflareService.scope_check(zone.id)+ p = res['products']+ assert p['settings'] == 'ok'+ assert p['dns'] == 'ok'+ assert p['dnssec'] == 'missing_scope'+ assert p['waf'] == 'ok'+ assert p['tunnels'] == 'missing_scope'+ assert p['storage'] == 'ok'+++def test_scope_check_account_unresolved_marks_missing(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services import cloudflare_ops_bridge as _cfb+ CloudflareService = _cfb.cloudflare_service()+ zone = _make_cf_zone()++ def req(method, url, headers=None, json=None, params=None, timeout=None):+ if url.endswith('/zones/zoneABC'):+ return _Resp({'success': False, 'errors': [{'message': 'no access'}]})+ if url.endswith('/zones/zoneABC/settings'):+ return _Resp({'success': True, 'result': []})+ return _Resp({'success': True, 'result': []})++ monkeypatch.setattr(cf.requests, 'request', req)+ monkeypatch.setattr(cf.requests, 'get', lambda *a, **k: _Resp({'success': True, 'result': []}))+ res = CloudflareService.scope_check(zone.id)+ p = res['products']+ assert p['workers'] == 'missing_scope'+ assert p['tunnels'] == 'missing_scope'+ assert p['storage'] == 'missing_scope'diff --git a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.py b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.pyindex 225c172b..b2a579e4 100644--- a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.py+++ b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare.py@@ -410,3 +410,173 @@ def delete_d1_database(zone_id, database_id):except CloudflareError as e:return jsonify({'error': str(e)}), 400return _service_response(res)+++# ── DNSSEC ────────────────────────────────────────────────────────────────────++@cloudflare_bp.route('/zones/<int:zone_id>/dnssec', methods=['GET'])+@jwt_required()+def get_dnssec(zone_id):+ try:+ res = CloudflareService.get_dnssec(zone_id)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/dnssec', methods=['PATCH'])+@jwt_required()+def set_dnssec(zone_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json(silent=True) or {}+ if 'enabled' not in data:+ return jsonify({'error': 'An "enabled" boolean is required'}), 400+ try:+ res = CloudflareService.set_dnssec(zone_id, bool(data['enabled']))+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++# ── Origin CA certificates ─────────────────────────────────────────────────────++@cloudflare_bp.route('/zones/<int:zone_id>/origin-certificates', methods=['GET'])+@jwt_required()+def list_origin_certificates(zone_id):+ try:+ res = CloudflareService.list_origin_certificates(zone_id)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/origin-certificates', methods=['POST'])+@jwt_required()+def issue_origin_certificate(zone_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json(silent=True) or {}+ try:+ res = CloudflareService.issue_origin_certificate(+ zone_id,+ hostnames=data.get('hostnames'),+ validity_days=int(data.get('validity_days', 5475)),+ install=bool(data.get('install', True)))+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ except (TypeError, ValueError):+ return jsonify({'error': 'validity_days must be a number'}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/origin-certificates/<certificate_id>',+ methods=['DELETE'])+@jwt_required()+def revoke_origin_certificate(zone_id, certificate_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ try:+ res = CloudflareService.revoke_origin_certificate(zone_id, certificate_id)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++# ── Redirect + Transform rules ─────────────────────────────────────────────────++@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>', methods=['GET'])+@jwt_required()+def list_rules(zone_id, slug):+ try:+ res = CloudflareService.list_rules(zone_id, slug)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>', methods=['POST'])+@jwt_required()+def add_rule(zone_id, slug):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json(silent=True) or {}+ try:+ res = CloudflareService.add_rule(+ zone_id, slug,+ description=data.get('description'),+ expression=data.get('expression'),+ action=data.get('action'),+ action_parameters=data.get('action_parameters'),+ enabled=data.get('enabled', True))+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>/presets/<preset_key>', methods=['POST'])+@jwt_required()+def apply_rule_preset(zone_id, slug, preset_key):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json(silent=True) or {}+ try:+ res = CloudflareService.apply_rule_preset(zone_id, slug, preset_key, data.get('params') or {})+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>/rulesets/<ruleset_id>/rules/<rule_id>',+ methods=['PATCH'])+@jwt_required()+def update_rule(zone_id, slug, ruleset_id, rule_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json(silent=True) or {}+ try:+ res = CloudflareService.update_rule(zone_id, slug, ruleset_id, rule_id, data)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/rules/<slug>/rulesets/<ruleset_id>/rules/<rule_id>',+ methods=['DELETE'])+@jwt_required()+def delete_rule(zone_id, slug, ruleset_id, rule_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ try:+ res = CloudflareService.delete_rule(zone_id, slug, ruleset_id, rule_id)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++# ── Activity + scope diagnostics ───────────────────────────────────────────────++@cloudflare_bp.route('/zones/<int:zone_id>/activity', methods=['GET'])+@jwt_required()+def list_activity(zone_id):+ try:+ res = CloudflareService.list_activity(+ zone_id,+ product=request.args.get('product'),+ result=request.args.get('result'),+ limit=min(int(request.args.get('limit', 100) or 100), 500))+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ except (TypeError, ValueError):+ return jsonify({'error': 'limit must be a number'}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/scope-check', methods=['GET'])+@jwt_required()+def scope_check(zone_id):+ try:+ res = CloudflareService.scope_check(zone_id)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)diff --git a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.py b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.pyindex 13e0c59e..a397b11c 100644--- a/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.py+++ b/builtin-extensions/serverkit-cloudflare-ops/backend/cloudflare_service.py@@ -12,6 +12,7 @@ the ``/dns`` API uses); credential + Cloudflare zone id are resolved server-sidevia :meth:`DNSZoneService._resolve_credential`, the canonical resolver."""import logging+import osimport relogger = logging.getLogger(__name__)@@ -178,6 +179,20 @@ class CloudflareService:return {'id': zone.id, 'domain': zone.domain,'provider_zone_id': zone.provider_zone_id}+ @staticmethod+ def _record(zone, product, action, target=None, result='ok', error=None):+ """Best-effort append to the Cloudflare-ops activity ledger. Never raises —+ an audit write must not break the operation it describes."""+ try:+ from app.services.cf_ops_change_service import CfOpsChangeService+ CfOpsChangeService.record(+ provider_zone_id=getattr(zone, 'provider_zone_id', None),+ product=product, action=action, target=target,+ result=result, error=error,+ config_id=getattr(zone, 'dns_provider_config_id', None))+ except Exception: # pragma: no cover - ledger writes are best-effort+ pass+@classmethoddef get_settings(cls, zone_id):"""Live zone settings, indexed by id, plus the UI grouping metadata."""@@ -202,7 +217,9 @@ class CloudflareService:zone, client = cls._zone_and_client(zone_id)res = client.update_zone_setting(zone.provider_zone_id, setting_id, value)if not res.get('success'):+ cls._record(zone, 'settings', 'update', setting_id, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Update failed')}+ cls._record(zone, 'settings', 'update', setting_id)return {'success': True, 'setting': res.get('result')}@classmethod@@ -217,6 +234,9 @@ class CloudflareService:'success': bool(res.get('success')),'error': None if res.get('success') else res.get('error')})applied = sum(1 for r in results if r['success'])+ cls._record(zone, 'settings', 'apply-preset', 'recommended',+ 'ok' if applied else 'error',+ None if applied else 'No settings applied')return {'success': applied > 0, 'applied': applied,'total': len(results), 'results': results}@@ -249,8 +269,11 @@ class CloudflareService:'provide files, hosts, prefixes, or tags')res = client.purge_cache(zone.provider_zone_id, payload)+ target = 'everything' if everything else 'files'if not res.get('success'):+ cls._record(zone, 'cache', 'purge', target, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Cache purge failed')}+ cls._record(zone, 'cache', 'purge', target)return {'success': True, 'purged': payload}# ── WAF custom rules ─────────────────────────────────────────────────────@@ -333,15 +356,16 @@ class CloudflareService:raise CloudflareError(f'Unknown WAF preset: {key}')@classmethod- def _find_custom_ruleset(cls, client, provider_zone_id):+ def _find_custom_ruleset(cls, client, provider_zone_id, phase=None):"""Return ``(ruleset_dict, listing_error)``. ``ruleset_dict`` is the zone'scustom-firewall entry-point ruleset or ``None`` when it doesn't exist yet;``listing_error`` is set only when the list call itself failed (auth/scope)."""+ phase = phase or cls.WAF_PHASElisting = client.list_rulesets(provider_zone_id)if not listing.get('success'):return None, listing.get('error', 'Failed to list rulesets')custom = next((rs for rs in (listing.get('result') or [])- if rs.get('phase') == cls.WAF_PHASE and rs.get('kind') == 'zone'), None)+ if rs.get('phase') == phase and rs.get('kind') == 'zone'), None)return custom, None@staticmethod@@ -388,7 +412,9 @@ class CloudflareService:else:res = client.create_phase_ruleset(zone.provider_zone_id, cls.WAF_PHASE, [rule])if not res.get('success'):+ cls._record(zone, 'waf', 'add-rule', rule['description'], 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to add rule')}+ cls._record(zone, 'waf', 'add-rule', rule['description'])return {'success': True, 'result': res.get('result')}@classmethod@@ -412,7 +438,9 @@ class CloudflareService:raise CloudflareError('No updatable fields provided')res = client.update_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id, rule)if not res.get('success'):+ cls._record(zone, 'waf', 'update-rule', rule_id, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to update rule')}+ cls._record(zone, 'waf', 'update-rule', rule_id)return {'success': True, 'result': res.get('result')}@classmethod@@ -420,7 +448,9 @@ class CloudflareService:zone, client = cls._zone_and_client(zone_id)res = client.delete_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id)if not res.get('success'):+ cls._record(zone, 'waf', 'delete-rule', rule_id, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to delete rule')}+ cls._record(zone, 'waf', 'delete-rule', rule_id)return {'success': True}# ── Workers (edge hosting) ───────────────────────────────────────────────@@ -488,6 +518,7 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.upload_worker_module(account_id, name, code, compat)if not res.get('success'):+ cls._record(zone, 'workers', 'deploy', name, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Worker upload failed')}rec = CloudflareWorker.query.filter_by(account_id=account_id, name=name).first()@@ -504,6 +535,7 @@ class CloudflareService:rr = client.add_worker_route(zone.provider_zone_id, route_pattern.strip(), name)route = {'success': bool(rr.get('success')),'error': None if rr.get('success') else rr.get('error')}+ cls._record(zone, 'workers', 'deploy', name)return {'success': True, 'worker': rec.to_dict(), 'route': route}@classmethod@@ -514,11 +546,13 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.delete_worker_script(account_id, name)if not res.get('success'):+ cls._record(zone, 'workers', 'delete', name, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to delete worker')}rec = CloudflareWorker.query.filter_by(account_id=account_id, name=name).first()if rec:db.session.delete(rec)db.session.commit()+ cls._record(zone, 'workers', 'delete', name)return {'success': True}@classmethod@@ -528,7 +562,9 @@ class CloudflareService:zone, client = cls._zone_and_client(zone_id)res = client.add_worker_route(zone.provider_zone_id, pattern.strip(), script.strip())if not res.get('success'):+ cls._record(zone, 'workers', 'add-route', pattern.strip(), 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to add route')}+ cls._record(zone, 'workers', 'add-route', pattern.strip())return {'success': True, 'result': res.get('result')}@classmethod@@ -536,7 +572,9 @@ class CloudflareService:zone, client = cls._zone_and_client(zone_id)res = client.delete_worker_route(zone.provider_zone_id, route_id)if not res.get('success'):+ cls._record(zone, 'workers', 'delete-route', route_id, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to delete route')}+ cls._record(zone, 'workers', 'delete-route', route_id)return {'success': True}# ── Tunnels (cloudflared) ────────────────────────────────────────────────@@ -583,6 +621,7 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.create_tunnel(account_id, name)if not res.get('success'):+ cls._record(zone, 'tunnels', 'create', name, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to create tunnel')}result = res.get('result') or {}tunnel_id = result.get('id')@@ -597,6 +636,7 @@ class CloudflareService:token_encrypted=encrypt_secret(token) if token else None)db.session.add(rec)db.session.commit()+ cls._record(zone, 'tunnels', 'create', name)return {'success': True, 'tunnel': rec.to_dict(),'token': token, 'install': cls._install_command(token)}@@ -619,11 +659,13 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.delete_tunnel(account_id, tunnel_id)if not res.get('success'):+ cls._record(zone, 'tunnels', 'delete', tunnel_id, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to delete tunnel')}rec = CloudflareTunnel.query.filter_by(account_id=account_id, tunnel_id=tunnel_id).first()if rec:db.session.delete(rec)db.session.commit()+ cls._record(zone, 'tunnels', 'delete', tunnel_id)return {'success': True}@classmethod@@ -662,8 +704,10 @@ class CloudflareService:res = client.put_tunnel_configuration(account_id, tunnel_id, config)if not res.get('success'):+ cls._record(zone, 'tunnels', 'add-hostname', hostname, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to set tunnel route')}dns = cls._ensure_tunnel_cname(zone, client, hostname, tunnel_id)+ cls._record(zone, 'tunnels', 'add-hostname', hostname)return {'success': True, 'dns': dns}@classmethod@@ -681,7 +725,9 @@ class CloudflareService:config['ingress'] = ingressres = client.put_tunnel_configuration(account_id, tunnel_id, config)if not res.get('success'):+ cls._record(zone, 'tunnels', 'remove-hostname', hostname, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to remove tunnel route')}+ cls._record(zone, 'tunnels', 'remove-hostname', hostname)return {'success': True}@staticmethod@@ -753,7 +799,9 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.create_r2_bucket(account_id, name)if not res.get('success'):+ cls._record(zone, 'storage', 'create-r2', name, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to create bucket')}+ cls._record(zone, 'storage', 'create-r2', name)return {'success': True, 'bucket': name}@classmethod@@ -762,7 +810,9 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.delete_r2_bucket(account_id, name)if not res.get('success'):+ cls._record(zone, 'storage', 'delete-r2', name, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to delete bucket')}+ cls._record(zone, 'storage', 'delete-r2', name)return {'success': True}@classmethod@@ -774,7 +824,9 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.create_kv_namespace(account_id, title)if not res.get('success'):+ cls._record(zone, 'storage', 'create-kv', title, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to create namespace')}+ cls._record(zone, 'storage', 'create-kv', title)return {'success': True, 'namespace': res.get('result')}@classmethod@@ -783,7 +835,9 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.delete_kv_namespace(account_id, namespace_id)if not res.get('success'):+ cls._record(zone, 'storage', 'delete-kv', namespace_id, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to delete namespace')}+ cls._record(zone, 'storage', 'delete-kv', namespace_id)return {'success': True}@classmethod@@ -795,7 +849,9 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.create_d1_database(account_id, name)if not res.get('success'):+ cls._record(zone, 'storage', 'create-d1', name, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to create database')}+ cls._record(zone, 'storage', 'create-d1', name)return {'success': True, 'database': res.get('result')}@classmethod@@ -804,5 +860,473 @@ class CloudflareService:account_id = cls._account_id(zone, client)res = client.delete_d1_database(account_id, database_id)if not res.get('success'):+ cls._record(zone, 'storage', 'delete-d1', database_id, 'error', res.get('error'))return {'success': False, 'error': res.get('error', 'Failed to delete database')}+ cls._record(zone, 'storage', 'delete-d1', database_id)+ return {'success': True}++ # ── DNSSEC ────────────────────────────────────────────────────────────────+ # Display-only: enabling DNSSEC returns the DS record the operator must place+ # at their registrar. No registrar automation.++ @staticmethod+ def _normalize_dnssec(r):+ """Flatten Cloudflare's DNSSEC ``result`` to the fields the DS card needs."""+ r = r or {}+ return {+ 'status': r.get('status'), # active | pending | pending-disabled | disabled+ 'ds': r.get('ds'),+ 'digest': r.get('digest'),+ 'digest_type': r.get('digest_type'),+ 'digest_algorithm': r.get('digest_algorithm'),+ 'algorithm': r.get('algorithm'),+ 'key_tag': r.get('key_tag'),+ 'key_type': r.get('key_type'),+ 'public_key': r.get('public_key'),+ 'flags': r.get('flags'),+ }++ @classmethod+ def get_dnssec(cls, zone_id):+ zone, client = cls._zone_and_client(zone_id)+ res = client.get_dnssec(zone.provider_zone_id)+ if not res.get('success'):+ return {'success': False, 'error': res.get('error', 'Failed to load DNSSEC status')}+ return {'success': True, 'zone': cls._zone_dict(zone),+ 'dnssec': cls._normalize_dnssec(res.get('result'))}++ @classmethod+ def set_dnssec(cls, zone_id, enabled):+ """Enable or disable DNSSEC. Returns the DS record payload on enable."""+ zone, client = cls._zone_and_client(zone_id)+ action = 'enable' if enabled else 'disable'+ res = client.set_dnssec(zone.provider_zone_id, 'active' if enabled else 'disabled')+ if not res.get('success'):+ cls._record(zone, 'dnssec', action, zone.domain, 'error', res.get('error'))+ return {'success': False, 'error': res.get('error', 'Failed to update DNSSEC')}+ cls._record(zone, 'dnssec', action, zone.domain)+ return {'success': True, 'dnssec': cls._normalize_dnssec(res.get('result'))}++ # ── Origin CA certificates ────────────────────────────────────────────────+ # Issue-and-install, honest about trust: Origin CA certs are valid ONLY behind+ # the Cloudflare proxy. The CSR is generated panel-side; the private key never+ # leaves the box (only the CSR is sent to Cloudflare). Install reuses the+ # existing custom-cert seam (Linux-only). A credential lacking the Origin CA+ # permission is surfaced as an actionable 400 (CloudflareError), never a 502.++ # Cloudflare's accepted Origin CA validity windows, in days (7d … 15y).+ ORIGIN_CA_VALIDITY_DAYS = [7, 30, 90, 365, 730, 1095, 5475]++ # Substrings that mark a provider error as a credential/scope problem rather+ # than a transient provider failure — surfaced as a scoped 400.+ _SCOPE_ERROR_MARKERS = (+ 'permission', 'not authorized', 'unauthorized', 'authentication',+ 'not allowed', 'insufficient', 'invalid api', 'access denied',+ 'forbidden', 'origin ca', 'service key', 'scope',+ )++ @classmethod+ def _is_scope_error(cls, error):+ e = (error or '').lower()+ return any(m in e for m in cls._SCOPE_ERROR_MARKERS)++ @staticmethod+ def _origin_ca_service_key(zone):+ """The optional account-level Origin CA service key stored (Fernet) on the+ zone's DNS provider connection, or ``None`` (a suitably-scoped token also+ authenticates the Origin CA endpoints)."""+ try:+ from app.models.email import DNSProviderConfig+ from app.utils.crypto import decrypt_secret_safe+ cfg_id = getattr(zone, 'dns_provider_config_id', None)+ cfg = DNSProviderConfig.query.get(cfg_id) if cfg_id else None+ if cfg and getattr(cfg, 'origin_ca_key', None):+ return decrypt_secret_safe(cfg.origin_ca_key)+ except Exception:+ pass+ return None++ @staticmethod+ def _generate_csr(hostnames):+ """Generate an RSA private key + CSR for ``hostnames`` panel-side. Returns+ ``(csr_pem, key_pem)``; the key is kept locally for install and never sent+ to Cloudflare."""+ from cryptography import x509+ from cryptography.x509.oid import NameOID+ from cryptography.hazmat.primitives import hashes, serialization+ from cryptography.hazmat.primitives.asymmetric import rsa++ key = rsa.generate_private_key(public_exponent=65537, key_size=2048)+ builder = x509.CertificateSigningRequestBuilder().subject_name(+ x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, hostnames[0])]))+ builder = builder.add_extension(+ x509.SubjectAlternativeName([x509.DNSName(h) for h in hostnames]), critical=False)+ csr = builder.sign(key, hashes.SHA256())+ csr_pem = csr.public_bytes(serialization.Encoding.PEM).decode()+ key_pem = key.private_bytes(+ serialization.Encoding.PEM,+ serialization.PrivateFormat.TraditionalOpenSSL,+ serialization.NoEncryption()).decode()+ return csr_pem, key_pem++ @staticmethod+ def _proxy_warnings(zone, client, hostnames):+ """Best-effort: warn when a covered hostname isn't proxied (grey cloud) or+ has no DNS record — an Origin CA cert is only valid behind the proxy."""+ warnings = []+ try:+ rec = client.list_records(zone.provider_zone_id)+ records = (rec.get('records') or []) if rec.get('success') else []+ by_name = {}+ for r in records:+ by_name.setdefault((r.get('name') or '').lower().rstrip('.'), []).append(r)+ for h in hostnames:+ base = h[2:] if h.startswith('*.') else h+ matches = by_name.get(base, [])+ if not matches:+ warnings.append(+ f'{h}: no DNS record found — an Origin CA certificate is only '+ 'valid when traffic is proxied through Cloudflare.')+ elif not any(m.get('proxied') for m in matches):+ warnings.append(+ f'{h}: the DNS record is not proxied (grey cloud). This '+ 'certificate only works when traffic goes through Cloudflare.')+ except Exception:+ pass+ return warnings++ @staticmethod+ def _install_origin_cert(hostnames, cert_pem, key_pem):+ """Install the issued cert + panel-generated key via the existing custom-cert+ seam (writes PEMs to ``/etc/ssl/serverkit/<domain>/``, Linux-only)."""+ try:+ from app.services.advanced_ssl_service import AdvancedSSLService+ install_domain = next((h for h in hostnames if not h.startswith('*.')), None)+ if not install_domain:+ install_domain = hostnames[0][2:] if hostnames[0].startswith('*.') else hostnames[0]+ info = AdvancedSSLService.upload_custom_cert(install_domain, cert_pem, key_pem)+ return {'success': True, **info}+ except Exception as e:+ return {'success': False, 'error': str(e)}++ @classmethod+ def issue_origin_certificate(cls, zone_id, hostnames, validity_days=5475, install=True):+ """Issue an Origin CA certificate for ``hostnames`` and (optionally) install+ it on the origin. The private key is generated panel-side and never sent to+ Cloudflare."""+ zone, client = cls._zone_and_client(zone_id)+ hostnames = [h.strip().lower().rstrip('.') for h in (hostnames or []) if h and h.strip()]+ if not hostnames:+ raise CloudflareError('At least one hostname is required')+ if validity_days not in cls.ORIGIN_CA_VALIDITY_DAYS:+ raise CloudflareError(+ 'Unsupported validity — choose one of: '+ + ', '.join(str(v) for v in cls.ORIGIN_CA_VALIDITY_DAYS) + ' days')++ csr_pem, key_pem = cls._generate_csr(hostnames)+ res = client.create_origin_certificate(+ csr=csr_pem, hostnames=hostnames, requested_validity=validity_days,+ service_key=cls._origin_ca_service_key(zone))+ if not res.get('success'):+ err = res.get('error', 'Failed to issue Origin CA certificate')+ cls._record(zone, 'origin_ca', 'issue', hostnames[0], 'error', err)+ if cls._is_scope_error(err):+ raise CloudflareError(+ 'This Cloudflare credential lacks the Origin CA permission. Add the '+ '"SSL and Certificates: Edit" scope to the token, or set an Origin CA '+ f'key on the connection. ({err})')+ return {'success': False, 'error': err}++ result = res.get('result') or {}+ cert_pem = result.get('certificate')+ out = {+ 'success': True,+ 'certificate_id': result.get('id'),+ 'certificate': cert_pem,+ 'hostnames': hostnames,+ 'expires_on': result.get('expires_on'),+ 'proxy_only': True,+ 'warnings': cls._proxy_warnings(zone, client, hostnames),+ }+ if install and cert_pem and os.name != 'nt':+ out['install'] = cls._install_origin_cert(hostnames, cert_pem, key_pem)+ cls._record(zone, 'origin_ca', 'issue', hostnames[0])+ return out++ @classmethod+ def list_origin_certificates(cls, zone_id):+ zone, client = cls._zone_and_client(zone_id)+ res = client.list_origin_certificates(+ zone.provider_zone_id, service_key=cls._origin_ca_service_key(zone))+ if not res.get('success'):+ err = res.get('error', 'Failed to list Origin CA certificates')+ if cls._is_scope_error(err):+ raise CloudflareError(+ 'This Cloudflare credential lacks the Origin CA permission. Add the '+ f'"SSL and Certificates: Read" scope to the token. ({err})')+ return {'success': False, 'error': err}+ certs = [{+ 'id': c.get('id'),+ 'hostnames': c.get('hostnames'),+ 'expires_on': c.get('expires_on'),+ 'requested_validity': c.get('requested_validity'),+ 'certificate': c.get('certificate'),+ } for c in (res.get('result') or [])]+ return {'success': True, 'certificates': certs, 'proxy_only': True}++ @classmethod+ def revoke_origin_certificate(cls, zone_id, certificate_id):+ zone, client = cls._zone_and_client(zone_id)+ res = client.revoke_origin_certificate(+ certificate_id, service_key=cls._origin_ca_service_key(zone))+ if not res.get('success'):+ err = res.get('error', 'Failed to revoke certificate')+ cls._record(zone, 'origin_ca', 'revoke', certificate_id, 'error', err)+ if cls._is_scope_error(err):+ raise CloudflareError(+ 'This Cloudflare credential lacks the Origin CA permission. '+ f'({err})')+ return {'success': False, 'error': err}+ cls._record(zone, 'origin_ca', 'revoke', certificate_id)+ return {'success': True, 'certificate_id': certificate_id}++ # ── Redirect + Transform rules ────────────────────────────────────────────+ # The same ruleset machinery as WAF, in different phases, with per-phase action+ # allowlists + the shared expression-injection guard.++ RULE_PHASES = {+ 'redirect': 'http_request_dynamic_redirect',+ 'transform': 'http_request_transform',+ }+ RULE_ACTIONS = {+ 'redirect': {'redirect'},+ 'transform': {'rewrite'},+ }++ # Preset library per rule type (plan §Phase 3). Presets take no free-form user+ # input that lands in an expression — the only interpolated value is the zone's+ # own (validated) domain — so there is no injection surface.+ RULE_PRESETS = {+ 'redirect': [+ {'key': 'force_www', 'label': 'Redirect apex to www',+ 'description': 'Send https://example.com/* to https://www.example.com/*.',+ 'params': []},+ {'key': 'www_to_apex', 'label': 'Redirect www to apex',+ 'description': 'Send https://www.example.com/* to https://example.com/*.',+ 'params': []},+ {'key': 'strip_trailing_slash', 'label': 'Remove trailing slash',+ 'description': 'Redirect /path/ to /path (except the root).',+ 'params': []},+ ],+ 'transform': [+ {'key': 'strip_tracking', 'label': 'Strip tracking parameters',+ 'description': 'Remove utm_*, gclid and fbclid query parameters.',+ 'params': []},+ ],+ }++ _SAFE_HOST_RE = re.compile(r'^[a-z0-9.-]+$')++ @classmethod+ def _resolve_rule_phase(cls, slug):+ phase = cls.RULE_PHASES.get(slug)+ if not phase:+ raise CloudflareError(+ f'Unknown rule type "{slug}". Use one of: '+ + ', '.join(sorted(cls.RULE_PHASES)))+ return phase++ @classmethod+ def _validate_rule_action(cls, slug, action):+ allowed = cls.RULE_ACTIONS.get(slug, set())+ if action not in allowed:+ raise CloudflareError(+ f'Unsupported action "{action}" for {slug} rules. '+ f'Use one of: {", ".join(sorted(allowed))}')++ @staticmethod+ def _full_rule_dict(r):+ return {'id': r.get('id'), 'description': r.get('description'),+ 'expression': r.get('expression'), 'action': r.get('action'),+ 'action_parameters': r.get('action_parameters'),+ 'enabled': r.get('enabled', True), 'ref': r.get('ref')}++ @classmethod+ def list_rules(cls, zone_id, slug):+ """Rules for a phase (redirect|transform), plus the preset catalog. A zone+ with no ruleset in that phase yet returns an empty list (not an error)."""+ phase = cls._resolve_rule_phase(slug)+ zone, client = cls._zone_and_client(zone_id)+ custom, err = cls._find_custom_ruleset(client, zone.provider_zone_id, phase)+ if err:+ return {'success': False, 'error': err}+ presets = cls.RULE_PRESETS.get(slug, [])+ if not custom:+ return {'success': True, 'ruleset_id': None, 'rules': [], 'presets': presets}+ detail = client.get_ruleset(zone.provider_zone_id, custom['id'])+ if not detail.get('success'):+ return {'success': False, 'error': detail.get('error', 'Failed to load ruleset')}+ result = detail.get('result') or {}+ rules = [cls._full_rule_dict(r) for r in (result.get('rules') or [])]+ return {'success': True, 'ruleset_id': result.get('id'),+ 'rules': rules, 'presets': presets}++ @classmethod+ def add_rule(cls, zone_id, slug, *, description, expression, action,+ action_parameters=None, enabled=True):+ """Append a rule to the phase's entry-point ruleset, creating it on first use."""+ phase = cls._resolve_rule_phase(slug)+ cls._validate_rule_action(slug, action)+ if not (expression or '').strip():+ raise CloudflareError('A rule expression is required')+ zone, client = cls._zone_and_client(zone_id)+ rule = {'description': description or 'ServerKit rule', 'expression': expression,+ 'action': action, 'enabled': bool(enabled)}+ if action_parameters:+ rule['action_parameters'] = action_parameters++ custom, err = cls._find_custom_ruleset(client, zone.provider_zone_id, phase)+ if err:+ return {'success': False, 'error': err}+ if custom:+ res = client.add_ruleset_rule(zone.provider_zone_id, custom['id'], rule)+ else:+ res = client.create_phase_ruleset(zone.provider_zone_id, phase, [rule])+ if not res.get('success'):+ cls._record(zone, slug, 'add-rule', rule['description'], 'error', res.get('error'))+ return {'success': False, 'error': res.get('error', 'Failed to add rule')}+ cls._record(zone, slug, 'add-rule', rule['description'])+ return {'success': True, 'result': res.get('result')}++ @classmethod+ def _build_rule_preset(cls, slug, key, domain, params):+ """Turn a preset key + the zone domain into a concrete rule dict. The domain+ is validated before interpolation so a preset can't inject expression syntax."""+ domain = (domain or '').strip().lower().rstrip('.')+ if not cls._SAFE_HOST_RE.match(domain or ''):+ raise CloudflareError('The zone domain is not a valid hostname')+ if slug == 'redirect':+ if key == 'force_www':+ return {'description': 'ServerKit: redirect apex to www',+ 'expression': f'(http.host eq "{domain}")',+ 'action': 'redirect',+ 'action_parameters': {'from_value': {+ 'status_code': 301,+ 'target_url': {'expression':+ f'concat("https://www.{domain}", http.request.uri.path)'},+ 'preserve_query_string': True}}}+ if key == 'www_to_apex':+ return {'description': 'ServerKit: redirect www to apex',+ 'expression': f'(http.host eq "www.{domain}")',+ 'action': 'redirect',+ 'action_parameters': {'from_value': {+ 'status_code': 301,+ 'target_url': {'expression':+ f'concat("https://{domain}", http.request.uri.path)'},+ 'preserve_query_string': True}}}+ if key == 'strip_trailing_slash':+ return {'description': 'ServerKit: remove trailing slash',+ 'expression': ('(ends_with(http.request.uri.path, "/") and '+ 'http.request.uri.path ne "/")'),+ 'action': 'redirect',+ 'action_parameters': {'from_value': {+ 'status_code': 301,+ 'target_url': {'expression':+ 'concat("https://", http.host, '+ 'substring(http.request.uri.path, 0, -1))'},+ 'preserve_query_string': True}}}+ elif slug == 'transform':+ if key == 'strip_tracking':+ return {'description': 'ServerKit: strip tracking parameters',+ 'expression': '(http.request.uri.query ne "")',+ 'action': 'rewrite',+ 'action_parameters': {'uri': {'query': {'expression':+ 'regex_replace(http.request.uri.query, '+ '"(^|&)(utm_[a-z]+|gclid|fbclid)=[^&]*", "")'}}}}+ raise CloudflareError(f'Unknown {slug} preset: {key}')++ @classmethod+ def apply_rule_preset(cls, zone_id, slug, preset_key, params=None):+ cls._resolve_rule_phase(slug) # validates slug up front+ zone, _ = cls._zone_and_client(zone_id)+ rule = cls._build_rule_preset(slug, preset_key, zone.domain, params or {})+ return cls.add_rule(zone_id, slug, description=rule['description'],+ expression=rule['expression'], action=rule['action'],+ action_parameters=rule.get('action_parameters'))++ @classmethod+ def update_rule(cls, zone_id, slug, ruleset_id, rule_id, fields):+ cls._resolve_rule_phase(slug)+ zone, client = cls._zone_and_client(zone_id)+ rule = {}+ for k in ('description', 'expression', 'action', 'enabled', 'action_parameters'):+ if k in fields:+ rule[k] = fields[k]+ if 'action' in rule:+ cls._validate_rule_action(slug, rule['action'])+ if not rule:+ raise CloudflareError('No updatable fields provided')+ res = client.update_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id, rule)+ if not res.get('success'):+ cls._record(zone, slug, 'update-rule', rule_id, 'error', res.get('error'))+ return {'success': False, 'error': res.get('error', 'Failed to update rule')}+ cls._record(zone, slug, 'update-rule', rule_id)+ return {'success': True, 'result': res.get('result')}++ @classmethod+ def delete_rule(cls, zone_id, slug, ruleset_id, rule_id):+ cls._resolve_rule_phase(slug)+ zone, client = cls._zone_and_client(zone_id)+ res = client.delete_ruleset_rule(zone.provider_zone_id, ruleset_id, rule_id)+ if not res.get('success'):+ cls._record(zone, slug, 'delete-rule', rule_id, 'error', res.get('error'))+ return {'success': False, 'error': res.get('error', 'Failed to delete rule')}+ cls._record(zone, slug, 'delete-rule', rule_id)return {'success': True}++ # ── Activity (local ops ledger) ───────────────────────────────────────────++ @classmethod+ def list_activity(cls, zone_id, product=None, result=None, limit=100):+ """The per-zone Cloudflare-ops change ledger, newest first."""+ zone, _ = cls._zone_and_client(zone_id)+ from app.services.cf_ops_change_service import CfOpsChangeService+ rows = CfOpsChangeService.list(+ provider_zone_id=zone.provider_zone_id,+ product=product, result=result, limit=limit)+ return {'success': True, 'zone': cls._zone_dict(zone),+ 'changes': [r.to_dict() for r in rows]}++ # ── Token scope diagnosability ────────────────────────────────────────────++ @classmethod+ def scope_check(cls, zone_id):+ """Probe each product with a cheap read and report+ ``{product: ok|missing_scope|error}`` — round 2 is exactly where DNS-only+ tokens start failing."""+ zone, client = cls._zone_and_client(zone_id)++ def classify(res):+ if res.get('success'):+ return 'ok'+ return 'missing_scope' if cls._is_scope_error(res.get('error')) else 'error'++ products = {+ 'dns': classify(client.list_records(zone.provider_zone_id)),+ 'settings': classify(client.get_zone_settings(zone.provider_zone_id)),+ 'dnssec': classify(client.get_dnssec(zone.provider_zone_id)),+ 'waf': classify(client.list_rulesets(zone.provider_zone_id)),+ 'origin_ca': classify(client.list_origin_certificates(+ zone.provider_zone_id, service_key=cls._origin_ca_service_key(zone))),+ }+ try:+ account_id = cls._account_id(zone, client)+ except CloudflareError:+ account_id = None+ if account_id:+ products['workers'] = classify(client.list_worker_scripts(account_id))+ products['tunnels'] = classify(client.list_tunnels(account_id))+ products['storage'] = classify(client.list_r2_buckets(account_id))+ else:+ products['workers'] = products['tunnels'] = products['storage'] = 'missing_scope'+ return {'success': True, 'zone': cls._zone_dict(zone), 'products': products}