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): R2 / KV / D1 developer platform (Phase 6)
Juan Denis5836294c4d7e
diff --git a/backend/app/api/cloudflare.py b/backend/app/api/cloudflare.pyindex 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)}), 400return _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.pyindex 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.pyindex 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.pyindex 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.jsxnew file mode 100644index 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.jsxindex 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.jsindex 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.scssindex 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;+ }+}