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): R2 / KV / D1 developer platform (Phase 6)

Juan Denis5836294c4d7e
diff --git a/backend/app/api/cloudflare.py b/backend/app/api/cloudflare.py
index d16925ea..eb4d498e 100644
--- a/backend/app/api/cloudflare.py
+++ b/backend/app/api/cloudflare.py
@@ -323,3 +323,90 @@ def delete_tunnel(zone_id, tunnel_id):
except CloudflareError as e:
return jsonify({'error': str(e)}), 400
return _service_response(res)
+
+
+# ── Developer platform: R2 / KV / D1 ─────────────────────────────────────────
+
+@cloudflare_bp.route('/zones/<int:zone_id>/storage', methods=['GET'])
+@jwt_required()
+def list_storage(zone_id):
+ try:
+ res = CloudflareService.list_storage(zone_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/storage/r2', methods=['POST'])
+@jwt_required()
+def create_r2_bucket(zone_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.create_r2_bucket(zone_id, data.get('name'))
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/storage/r2/<bucket>', methods=['DELETE'])
+@jwt_required()
+def delete_r2_bucket(zone_id, bucket):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ try:
+ res = CloudflareService.delete_r2_bucket(zone_id, bucket)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/storage/kv', methods=['POST'])
+@jwt_required()
+def create_kv_namespace(zone_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.create_kv_namespace(zone_id, data.get('title'))
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/storage/kv/<namespace_id>', methods=['DELETE'])
+@jwt_required()
+def delete_kv_namespace(zone_id, namespace_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ try:
+ res = CloudflareService.delete_kv_namespace(zone_id, namespace_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/storage/d1', methods=['POST'])
+@jwt_required()
+def create_d1_database(zone_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ data = request.get_json(silent=True) or {}
+ try:
+ res = CloudflareService.create_d1_database(zone_id, data.get('name'))
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
+
+
+@cloudflare_bp.route('/zones/<int:zone_id>/storage/d1/<database_id>', methods=['DELETE'])
+@jwt_required()
+def delete_d1_database(zone_id, database_id):
+ if not _require_admin():
+ return jsonify({'error': 'Admin access required'}), 403
+ try:
+ res = CloudflareService.delete_d1_database(zone_id, database_id)
+ except CloudflareError as e:
+ return jsonify({'error': str(e)}), 400
+ return _service_response(res)
diff --git a/backend/app/services/cloudflare_service.py b/backend/app/services/cloudflare_service.py
index 70d52200..13e0c59e 100644
--- a/backend/app/services/cloudflare_service.py
+++ b/backend/app/services/cloudflare_service.py
@@ -702,3 +702,107 @@ class CloudflareService:
'error': None if res.get('success') else res.get('error')}
except Exception as e:
return {'created': False, 'error': str(e)}
+
+ # ── Developer platform: R2 / KV / D1 ─────────────────────────────────────
+ # Account-scoped storage. Management only — listing the inventory and
+ # creating/deleting resources. R2 is S3-compatible, so a bucket made here can
+ # later back ServerKit backups via the existing S3 storage backend (a separate
+ # follow-up that mints scoped R2 access keys).
+
+ R2_BUCKET_RE = re.compile(r'^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$')
+
+ @classmethod
+ def list_storage(cls, zone_id):
+ """Combined developer-platform inventory. Each product is fetched
+ independently so a missing token scope degrades to a per-product error
+ rather than failing the whole tab."""
+ zone, client = cls._zone_and_client(zone_id)
+ account_id = cls._account_id(zone, client)
+ out = {'success': True, 'account_id': account_id,
+ 'r2': [], 'kv': [], 'd1': [], 'errors': {}}
+
+ r2 = client.list_r2_buckets(account_id)
+ if r2.get('success'):
+ out['r2'] = [{'name': b.get('name'), 'creation_date': b.get('creation_date')}
+ for b in ((r2.get('result') or {}).get('buckets') or [])]
+ else:
+ out['errors']['r2'] = r2.get('error')
+
+ kv = client.list_kv_namespaces(account_id)
+ if kv.get('success'):
+ out['kv'] = [{'id': n.get('id'), 'title': n.get('title')}
+ for n in (kv.get('result') or [])]
+ else:
+ out['errors']['kv'] = kv.get('error')
+
+ d1 = client.list_d1_databases(account_id)
+ if d1.get('success'):
+ out['d1'] = [{'uuid': d.get('uuid'), 'name': d.get('name')}
+ for d in (d1.get('result') or [])]
+ else:
+ out['errors']['d1'] = d1.get('error')
+ return out
+
+ @classmethod
+ def create_r2_bucket(cls, zone_id, name):
+ name = (name or '').strip().lower()
+ if not cls.R2_BUCKET_RE.match(name):
+ raise CloudflareError('Bucket name must be 3–63 chars: lowercase letters, '
+ 'digits and hyphens, starting and ending alphanumeric')
+ zone, client = cls._zone_and_client(zone_id)
+ account_id = cls._account_id(zone, client)
+ res = client.create_r2_bucket(account_id, name)
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to create bucket')}
+ return {'success': True, 'bucket': name}
+
+ @classmethod
+ def delete_r2_bucket(cls, zone_id, name):
+ zone, client = cls._zone_and_client(zone_id)
+ account_id = cls._account_id(zone, client)
+ res = client.delete_r2_bucket(account_id, name)
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to delete bucket')}
+ return {'success': True}
+
+ @classmethod
+ def create_kv_namespace(cls, zone_id, title):
+ title = (title or '').strip()
+ if not title:
+ raise CloudflareError('A namespace title is required')
+ zone, client = cls._zone_and_client(zone_id)
+ account_id = cls._account_id(zone, client)
+ res = client.create_kv_namespace(account_id, title)
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to create namespace')}
+ return {'success': True, 'namespace': res.get('result')}
+
+ @classmethod
+ def delete_kv_namespace(cls, zone_id, namespace_id):
+ zone, client = cls._zone_and_client(zone_id)
+ account_id = cls._account_id(zone, client)
+ res = client.delete_kv_namespace(account_id, namespace_id)
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to delete namespace')}
+ return {'success': True}
+
+ @classmethod
+ def create_d1_database(cls, zone_id, name):
+ name = (name or '').strip()
+ if not name:
+ raise CloudflareError('A database name is required')
+ zone, client = cls._zone_and_client(zone_id)
+ account_id = cls._account_id(zone, client)
+ res = client.create_d1_database(account_id, name)
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to create database')}
+ return {'success': True, 'database': res.get('result')}
+
+ @classmethod
+ def delete_d1_database(cls, zone_id, database_id):
+ zone, client = cls._zone_and_client(zone_id)
+ account_id = cls._account_id(zone, client)
+ res = client.delete_d1_database(account_id, database_id)
+ if not res.get('success'):
+ return {'success': False, 'error': res.get('error', 'Failed to delete database')}
+ return {'success': True}
diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.py
index 81415c62..5f75384b 100644
--- a/backend/app/services/dns/cloudflare.py
+++ b/backend/app/services/dns/cloudflare.py
@@ -381,3 +381,36 @@ class CloudflareClient:
return self.request('PUT',
f'/accounts/{account_id}/cfd_tunnel/{tunnel_id}/configurations',
json={'config': config})
+
+ # ── Developer platform: R2 / KV / D1 ──────────────────────────────────────
+ # Account-scoped storage primitives. Management only (list/create/delete);
+ # object/key/row data planes are out of scope.
+ def list_r2_buckets(self, account_id: str) -> dict:
+ return self.request('GET', f'/accounts/{account_id}/r2/buckets')
+
+ def create_r2_bucket(self, account_id: str, name: str) -> dict:
+ return self.request('POST', f'/accounts/{account_id}/r2/buckets', json={'name': name})
+
+ def delete_r2_bucket(self, account_id: str, name: str) -> dict:
+ return self.request('DELETE', f'/accounts/{account_id}/r2/buckets/{name}')
+
+ def list_kv_namespaces(self, account_id: str) -> dict:
+ return self.request('GET', f'/accounts/{account_id}/storage/kv/namespaces',
+ params={'per_page': 100})
+
+ def create_kv_namespace(self, account_id: str, title: str) -> dict:
+ return self.request('POST', f'/accounts/{account_id}/storage/kv/namespaces',
+ json={'title': title})
+
+ def delete_kv_namespace(self, account_id: str, namespace_id: str) -> dict:
+ return self.request('DELETE',
+ f'/accounts/{account_id}/storage/kv/namespaces/{namespace_id}')
+
+ def list_d1_databases(self, account_id: str) -> dict:
+ return self.request('GET', f'/accounts/{account_id}/d1/database')
+
+ def create_d1_database(self, account_id: str, name: str) -> dict:
+ return self.request('POST', f'/accounts/{account_id}/d1/database', json={'name': name})
+
+ def delete_d1_database(self, account_id: str, database_id: str) -> dict:
+ return self.request('DELETE', f'/accounts/{account_id}/d1/database/{database_id}')
diff --git a/backend/tests/test_cloudflare_zone_settings.py b/backend/tests/test_cloudflare_zone_settings.py
index bf9307a3..676891a2 100644
--- a/backend/tests/test_cloudflare_zone_settings.py
+++ b/backend/tests/test_cloudflare_zone_settings.py
@@ -604,3 +604,92 @@ def test_add_tunnel_hostname_sets_ingress_with_catchall(app, monkeypatch):
ingress = put_body['config']['ingress']
assert ingress[0] == {'hostname': 'app.example.com', 'service': 'http://localhost:8080'}
assert ingress[-1] == {'service': 'http_status:404'} # required catch-all is last
+
+
+# ── Developer platform: R2 / KV / D1 (Phase 6) ───────────────────────────────
+
+def test_list_storage_aggregates_and_reports_errors(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ zone = _make_cf_zone()
+
+ 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('/r2/buckets'):
+ return _Resp({'success': True, 'result': {'buckets': [
+ {'name': 'assets', 'creation_date': 'x'}]}})
+ if url.endswith('/storage/kv/namespaces'):
+ return _Resp({'success': False, 'errors': [{'message': 'no kv scope'}]})
+ if url.endswith('/d1/database'):
+ return _Resp({'success': True, 'result': [{'uuid': 'db1', 'name': 'main'}]})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', req)
+
+ res = CloudflareService.list_storage(zone.id)
+ assert res['success'] is True and res['account_id'] == 'acct1'
+ assert res['r2'][0]['name'] == 'assets'
+ assert res['d1'][0]['name'] == 'main'
+ # A per-product scope error degrades that product only — not the whole tab.
+ assert res['errors']['kv'] == 'no kv scope' and res['kv'] == []
+
+
+def test_create_r2_bucket_validates_name(app):
+ from app.services.cloudflare_service import CloudflareService, CloudflareError
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.create_r2_bucket(zone.id, 'Bad_Bucket!')
+
+
+def test_create_r2_bucket_creates(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ zone = _make_cf_zone()
+ seen = {}
+
+ 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 == 'POST' and url.endswith('/r2/buckets'):
+ seen.update(json=json)
+ return _Resp({'success': True, 'result': {'name': 'my-assets'}})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', req)
+
+ res = CloudflareService.create_r2_bucket(zone.id, 'my-assets')
+ assert res['success'] is True and res['bucket'] == 'my-assets'
+ assert seen['json'] == {'name': 'my-assets'}
+
+
+def test_create_kv_namespace_requires_title(app):
+ from app.services.cloudflare_service import CloudflareService, CloudflareError
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.create_kv_namespace(zone.id, ' ')
+
+
+def test_create_d1_database_requires_name(app):
+ from app.services.cloudflare_service import CloudflareService, CloudflareError
+ zone = _make_cf_zone()
+ with pytest.raises(CloudflareError):
+ CloudflareService.create_d1_database(zone.id, '')
+
+
+def test_delete_r2_bucket_calls_delete(app, monkeypatch):
+ from app.services.dns import cloudflare as cf
+ from app.services.cloudflare_service import CloudflareService
+ zone = _make_cf_zone()
+ deleted = {}
+
+ 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('/r2/buckets/assets'):
+ deleted.update(url=url)
+ return _Resp({'success': True})
+ return _Resp({'success': False})
+ monkeypatch.setattr(cf.requests, 'request', req)
+
+ res = CloudflareService.delete_r2_bucket(zone.id, 'assets')
+ assert res['success'] is True
+ assert deleted['url'].endswith('/r2/buckets/assets')
diff --git a/frontend/src/components/cloudflare/StoragePanel.jsx b/frontend/src/components/cloudflare/StoragePanel.jsx
new file mode 100644
index 00000000..38041936
--- /dev/null
+++ b/frontend/src/components/cloudflare/StoragePanel.jsx
@@ -0,0 +1,266 @@
+import { useState, useEffect, useCallback } from 'react';
+import { HardDrive } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import EmptyState from '../EmptyState';
+import { useToast } from '../../contexts/ToastContext';
+import api from '../../services/api';
+
+function StorageSection({
+ title,
+ items,
+ error,
+ placeholder,
+ hint,
+ renderItem,
+ onCreate,
+ onDelete,
+ isAdmin,
+ busy,
+}) {
+ const [value, setValue] = useState('');
+
+ const writeDisabled = !isAdmin || busy;
+
+ const handleCreate = async () => {
+ const trimmed = value.trim();
+ if (!trimmed) return;
+ // Only clear the input when the create succeeds; a throw leaves the text intact.
+ await onCreate(trimmed);
+ setValue('');
+ };
+
+ return (
+ <section className="cf-storage__section">
+ <h3 className="cf-storage__heading">
+ {title} ({error ? 0 : items.length})
+ </h3>
+
+ {hint && <p className="cf-storage__hint">{hint}</p>}
+
+ {error ? (
+ <p className="cf-storage__error">{error}</p>
+ ) : (
+ <>
+ <div className="cf-storage__create">
+ <Input
+ value={value}
+ placeholder={placeholder}
+ onChange={(e) => setValue(e.target.value)}
+ disabled={writeDisabled}
+ />
+ <Button
+ size="sm"
+ onClick={handleCreate}
+ disabled={writeDisabled || !value.trim()}
+ >
+ Add
+ </Button>
+ </div>
+
+ {items.length === 0 ? (
+ <p className="cf-storage__hint">{`No ${title.toLowerCase()} yet.`}</p>
+ ) : (
+ <ul className="cf-storage__list">
+ {items.map((item) => {
+ const { key, label } = renderItem(item);
+ return (
+ <li className="cf-storage__item" key={key}>
+ <code className="cf-storage__name">{label}</code>
+ <Button
+ variant="destructive"
+ size="sm"
+ onClick={() => onDelete(item)}
+ disabled={writeDisabled}
+ >
+ Delete
+ </Button>
+ </li>
+ );
+ })}
+ </ul>
+ )}
+ </>
+ )}
+ </section>
+ );
+}
+
+export default function StoragePanel({ zoneId, isAdmin }) {
+ const toast = useToast();
+
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+ const [data, setData] = useState(null);
+
+ // Tracks any in-flight write so all write controls can disable
+ const [working, setWorking] = useState(false);
+
+ const loadData = useCallback(async () => {
+ try {
+ const res = await api.getCloudflareStorage(zoneId);
+ setData(res);
+ setError(null);
+ } catch (err) {
+ setError(err.message);
+ }
+ }, [zoneId]);
+
+ useEffect(() => {
+ let active = true;
+ setLoading(true);
+ (async () => {
+ try {
+ const res = await api.getCloudflareStorage(zoneId);
+ if (!active) return;
+ setData(res);
+ setError(null);
+ } catch (err) {
+ if (active) setError(err.message);
+ } finally {
+ if (active) setLoading(false);
+ }
+ })();
+ return () => {
+ active = false;
+ };
+ }, [zoneId]);
+
+ const handleCreateR2 = async (name) => {
+ setWorking(true);
+ try {
+ await api.createCloudflareR2Bucket(zoneId, name);
+ toast.success(`Created bucket "${name}"`);
+ await loadData();
+ } catch (err) {
+ toast.error(err.message);
+ throw err;
+ } finally {
+ setWorking(false);
+ }
+ };
+
+ const handleDeleteR2 = async (bucket) => {
+ setWorking(true);
+ try {
+ await api.deleteCloudflareR2Bucket(zoneId, bucket.name);
+ toast.success('Deleted');
+ await loadData();
+ } catch (err) {
+ toast.error(err.message);
+ } finally {
+ setWorking(false);
+ }
+ };
+
+ const handleCreateKv = async (title) => {
+ setWorking(true);
+ try {
+ await api.createCloudflareKvNamespace(zoneId, title);
+ toast.success(`Created namespace "${title}"`);
+ await loadData();
+ } catch (err) {
+ toast.error(err.message);
+ throw err;
+ } finally {
+ setWorking(false);
+ }
+ };
+
+ const handleDeleteKv = async (namespace) => {
+ setWorking(true);
+ try {
+ await api.deleteCloudflareKvNamespace(zoneId, namespace.id);
+ toast.success('Deleted');
+ await loadData();
+ } catch (err) {
+ toast.error(err.message);
+ } finally {
+ setWorking(false);
+ }
+ };
+
+ const handleCreateD1 = async (name) => {
+ setWorking(true);
+ try {
+ await api.createCloudflareD1Database(zoneId, name);
+ toast.success(`Created database "${name}"`);
+ await loadData();
+ } catch (err) {
+ toast.error(err.message);
+ throw err;
+ } finally {
+ setWorking(false);
+ }
+ };
+
+ const handleDeleteD1 = async (database) => {
+ setWorking(true);
+ try {
+ await api.deleteCloudflareD1Database(zoneId, database.uuid);
+ toast.success('Deleted');
+ await loadData();
+ } catch (err) {
+ toast.error(err.message);
+ } finally {
+ setWorking(false);
+ }
+ };
+
+ if (loading) {
+ return <div className="cf-storage__loading">Loading storage…</div>;
+ }
+
+ if (error) {
+ return (
+ <EmptyState
+ icon={HardDrive}
+ title="Storage unavailable"
+ description={error}
+ />
+ );
+ }
+
+ const errors = data.errors || {};
+
+ return (
+ <div className="cf-storage">
+ <StorageSection
+ title="R2 buckets"
+ items={data.r2 || []}
+ error={errors.r2}
+ placeholder="my-bucket"
+ hint="R2 is S3-compatible, so a bucket here can back ServerKit backups later."
+ renderItem={(b) => ({ key: b.name, label: b.name })}
+ onCreate={handleCreateR2}
+ onDelete={handleDeleteR2}
+ isAdmin={isAdmin}
+ busy={working}
+ />
+
+ <StorageSection
+ title="KV namespaces"
+ items={data.kv || []}
+ error={errors.kv}
+ placeholder="my-namespace"
+ renderItem={(n) => ({ key: n.id, label: n.title })}
+ onCreate={handleCreateKv}
+ onDelete={handleDeleteKv}
+ isAdmin={isAdmin}
+ busy={working}
+ />
+
+ <StorageSection
+ title="D1 databases"
+ items={data.d1 || []}
+ error={errors.d1}
+ placeholder="my-database"
+ renderItem={(d) => ({ key: d.uuid, label: d.name })}
+ onCreate={handleCreateD1}
+ onDelete={handleDeleteD1}
+ isAdmin={isAdmin}
+ busy={working}
+ />
+ </div>
+ );
+}
diff --git a/frontend/src/pages/CloudflareZoneSettings.jsx b/frontend/src/pages/CloudflareZoneSettings.jsx
index 947ae9be..ac5f77f5 100644
--- a/frontend/src/pages/CloudflareZoneSettings.jsx
+++ b/frontend/src/pages/CloudflareZoneSettings.jsx
@@ -1,10 +1,11 @@
import { useState, useEffect, useCallback } from 'react';
import { useParams, Link } from 'react-router-dom';
-import { Cloud, ShieldCheck, Lock, Gauge, Database, Wand2, Eraser, Flame, Zap, Network } from 'lucide-react';
+import { Cloud, ShieldCheck, Lock, Gauge, Database, Wand2, Eraser, Flame, Zap, Network, HardDrive } from 'lucide-react';
import { PageTopbar } from '@/components/ds';
import WafPanel from '../components/cloudflare/WafPanel';
import WorkersPanel from '../components/cloudflare/WorkersPanel';
import TunnelsPanel from '../components/cloudflare/TunnelsPanel';
+import StoragePanel from '../components/cloudflare/StoragePanel';
import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';
import { Switch } from '@/components/ui/switch';
import { Button } from '@/components/ui/button';
@@ -191,6 +192,7 @@ const CloudflareZoneSettings = () => {
<TabsTrigger value="waf"><Flame size={15} />WAF</TabsTrigger>
<TabsTrigger value="workers"><Zap size={15} />Workers</TabsTrigger>
<TabsTrigger value="tunnels"><Network size={15} />Tunnels</TabsTrigger>
+ <TabsTrigger value="storage"><HardDrive size={15} />Storage</TabsTrigger>
<TabsTrigger value="actions"><Wand2 size={15} />Actions</TabsTrigger>
</TabsList>
@@ -229,6 +231,12 @@ const CloudflareZoneSettings = () => {
</div>
</TabsContent>
+ <TabsContent value="storage">
+ <div className="cf-panel">
+ <StoragePanel 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 bfc5db4d..67931539 100644
--- a/frontend/src/services/api/cloudflare.js
+++ b/frontend/src/services/api/cloudflare.js
@@ -134,3 +134,47 @@ export async function removeCloudflareTunnelHostname(zoneId, tunnelId, hostname)
body: { hostname },
});
}
+
+// Developer platform — R2 buckets, KV namespaces, D1 databases (account-scoped).
+export async function getCloudflareStorage(zoneId) {
+ return this.request(`/cloudflare/zones/${zoneId}/storage`);
+}
+
+export async function createCloudflareR2Bucket(zoneId, name) {
+ return this.request(`/cloudflare/zones/${zoneId}/storage/r2`, {
+ method: 'POST',
+ body: { name },
+ });
+}
+
+export async function deleteCloudflareR2Bucket(zoneId, name) {
+ return this.request(`/cloudflare/zones/${zoneId}/storage/r2/${encodeURIComponent(name)}`, {
+ method: 'DELETE',
+ });
+}
+
+export async function createCloudflareKvNamespace(zoneId, title) {
+ return this.request(`/cloudflare/zones/${zoneId}/storage/kv`, {
+ method: 'POST',
+ body: { title },
+ });
+}
+
+export async function deleteCloudflareKvNamespace(zoneId, namespaceId) {
+ return this.request(`/cloudflare/zones/${zoneId}/storage/kv/${namespaceId}`, {
+ method: 'DELETE',
+ });
+}
+
+export async function createCloudflareD1Database(zoneId, name) {
+ return this.request(`/cloudflare/zones/${zoneId}/storage/d1`, {
+ method: 'POST',
+ body: { name },
+ });
+}
+
+export async function deleteCloudflareD1Database(zoneId, databaseId) {
+ return this.request(`/cloudflare/zones/${zoneId}/storage/d1/${databaseId}`, {
+ method: 'DELETE',
+ });
+}
diff --git a/frontend/src/styles/pages/_cloudflare-zone.scss b/frontend/src/styles/pages/_cloudflare-zone.scss
index 11a259d1..12b19308 100644
--- a/frontend/src/styles/pages/_cloudflare-zone.scss
+++ b/frontend/src/styles/pages/_cloudflare-zone.scss
@@ -497,3 +497,70 @@
align-items: center;
}
}
+
+// Storage tab — R2 buckets, KV namespaces, D1 databases.
+.cf-storage {
+ &__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;
+ color: $text-muted;
+ font-size: 0.82rem;
+ }
+
+ &__error {
+ margin: $spacing-xs 0;
+ color: $text-muted;
+ font-size: 0.82rem;
+ font-style: italic;
+ }
+
+ &__create {
+ display: flex;
+ gap: $spacing-sm;
+ align-items: center;
+ max-width: 420px;
+ margin-bottom: $spacing-sm;
+ }
+
+ &__list {
+ list-style: none;
+ margin: 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 {
+ font-family: $font-mono;
+ font-size: 0.85rem;
+ color: $text-primary;
+ }
+}