Skip to content

ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.

feat(cloudflare): Workers edge hosting (Phase 4)

Juan Denis02774f741e5f
diff --git a/backend/app/api/cloudflare.py b/backend/app/api/cloudflare.py
index 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)}), 400
return _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__.py
index 2c881cd2..d4a27a27 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -44,6 +44,7 @@ from app.models.passkey import PasskeyCredential
from app.models.secret_vault import SecretVault, Secret
from app.models.webhook_gateway import WebhookEndpoint, WebhookDelivery
from app.models.waf_policy import WafPolicy
+from app.models.cloudflare_worker import CloudflareWorker
from app.models.backup_policy import BackupPolicy
from app.models.backup_run import BackupRun
from 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.py
new file mode 100644
index 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 d
diff --git a/backend/app/services/cloudflare_service.py b/backend/app/services/cloudflare_service.py
index 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-side
via :meth:`DNSZoneService._resolve_credential`, the canonical resolver.
"""
import logging
+import re
logger = 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.py
index 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 json
import logging
import 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.py
index 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 True
assert 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 None
diff --git a/frontend/src/components/cloudflare/WorkersPanel.jsx b/frontend/src/components/cloudflare/WorkersPanel.jsx
new file mode 100644
index 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">&rarr; {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.jsx
index 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.js
index 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.scss
index 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;
+ }
+}