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): Workers edge hosting (Phase 4)
Juan Denis02774f741e5f
diff --git a/backend/app/api/cloudflare.py b/backend/app/api/cloudflare.pyindex e3e6828a..9ddf09a0 100644--- a/backend/app/api/cloudflare.py+++ b/backend/app/api/cloudflare.py@@ -168,3 +168,72 @@ def delete_waf_rule(zone_id, ruleset_id, rule_id):except CloudflareError as e:return jsonify({'error': str(e)}), 400return _service_response(res)+++# ── Workers (edge hosting) ───────────────────────────────────────────────────++@cloudflare_bp.route('/zones/<int:zone_id>/workers', methods=['GET'])+@jwt_required()+def list_workers(zone_id):+ try:+ res = CloudflareService.list_workers(zone_id)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/workers', methods=['POST'])+@jwt_required()+def deploy_worker(zone_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json(silent=True) or {}+ try:+ res = CloudflareService.deploy_worker(+ zone_id,+ name=data.get('name'),+ code=data.get('code'),+ compatibility_date=data.get('compatibility_date'),+ route_pattern=data.get('route_pattern'))+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/workers/routes', methods=['POST'])+@jwt_required()+def add_worker_route(zone_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ data = request.get_json(silent=True) or {}+ try:+ res = CloudflareService.add_worker_route(zone_id, data.get('pattern'), data.get('script'))+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++@cloudflare_bp.route('/zones/<int:zone_id>/workers/routes/<route_id>', methods=['DELETE'])+@jwt_required()+def delete_worker_route(zone_id, route_id):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ try:+ res = CloudflareService.delete_worker_route(zone_id, route_id)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)+++# Note: this dynamic <name> route is registered last so it can't shadow the more+# specific /workers/routes paths above.+@cloudflare_bp.route('/zones/<int:zone_id>/workers/<name>', methods=['DELETE'])+@jwt_required()+def delete_worker(zone_id, name):+ if not _require_admin():+ return jsonify({'error': 'Admin access required'}), 403+ try:+ res = CloudflareService.delete_worker(zone_id, name)+ except CloudflareError as e:+ return jsonify({'error': str(e)}), 400+ return _service_response(res)diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex 2c881cd2..d4a27a27 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -44,6 +44,7 @@ from app.models.passkey import PasskeyCredentialfrom app.models.secret_vault import SecretVault, Secretfrom app.models.webhook_gateway import WebhookEndpoint, WebhookDeliveryfrom app.models.waf_policy import WafPolicy+from app.models.cloudflare_worker import CloudflareWorkerfrom app.models.backup_policy import BackupPolicyfrom app.models.backup_run import BackupRunfrom app.queue_bus.models import QueueGroup, Queue, QueueMessage@@ -78,6 +79,7 @@ __all__ = ['SecretVault', 'Secret','WebhookEndpoint', 'WebhookDelivery','WafPolicy',+ 'CloudflareWorker','BackupPolicy', 'BackupRun','QueueGroup', 'Queue', 'QueueMessage','Notification', 'NotificationDelivery',diff --git a/backend/app/models/cloudflare_worker.py b/backend/app/models/cloudflare_worker.pynew file mode 100644index 00000000..8558edcc--- /dev/null+++ b/backend/app/models/cloudflare_worker.py@@ -0,0 +1,41 @@+from datetime import datetime+from app import db+++class CloudflareWorker(db.Model):+ """A Cloudflare Worker (edge script) ServerKit uploaded.++ Cloudflare is the source of truth for what's deployed; this table records the+ source we pushed (so it can be viewed and re-deployed) and which connection it+ belongs to. Keyed by ``(account_id, name)`` — a script name is unique per+ account.+ """+ __tablename__ = 'cloudflare_workers'+ __table_args__ = (+ db.UniqueConstraint('account_id', 'name', name='uq_cf_worker_account_name'),+ )++ id = db.Column(db.Integer, primary_key=True)+ name = db.Column(db.String(128), nullable=False, index=True) # script name+ account_id = db.Column(db.String(64), nullable=False)+ dns_provider_config_id = db.Column(+ db.Integer, db.ForeignKey('dns_provider_configs.id'), nullable=True)+ source = db.Column(db.Text) # JS module we uploaded+ compatibility_date = db.Column(db.String(20))++ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ def to_dict(self, include_source=False):+ d = {+ 'id': self.id,+ 'name': self.name,+ 'account_id': self.account_id,+ 'dns_provider_config_id': self.dns_provider_config_id,+ 'compatibility_date': self.compatibility_date,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,+ }+ if include_source:+ d['source'] = self.source+ return ddiff --git a/backend/app/services/cloudflare_service.py b/backend/app/services/cloudflare_service.pyindex 8b7d1449..2bc33c33 100644--- a/backend/app/services/cloudflare_service.py+++ b/backend/app/services/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 relogger = logging.getLogger(__name__)@@ -421,3 +422,119 @@ class CloudflareService:if not res.get('success'):return {'success': False, 'error': res.get('error', 'Failed to delete rule')}return {'success': True}++ # ── Workers (edge hosting) ───────────────────────────────────────────────+ # Workers are account-scoped; the owning account is read from the zone, so the+ # whole feature reuses the same Cloudflare connection the DNS zone already has.++ WORKER_NAME_RE = re.compile(r'^[a-z0-9][a-z0-9_-]{0,62}$')+ DEFAULT_COMPAT_DATE = '2025-01-01'++ @classmethod+ def _account_id(cls, zone, client):+ """The Cloudflare account that owns ``zone`` (for account-scoped resources)."""+ res = client.get_zone_account_id(zone.provider_zone_id)+ if not res.get('success'):+ raise CloudflareError(+ res.get('error') or 'Could not resolve the Cloudflare account for this zone')+ acct = ((res.get('result') or {}).get('account') or {}).get('id')+ if not acct:+ raise CloudflareError('Cloudflare did not return an account for this zone')+ return acct++ @classmethod+ def list_workers(cls, zone_id):+ """Live Worker scripts in the zone's account (flagged when ServerKit manages+ them), plus the zone's Worker routes."""+ from app.models.cloudflare_worker import CloudflareWorker+ zone, client = cls._zone_and_client(zone_id)+ account_id = cls._account_id(zone, client)+ res = client.list_worker_scripts(account_id)+ if not res.get('success'):+ return {'success': False, 'error': res.get('error', 'Failed to list workers')}+ managed = {w.name: w for w in+ CloudflareWorker.query.filter_by(account_id=account_id).all()}+ scripts = []+ for s in (res.get('result') or []):+ name = s.get('id') # Cloudflare returns the script name in `id`+ rec = managed.get(name)+ scripts.append({'name': name, 'created_on': s.get('created_on'),+ 'modified_on': s.get('modified_on'),+ 'managed': rec is not None,+ 'has_source': bool(rec and rec.source)})+ routes = []+ rres = client.list_worker_routes(zone.provider_zone_id)+ if rres.get('success'):+ routes = [{'id': r.get('id'), 'pattern': r.get('pattern'), 'script': r.get('script')}+ for r in (rres.get('result') or [])]+ return {'success': True, 'account_id': account_id, 'workers': scripts, 'routes': routes}++ @classmethod+ def deploy_worker(cls, zone_id, *, name, code, compatibility_date=None, route_pattern=None):+ """Upload a module Worker, record the source locally, and optionally attach a+ route in this zone."""+ from app import db+ from app.models.cloudflare_worker import CloudflareWorker++ name = (name or '').strip().lower()+ if not cls.WORKER_NAME_RE.match(name):+ raise CloudflareError('Worker name must be 1–63 chars: lowercase letters, '+ 'digits, hyphens or underscores, starting alphanumeric')+ if not (code or '').strip():+ raise CloudflareError('Worker code is required')+ compat = compatibility_date or cls.DEFAULT_COMPAT_DATE++ zone, client = cls._zone_and_client(zone_id)+ account_id = cls._account_id(zone, client)+ res = client.upload_worker_module(account_id, name, code, compat)+ if not res.get('success'):+ return {'success': False, 'error': res.get('error', 'Worker upload failed')}++ rec = CloudflareWorker.query.filter_by(account_id=account_id, name=name).first()+ if not rec:+ rec = CloudflareWorker(account_id=account_id, name=name,+ dns_provider_config_id=zone.dns_provider_config_id)+ db.session.add(rec)+ rec.source = code+ rec.compatibility_date = compat+ db.session.commit()++ route = None+ if route_pattern and route_pattern.strip():+ 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')}+ return {'success': True, 'worker': rec.to_dict(), 'route': route}++ @classmethod+ def delete_worker(cls, zone_id, name):+ from app import db+ from app.models.cloudflare_worker import CloudflareWorker+ zone, client = cls._zone_and_client(zone_id)+ account_id = cls._account_id(zone, client)+ res = client.delete_worker_script(account_id, name)+ if not res.get('success'):+ 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()+ return {'success': True}++ @classmethod+ def add_worker_route(cls, zone_id, pattern, script):+ if not (pattern or '').strip() or not (script or '').strip():+ raise CloudflareError('Both a route pattern and a worker name are required')+ 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'):+ return {'success': False, 'error': res.get('error', 'Failed to add route')}+ return {'success': True, 'result': res.get('result')}++ @classmethod+ def delete_worker_route(cls, zone_id, route_id):+ zone, client = cls._zone_and_client(zone_id)+ res = client.delete_worker_route(zone.provider_zone_id, route_id)+ if not res.get('success'):+ return {'success': False, 'error': res.get('error', 'Failed to delete route')}+ return {'success': True}diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.pyindex dfd587d1..20f0b866 100644--- a/backend/app/services/dns/cloudflare.py+++ b/backend/app/services/dns/cloudflare.py@@ -13,6 +13,7 @@ Centralizes, in one place:Both ``DNSProviderService`` (provider layer) and ``DNSZoneService`` (zone layer)delegate here, so a wire-format fix is made once rather than twice."""+import jsonimport loggingimport requests@@ -293,3 +294,59 @@ class CloudflareClient:def delete_ruleset_rule(self, zone_id: str, ruleset_id: str, rule_id: str) -> dict:return self.request('DELETE',f'/zones/{zone_id}/rulesets/{ruleset_id}/rules/{rule_id}')++ # ── Workers (edge scripts) ────────────────────────────────────────────────+ # Workers/R2/Tunnels are account-scoped; the owning account is read from the+ # zone. Script upload uses the stable multipart PUT /scripts/{name} (module+ # syntax) rather than the still-beta resource-oriented Workers API.+ def _auth_only_headers(self) -> dict:+ """Auth headers WITHOUT ``Content-Type`` — for multipart uploads where+ ``requests`` must set the multipart boundary itself."""+ if self.cred.email:+ return {'X-Auth-Email': self.cred.email, 'X-Auth-Key': self.cred.token or ''}+ return {'Authorization': f'Bearer {self.cred.token or ""}'}++ def get_zone_account_id(self, zone_id: str) -> dict:+ """Zone details — used to read the owning ``account.id``."""+ return self.request('GET', f'/zones/{zone_id}')++ def list_worker_scripts(self, account_id: str) -> dict:+ return self.request('GET', f'/accounts/{account_id}/workers/scripts')++ def upload_worker_module(self, account_id: str, name: str, code: str,+ compatibility_date: str, main: str = 'worker.js') -> dict:+ """Create/overwrite a module-syntax Worker via the stable multipart+ ``PUT /accounts/{id}/workers/scripts/{name}`` endpoint."""+ url = f'{API_BASE}/accounts/{account_id}/workers/scripts/{name}'+ metadata = {'main_module': main, 'compatibility_date': compatibility_date}+ files = {+ 'metadata': (None, json.dumps(metadata), 'application/json'),+ main: (main, code, 'application/javascript+module'),+ }+ try:+ resp = requests.put(url, headers=self._auth_only_headers(), files=files, timeout=30)+ try:+ data = resp.json()+ except ValueError:+ return {'success': False,+ 'error': f'HTTP {resp.status_code}: non-JSON response from Cloudflare'}+ if not isinstance(data, dict):+ return {'success': False, 'error': 'Unexpected Cloudflare response'}+ if not data.get('success') and not data.get('error'):+ data['error'] = _first_error(data)+ return data+ except Exception as e:+ return {'success': False, 'error': str(e)}++ def delete_worker_script(self, account_id: str, name: str) -> dict:+ return self.request('DELETE', f'/accounts/{account_id}/workers/scripts/{name}')++ def list_worker_routes(self, zone_id: str) -> dict:+ return self.request('GET', f'/zones/{zone_id}/workers/routes')++ def add_worker_route(self, zone_id: str, pattern: str, script: str) -> dict:+ return self.request('POST', f'/zones/{zone_id}/workers/routes',+ json={'pattern': pattern, 'script': script})++ def delete_worker_route(self, zone_id: str, route_id: str) -> dict:+ return self.request('DELETE', f'/zones/{zone_id}/workers/routes/{route_id}')diff --git a/backend/tests/test_cloudflare_zone_settings.py b/backend/tests/test_cloudflare_zone_settings.pyindex 57d7ae23..924676c1 100644--- a/backend/tests/test_cloudflare_zone_settings.py+++ b/backend/tests/test_cloudflare_zone_settings.py@@ -366,3 +366,106 @@ def test_waf_delete_calls_delete(app, monkeypatch):res = CloudflareService.delete_waf_rule(zone.id, 'rs1', 'r1')assert res['success'] is Trueassert deleted['url'].endswith('/rulesets/rs1/rules/r1')+++# ── Workers (Phase 4) ────────────────────────────────────────────────────────++def test_upload_worker_module_is_multipart(monkeypatch):+ import json as _json+ from app.services.dns import cloudflare as cf+ seen = {}++ def put(url, headers=None, files=None, timeout=None):+ seen.update(url=url, headers=headers, files=files)+ return _Resp({'success': True, 'result': {'id': 'w'}})+ monkeypatch.setattr(cf.requests, 'put', put)+ res = _client().upload_worker_module('acct1', 'w', 'CODE', '2025-01-01')+ assert res['success'] is True+ assert seen['url'].endswith('/accounts/acct1/workers/scripts/w')+ # multipart upload must NOT carry a JSON Content-Type (requests sets the boundary)+ assert 'Content-Type' not in seen['headers']+ meta = _json.loads(seen['files']['metadata'][1])+ assert meta['main_module'] == 'worker.js' and meta['compatibility_date'] == '2025-01-01'+ assert 'worker.js' in seen['files']+++def test_deploy_worker_validates_name(app):+ from app.services.cloudflare_service import CloudflareService, CloudflareError+ zone = _make_cf_zone()+ with pytest.raises(CloudflareError):+ CloudflareService.deploy_worker(zone.id, name='Bad Name!', code='x')+++def test_deploy_worker_records_source(app, monkeypatch):+ from app.services.dns import cloudflare as cf+ from app.services.cloudflare_service import CloudflareService+ from app.models.cloudflare_worker import CloudflareWorker+ zone = _make_cf_zone()++ def req(method, url, headers=None, json=None, params=None, timeout=None):+ if method == 'GET' and url.endswith('/zones/zoneABC'):+ return _Resp({'success': True, 'result': {'account': {'id': 'acct1'}}})+ return _Resp({'success': False})++ def put(url, headers=None, files=None, timeout=None):+ return _Resp({'success': True, 'result': {'id': 'my-worker'}})+ monkeypatch.setattr(cf.requests, 'request', req)+ monkeypatch.setattr(cf.requests, 'put', put)++ res = CloudflareService.deploy_worker(zone.id, name='My-Worker', code='export default {}')+ assert res['success'] is True+ assert res['worker']['name'] == 'my-worker' # lowercased+ rec = CloudflareWorker.query.filter_by(account_id='acct1', name='my-worker').first()+ assert rec is not None and rec.source == 'export default {}'+++def test_list_workers_flags_managed(app, monkeypatch):+ from app import db+ from app.services.dns import cloudflare as cf+ from app.services.cloudflare_service import CloudflareService+ from app.models.cloudflare_worker import CloudflareWorker+ zone = _make_cf_zone()+ db.session.add(CloudflareWorker(account_id='acct1', name='managed-one', source='x'))+ db.session.commit()++ def req(method, url, headers=None, json=None, params=None, timeout=None):+ if url.endswith('/zones/zoneABC'):+ return _Resp({'success': True, 'result': {'account': {'id': 'acct1'}}})+ if url.endswith('/accounts/acct1/workers/scripts'):+ return _Resp({'success': True, 'result': [+ {'id': 'managed-one', 'modified_on': '2026-01-01'},+ {'id': 'foreign', 'modified_on': '2026-01-02'}]})+ if url.endswith('/zones/zoneABC/workers/routes'):+ return _Resp({'success': True, 'result': [+ {'id': 'rt1', 'pattern': 'example.com/*', 'script': 'managed-one'}]})+ return _Resp({'success': False})+ monkeypatch.setattr(cf.requests, 'request', req)++ res = CloudflareService.list_workers(zone.id)+ assert res['account_id'] == 'acct1'+ by_name = {w['name']: w for w in res['workers']}+ assert by_name['managed-one']['managed'] is True+ assert by_name['foreign']['managed'] is False+ assert res['routes'][0]['pattern'] == 'example.com/*'+++def test_delete_worker_removes_local_row(app, monkeypatch):+ from app import db+ from app.services.dns import cloudflare as cf+ from app.services.cloudflare_service import CloudflareService+ from app.models.cloudflare_worker import CloudflareWorker+ zone = _make_cf_zone()+ db.session.add(CloudflareWorker(account_id='acct1', name='gone', source='x'))+ db.session.commit()++ def req(method, url, headers=None, json=None, params=None, timeout=None):+ if url.endswith('/zones/zoneABC'):+ return _Resp({'success': True, 'result': {'account': {'id': 'acct1'}}})+ if method == 'DELETE' and url.endswith('/accounts/acct1/workers/scripts/gone'):+ return _Resp({'success': True})+ return _Resp({'success': False})+ monkeypatch.setattr(cf.requests, 'request', req)++ res = CloudflareService.delete_worker(zone.id, 'gone')+ assert res['success'] is True+ assert CloudflareWorker.query.filter_by(account_id='acct1', name='gone').first() is Nonediff --git a/frontend/src/components/cloudflare/WorkersPanel.jsx b/frontend/src/components/cloudflare/WorkersPanel.jsxnew file mode 100644index 00000000..6612b49c--- /dev/null+++ b/frontend/src/components/cloudflare/WorkersPanel.jsx@@ -0,0 +1,256 @@+import { useState, useEffect, useCallback } from 'react';+import { Zap } from 'lucide-react';+import { Button } from '@/components/ui/button';+import { Input } from '@/components/ui/input';+import { Textarea } from '@/components/ui/textarea';+import { Badge } from '@/components/ui/badge';+import EmptyState from '../EmptyState';+import { useToast } from '../../contexts/ToastContext';+import api from '../../services/api';++const STARTER_SCRIPT = `export default {+ async fetch(request, env, ctx) {+ return new Response("Hello from ServerKit + Cloudflare Workers!", {+ headers: { "content-type": "text/plain" },+ });+ },+};`;++export default function WorkersPanel({ zoneId, isAdmin }) {+ const toast = useToast();++ const [loading, setLoading] = useState(true);+ const [error, setError] = useState(null);+ const [workers, setWorkers] = useState([]);+ const [routes, setRoutes] = useState([]);++ // Deploy form state+ const [name, setName] = useState('');+ const [code, setCode] = useState(STARTER_SCRIPT);+ const [routePattern, setRoutePattern] = useState('');++ // Tracks any in-flight write so buttons can disable+ const [deploying, setDeploying] = useState(false);+ const [working, setWorking] = useState(false);++ const loadData = useCallback(async () => {+ try {+ const data = await api.getCloudflareWorkers(zoneId);+ setWorkers(data.workers || []);+ setRoutes(data.routes || []);+ setError(null);+ } catch (err) {+ setError(err.message);+ }+ }, [zoneId]);++ useEffect(() => {+ let active = true;+ setLoading(true);+ (async () => {+ try {+ const data = await api.getCloudflareWorkers(zoneId);+ if (!active) return;+ setWorkers(data.workers || []);+ setRoutes(data.routes || []);+ setError(null);+ } catch (err) {+ if (active) setError(err.message);+ } finally {+ if (active) setLoading(false);+ }+ })();+ return () => {+ active = false;+ };+ }, [zoneId]);++ const handleDeploy = async () => {+ setDeploying(true);+ try {+ const res = await api.deployCloudflareWorker(zoneId, {+ name,+ code,+ route_pattern: routePattern || undefined,+ });+ toast.success(`Deployed worker "${name}"`);+ if (res.route && !res.route.success) {+ toast.error('Worker deployed, but the route failed: ' + res.route.error);+ }+ setName('');+ setRoutePattern('');+ await loadData();+ } catch (err) {+ toast.error(err.message);+ } finally {+ setDeploying(false);+ }+ };++ const handleDeleteWorker = async (worker) => {+ setWorking(true);+ try {+ await api.deleteCloudflareWorker(zoneId, worker.name);+ await loadData();+ toast.success(`Deleted worker "${worker.name}"`);+ } catch (err) {+ toast.error(err.message);+ } finally {+ setWorking(false);+ }+ };++ const handleDeleteRoute = async (route) => {+ setWorking(true);+ try {+ await api.deleteCloudflareWorkerRoute(zoneId, route.id);+ await loadData();+ toast.success('Route removed');+ } catch (err) {+ toast.error(err.message);+ } finally {+ setWorking(false);+ }+ };++ if (loading) {+ return <div className="cf-workers__loading">Loading workers…</div>;+ }++ if (error) {+ return (+ <EmptyState+ icon={Zap}+ title="Workers unavailable"+ description={error}+ />+ );+ }++ const writeDisabled = !isAdmin || working;+ const deployDisabled = !isAdmin || deploying || !name.trim() || !code.trim();++ return (+ <div className="cf-workers">+ {/* Deploy a Worker */}+ <section className="cf-workers__section">+ <h3 className="cf-workers__heading">Deploy a Worker</h3>++ <div className="cf-workers__field">+ <label className="cf-workers__label">Name</label>+ <Input+ value={name}+ placeholder="my-worker"+ onChange={(e) => setName(e.target.value)}+ disabled={!isAdmin || deploying}+ />+ </div>++ <div className="cf-workers__field">+ <label className="cf-workers__label">Code</label>+ <Textarea+ rows={8}+ className="cf-workers__code"+ value={code}+ onChange={(e) => setCode(e.target.value)}+ disabled={!isAdmin || deploying}+ />+ </div>++ <div className="cf-workers__field">+ <label className="cf-workers__label">Route pattern (optional)</label>+ <Input+ value={routePattern}+ placeholder="example.com/*"+ onChange={(e) => setRoutePattern(e.target.value)}+ disabled={!isAdmin || deploying}+ />+ <p className="cf-workers__hint">+ Attaches the worker to this domain so matching traffic runs the script.+ </p>+ </div>++ <div className="cf-workers__actions">+ <Button onClick={handleDeploy} disabled={deployDisabled}>+ Deploy+ </Button>+ </div>+ </section>++ {/* Deployed workers */}+ <section className="cf-workers__section">+ <h3 className="cf-workers__heading">Workers ({workers.length})</h3>++ {workers.length === 0 ? (+ <EmptyState+ icon={Zap}+ title="No Workers deployed"+ description="Deploy your first edge script above."+ />+ ) : (+ <ul className="cf-workers__list">+ {workers.map((worker) => (+ <li className="cf-workers__item" key={worker.name}>+ <div className="cf-workers__name">+ <code>{worker.name}</code>+ {worker.managed && (+ <Badge variant="secondary">ServerKit</Badge>+ )}+ {worker.modified_on && (+ <span className="cf-workers__meta">+ {new Date(worker.modified_on).toLocaleString()}+ </span>+ )}+ </div>++ <div className="cf-workers__item-actions">+ <Button+ variant="destructive"+ size="sm"+ onClick={() => handleDeleteWorker(worker)}+ disabled={writeDisabled}+ >+ Delete+ </Button>+ </div>+ </li>+ ))}+ </ul>+ )}+ </section>++ {/* Routes */}+ <section className="cf-workers__section">+ <h3 className="cf-workers__heading">Routes ({routes.length})</h3>++ {routes.length === 0 ? (+ <p className="cf-workers__hint">+ No routes yet. Add a route pattern when deploying to send traffic to a worker.+ </p>+ ) : (+ <ul className="cf-workers__list">+ {routes.map((route) => (+ <li className="cf-workers__item" key={route.id}>+ <div className="cf-workers__name">+ <code>{route.pattern}</code>+ <span className="cf-workers__meta">→ {route.script}</span>+ </div>++ <div className="cf-workers__item-actions">+ <Button+ variant="destructive"+ size="sm"+ onClick={() => handleDeleteRoute(route)}+ disabled={writeDisabled}+ >+ Remove+ </Button>+ </div>+ </li>+ ))}+ </ul>+ )}+ </section>+ </div>+ );+}diff --git a/frontend/src/pages/CloudflareZoneSettings.jsx b/frontend/src/pages/CloudflareZoneSettings.jsxindex 4a3c08c6..c57e5249 100644--- a/frontend/src/pages/CloudflareZoneSettings.jsx+++ b/frontend/src/pages/CloudflareZoneSettings.jsx@@ -1,8 +1,9 @@import { useState, useEffect, useCallback } from 'react';import { useParams, Link } from 'react-router-dom';-import { Cloud, ShieldCheck, Lock, Gauge, Database, Wand2, Eraser, Flame } from 'lucide-react';+import { Cloud, ShieldCheck, Lock, Gauge, Database, Wand2, Eraser, Flame, Zap } from 'lucide-react';import { PageTopbar } from '@/components/ds';import WafPanel from '../components/cloudflare/WafPanel';+import WorkersPanel from '../components/cloudflare/WorkersPanel';import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';import { Switch } from '@/components/ui/switch';import { Button } from '@/components/ui/button';@@ -187,6 +188,7 @@ const CloudflareZoneSettings = () => {</TabsTrigger>))}<TabsTrigger value="waf"><Flame size={15} />WAF</TabsTrigger>+ <TabsTrigger value="workers"><Zap size={15} />Workers</TabsTrigger><TabsTrigger value="actions"><Wand2 size={15} />Actions</TabsTrigger></TabsList>@@ -213,6 +215,12 @@ const CloudflareZoneSettings = () => {</div></TabsContent>+ <TabsContent value="workers">+ <div className="cf-panel">+ <WorkersPanel zoneId={zoneId} isAdmin={isAdmin} />+ </div>+ </TabsContent>+<TabsContent value="actions"><div className="cf-panel cf-actions"><div className="cf-action">diff --git a/frontend/src/services/api/cloudflare.js b/frontend/src/services/api/cloudflare.jsindex da72e209..45850ede 100644--- a/frontend/src/services/api/cloudflare.js+++ b/frontend/src/services/api/cloudflare.js@@ -63,3 +63,34 @@ export async function deleteCloudflareWafRule(zoneId, rulesetId, ruleId) {method: 'DELETE',});}++// Workers (edge hosting). Account is resolved from the zone server-side.+export async function getCloudflareWorkers(zoneId) {+ return this.request(`/cloudflare/zones/${zoneId}/workers`);+}++export async function deployCloudflareWorker(zoneId, payload) {+ return this.request(`/cloudflare/zones/${zoneId}/workers`, {+ method: 'POST',+ body: payload,+ });+}++export async function deleteCloudflareWorker(zoneId, name) {+ return this.request(`/cloudflare/zones/${zoneId}/workers/${encodeURIComponent(name)}`, {+ method: 'DELETE',+ });+}++export async function addCloudflareWorkerRoute(zoneId, pattern, script) {+ return this.request(`/cloudflare/zones/${zoneId}/workers/routes`, {+ method: 'POST',+ body: { pattern, script },+ });+}++export async function deleteCloudflareWorkerRoute(zoneId, routeId) {+ return this.request(`/cloudflare/zones/${zoneId}/workers/routes/${routeId}`, {+ method: 'DELETE',+ });+}diff --git a/frontend/src/styles/pages/_cloudflare-zone.scss b/frontend/src/styles/pages/_cloudflare-zone.scssindex 3b473e16..848d0c01 100644--- a/frontend/src/styles/pages/_cloudflare-zone.scss+++ b/frontend/src/styles/pages/_cloudflare-zone.scss@@ -272,3 +272,93 @@flex-shrink: 0;}}++// Workers tab — deploy form + script/route lists.+.cf-workers {+ &__loading {+ padding: $spacing-lg;+ color: $text-muted;+ }++ &__section {+ padding: $spacing-md 0;+ border-bottom: 1px solid $border-color;++ &:last-child { border-bottom: none; }+ }++ &__heading {+ margin: 0 0 $spacing-sm;+ font-size: 0.95rem;+ }++ &__hint {+ margin: $spacing-xs 0 0;+ color: $text-muted;+ font-size: 0.82rem;+ }++ &__field {+ margin-bottom: $spacing-sm;+ }++ &__label {+ display: block;+ font-size: 0.82rem;+ color: $text-secondary;+ margin-bottom: 4px;+ }++ &__code {+ font-family: $font-mono;+ font-size: 0.82rem;+ }++ &__actions {+ display: flex;+ justify-content: flex-end;+ }++ &__list {+ list-style: none;+ margin: $spacing-sm 0 0;+ padding: 0;+ display: flex;+ flex-direction: column;+ gap: $spacing-xs;+ }++ &__item {+ display: flex;+ align-items: center;+ justify-content: space-between;+ gap: $spacing-md;+ padding: $spacing-sm $spacing-md;+ background: $bg-elevated;+ border: 1px solid $border-color;+ border-radius: $radius-md;+ }++ &__name {+ display: flex;+ align-items: center;+ gap: $spacing-sm;+ min-width: 0;+ flex-wrap: wrap;++ code {+ font-family: $font-mono;+ font-size: 0.85rem;+ color: $text-primary;+ }+ }++ &__meta {+ color: $text-muted;+ font-size: 0.8rem;+ }++ &__item-actions {+ flex-shrink: 0;+ }+}