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: add secrets manager and inbound webhook gateway

Juan Denisbf9fee131e2c
diff --git a/.env.example b/.env.example
index 84ed8843..9394618e 100644
--- a/.env.example
+++ b/.env.example
@@ -11,6 +11,9 @@
# Generate unique keys for production!
SECRET_KEY=your-secret-key-here
JWT_SECRET_KEY=your-jwt-secret-key-here
+# Fernet key for encrypting secrets at rest.
+# Generate with: python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
+SERVERKIT_ENCRYPTION_KEY=your-fernet-key-here
# ----------------------------------------
# Database Configuration
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index e4d16a76..3274dbd5 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -182,6 +182,10 @@ def create_app(config_name=None):
from app.api.security import security_bp
app.register_blueprint(security_bp, url_prefix='/api/v1/security')
+ # Register blueprints - Secrets manager + inbound webhook gateway
+ from app.api.secrets_webhooks import bp as secrets_webhooks_bp
+ app.register_blueprint(secrets_webhooks_bp, url_prefix='/api/v1')
+
# Register blueprints - Cron Jobs
from app.api.cron import cron_bp
app.register_blueprint(cron_bp, url_prefix='/api/v1/cron')
diff --git a/backend/app/api/secrets_webhooks.py b/backend/app/api/secrets_webhooks.py
new file mode 100644
index 00000000..48741c25
--- /dev/null
+++ b/backend/app/api/secrets_webhooks.py
@@ -0,0 +1,269 @@
+"""API endpoints for secrets manager and inbound webhook gateway."""
+from datetime import datetime
+from functools import wraps
+
+from flask import Blueprint, request
+from flask_jwt_extended import get_jwt_identity, jwt_required
+
+from app.services.secret_vault_service import SecretService, SecretVaultService
+from app.services.webhook_gateway_service import WebhookGatewayService
+
+bp = Blueprint('secrets_webhooks', __name__)
+
+
+def _current_user_id() -> int:
+ identity = get_jwt_identity()
+ return int(identity) if identity else None
+
+
+def _json_or_form() -> dict:
+ """Return JSON body if available, otherwise an empty dict."""
+ if request.is_json:
+ return request.get_json(silent=True) or {}
+ return {}
+
+
+def admin_required(fn):
+ """Require an admin user (placeholder for role check)."""
+ @wraps(fn)
+ @jwt_required()
+ def wrapper(*args, **kwargs):
+ # Role checks can be added here when the auth system exposes roles.
+ return fn(*args, **kwargs)
+ return wrapper
+
+
+# ---------- Secret Vaults ----------
+
[email protected]('/vaults', methods=['GET'])
+@jwt_required()
+def list_vaults():
+ return {'success': True, 'vaults': SecretVaultService.list_vaults()}
+
+
[email protected]('/vaults', methods=['POST'])
+@jwt_required()
+def create_vault():
+ data = _json_or_form()
+ name = data.get('name')
+ if not name:
+ return {'error': 'name is required'}, 400
+ result = SecretVaultService.create_vault(name, description=data.get('description'), user_id=_current_user_id())
+ if not result.get('success'):
+ return {'error': result.get('error')}, 409
+ return result, 201
+
+
[email protected]('/vaults/<int:vault_id>', methods=['GET'])
+@jwt_required()
+def get_vault(vault_id):
+ vault = SecretVaultService.get_vault(vault_id)
+ if not vault:
+ return {'error': 'Vault not found'}, 404
+ return {'success': True, 'vault': vault.to_dict()}
+
+
[email protected]('/vaults/<int:vault_id>', methods=['PATCH'])
+@jwt_required()
+def update_vault(vault_id):
+ data = _json_or_form()
+ result = SecretVaultService.update_vault(vault_id, name=data.get('name'), description=data.get('description'))
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404 if 'not found' in result.get('error', '').lower() else 409
+ return result
+
+
[email protected]('/vaults/<int:vault_id>', methods=['DELETE'])
+@jwt_required()
+def delete_vault(vault_id):
+ result = SecretVaultService.delete_vault(vault_id)
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404
+ return result
+
+
+# ---------- Secrets ----------
+
[email protected]('/vaults/<int:vault_id>/secrets', methods=['GET'])
+@jwt_required()
+def list_secrets(vault_id):
+ return {'success': True, 'secrets': SecretService.list_secrets(vault_id)}
+
+
[email protected]('/vaults/<int:vault_id>/secrets', methods=['POST'])
+@jwt_required()
+def create_secret(vault_id):
+ data = _json_or_form()
+ name = data.get('name')
+ value = data.get('value')
+ if name is None or value is None:
+ return {'error': 'name and value are required'}, 400
+ expires_at = None
+ if data.get('expires_at'):
+ try:
+ expires_at = datetime.fromisoformat(data['expires_at'])
+ except ValueError:
+ return {'error': 'Invalid expires_at format'}, 400
+ result = SecretService.create_secret(vault_id, name, value, description=data.get('description'), expires_at=expires_at)
+ if not result.get('success'):
+ return {'error': result.get('error')}, 409 if 'already exists' in result.get('error', '').lower() else 400
+ return result, 201
+
+
[email protected]('/vaults/<int:vault_id>/secrets/bulk', methods=['POST'])
+@jwt_required()
+def bulk_create_secrets(vault_id):
+ data = _json_or_form()
+ secrets_list = data.get('secrets', [])
+ if not isinstance(secrets_list, list):
+ return {'error': 'secrets must be a list'}, 400
+ result = SecretService.bulk_create_or_update(vault_id, secrets_list)
+ return result, 207
+
+
[email protected]('/secrets/<int:secret_id>', methods=['GET'])
+@jwt_required()
+def get_secret(secret_id):
+ secret = SecretService.get_secret(secret_id)
+ if not secret:
+ return {'error': 'Secret not found'}, 404
+ return {'success': True, 'secret': secret.to_dict(mask=True)}
+
+
[email protected]('/secrets/<int:secret_id>', methods=['PATCH'])
+@jwt_required()
+def update_secret(secret_id):
+ data = _json_or_form()
+ expires_at = None
+ if data.get('expires_at'):
+ try:
+ expires_at = datetime.fromisoformat(data['expires_at'])
+ except ValueError:
+ return {'error': 'Invalid expires_at format'}, 400
+ result = SecretService.update_secret(
+ secret_id,
+ value=data.get('value'),
+ description=data.get('description'),
+ expires_at=expires_at,
+ rotate=data.get('rotate', False),
+ )
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404
+ return result
+
+
[email protected]('/secrets/<int:secret_id>/reveal', methods=['POST'])
+@jwt_required()
+def reveal_secret(secret_id):
+ result = SecretService.reveal_secret(secret_id)
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404
+ return result
+
+
[email protected]('/secrets/<int:secret_id>', methods=['DELETE'])
+@jwt_required()
+def delete_secret(secret_id):
+ result = SecretService.delete_secret(secret_id)
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404
+ return result
+
+
+# ---------- Webhook Endpoints ----------
+
[email protected]('/webhooks/endpoints', methods=['GET'])
+@jwt_required()
+def list_webhook_endpoints():
+ return {'success': True, 'endpoints': WebhookGatewayService.list_endpoints()}
+
+
[email protected]('/webhooks/endpoints', methods=['POST'])
+@jwt_required()
+def create_webhook_endpoint():
+ data = _json_or_form()
+ name = data.get('name')
+ if not name:
+ return {'error': 'name is required'}, 400
+ result = WebhookGatewayService.create_endpoint(
+ name=name,
+ secret=data.get('secret'),
+ forward_url=data.get('forward_url'),
+ filter_paths=data.get('filter_paths'),
+ retry_count=data.get('retry_count', 3),
+ user_id=_current_user_id(),
+ )
+ if not result.get('success'):
+ return {'error': result.get('error')}, 409
+ return result, 201
+
+
[email protected]('/webhooks/endpoints/<int:endpoint_id>', methods=['GET'])
+@jwt_required()
+def get_webhook_endpoint(endpoint_id):
+ endpoint = WebhookGatewayService.get_endpoint(endpoint_id)
+ if not endpoint:
+ return {'error': 'Endpoint not found'}, 404
+ return {'success': True, 'endpoint': endpoint.to_dict()}
+
+
[email protected]('/webhooks/endpoints/<int:endpoint_id>', methods=['PATCH'])
+@jwt_required()
+def update_webhook_endpoint(endpoint_id):
+ data = _json_or_form()
+ result = WebhookGatewayService.update_endpoint(
+ endpoint_id,
+ name=data.get('name'),
+ forward_url=data.get('forward_url'),
+ filter_paths=data.get('filter_paths'),
+ retry_count=data.get('retry_count'),
+ is_active=data.get('is_active'),
+ )
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404 if 'not found' in result.get('error', '').lower() else 409
+ return result
+
+
[email protected]('/webhooks/endpoints/<int:endpoint_id>/regenerate-secret', methods=['POST'])
+@jwt_required()
+def regenerate_webhook_secret(endpoint_id):
+ result = WebhookGatewayService.regenerate_secret(endpoint_id)
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404
+ return result
+
+
[email protected]('/webhooks/endpoints/<int:endpoint_id>', methods=['DELETE'])
+@jwt_required()
+def delete_webhook_endpoint(endpoint_id):
+ result = WebhookGatewayService.delete_endpoint(endpoint_id)
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404
+ return result
+
+
[email protected]('/webhooks/endpoints/<int:endpoint_id>/deliveries', methods=['GET'])
+@jwt_required()
+def list_webhook_deliveries(endpoint_id):
+ limit = request.args.get('limit', 50, type=int)
+ status = request.args.get('status')
+ return {'success': True, 'deliveries': WebhookGatewayService.list_deliveries(endpoint_id, limit=limit, status=status)}
+
+
[email protected]('/webhooks/deliveries/<int:delivery_id>/replay', methods=['POST'])
+@jwt_required()
+def replay_webhook_delivery(delivery_id):
+ result = WebhookGatewayService.replay_delivery(delivery_id)
+ if not result.get('success'):
+ return {'error': result.get('error')}, 404
+ return result
+
+
+# ---------- Public webhook receiver ----------
+
[email protected]('/webhooks/receive/<string:slug>', methods=['POST'])
+def receive_webhook(slug):
+ payload = request.get_data() or b''
+ headers = dict(request.headers)
+ result, status = WebhookGatewayService.receive(slug, payload, headers)
+ return result, status
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index d4799fe2..2dd53349 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -39,6 +39,8 @@ from app.models.plugin import InstalledPlugin
from app.models.ai import AiConversation, AiMessage, AiPendingAction
from app.models.image_scan import ImageVulnerabilityScan, SbomArtifact
from app.models.passkey import PasskeyCredential
+from app.models.secret_vault import SecretVault, Secret
+from app.models.webhook_gateway import WebhookEndpoint, WebhookDelivery
__all__ = [
'User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',
@@ -64,4 +66,6 @@ __all__ = [
'AiConversation', 'AiMessage', 'AiPendingAction',
'ImageVulnerabilityScan', 'SbomArtifact',
'PasskeyCredential',
+ 'SecretVault', 'Secret',
+ 'WebhookEndpoint', 'WebhookDelivery',
]
diff --git a/backend/app/models/secret_vault.py b/backend/app/models/secret_vault.py
new file mode 100644
index 00000000..bbdcc1ce
--- /dev/null
+++ b/backend/app/models/secret_vault.py
@@ -0,0 +1,71 @@
+import json
+from datetime import datetime
+from app import db
+from app.utils.crypto import encrypt_secret, decrypt_secret_safe
+
+
+class SecretVault(db.Model):
+ """A named vault for encrypted secrets."""
+ __tablename__ = 'secret_vaults'
+
+ id = db.Column(db.Integer, primary_key=True)
+ name = db.Column(db.String(200), nullable=False, unique=True)
+ slug = db.Column(db.String(220), nullable=False, unique=True, index=True)
+ description = db.Column(db.Text, nullable=True)
+ created_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ secrets = db.relationship('Secret', backref='vault', lazy='dynamic', cascade='all, delete-orphan')
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'name': self.name,
+ 'slug': self.slug,
+ 'description': self.description,
+ 'secret_count': self.secrets.count(),
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+ }
+
+
+class Secret(db.Model):
+ """An encrypted secret inside a vault."""
+ __tablename__ = 'secrets'
+
+ id = db.Column(db.Integer, primary_key=True)
+ vault_id = db.Column(db.Integer, db.ForeignKey('secret_vaults.id', ondelete='CASCADE'), nullable=False, index=True)
+ name = db.Column(db.String(200), nullable=False)
+ encrypted_value = db.Column(db.Text, nullable=False)
+ description = db.Column(db.Text, nullable=True)
+ expires_at = db.Column(db.DateTime, nullable=True)
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ __table_args__ = (
+ db.UniqueConstraint('vault_id', 'name', name='uq_secret_vault_name'),
+ )
+
+ @property
+ def value(self):
+ return decrypt_secret_safe(self.encrypted_value)
+
+ @property
+ def is_expired(self):
+ return self.expires_at is not None and self.expires_at < datetime.utcnow()
+
+ def to_dict(self, include_value=False, mask=False):
+ result = {
+ 'id': self.id,
+ 'vault_id': self.vault_id,
+ 'name': self.name,
+ 'description': self.description,
+ 'expires_at': self.expires_at.isoformat() if self.expires_at else None,
+ 'is_expired': self.is_expired,
+ '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_value:
+ result['value'] = '••••••••' if mask else self.value
+ return result
diff --git a/backend/app/models/webhook_gateway.py b/backend/app/models/webhook_gateway.py
new file mode 100644
index 00000000..4445dd1b
--- /dev/null
+++ b/backend/app/models/webhook_gateway.py
@@ -0,0 +1,105 @@
+import json
+import hmac
+import hashlib
+import base64
+from datetime import datetime
+from app import db
+
+
+class WebhookEndpoint(db.Model):
+ """Inbound webhook endpoint configuration."""
+ __tablename__ = 'webhook_endpoints'
+
+ id = db.Column(db.Integer, primary_key=True)
+ name = db.Column(db.String(200), nullable=False, unique=True)
+ slug = db.Column(db.String(220), nullable=False, unique=True, index=True)
+ secret = db.Column(db.String(500), nullable=False) # HMAC secret
+ is_active = db.Column(db.Boolean, default=True)
+ filter_paths = db.Column(db.Text, nullable=True) # JSON list of dotted-path filters
+ forward_url = db.Column(db.String(500), nullable=True)
+ retry_count = db.Column(db.Integer, default=3)
+ created_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ deliveries = db.relationship('WebhookDelivery', backref='endpoint', lazy='dynamic', cascade='all, delete-orphan')
+
+ def get_filter_paths(self):
+ if not self.filter_paths:
+ return []
+ try:
+ return json.loads(self.filter_paths)
+ except Exception:
+ return []
+
+ def set_filter_paths(self, paths):
+ self.filter_paths = json.dumps(list(paths)) if paths else None
+
+ def verify_signature(self, payload: bytes, signature_header: str, algorithm: str = 'sha256') -> bool:
+ """Verify HMAC-SHA1/SHA256 signature from header."""
+ if not signature_header:
+ return False
+ if algorithm == 'sha256':
+ expected = 'sha256=' + hmac.new(self.secret.encode(), payload, hashlib.sha256).hexdigest()
+ return hmac.compare_digest(expected, signature_header)
+ if algorithm == 'sha1':
+ expected = 'sha1=' + hmac.new(self.secret.encode(), payload, hashlib.sha1).hexdigest()
+ return hmac.compare_digest(expected, signature_header)
+ return False
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'name': self.name,
+ 'slug': self.slug,
+ 'is_active': self.is_active,
+ 'filter_paths': self.get_filter_paths(),
+ 'forward_url': self.forward_url,
+ 'retry_count': self.retry_count,
+ 'delivery_count': self.deliveries.count(),
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ 'updated_at': self.updated_at.isoformat() if self.updated_at else None,
+ }
+
+
+class WebhookDelivery(db.Model):
+ """Log of an inbound webhook delivery."""
+ __tablename__ = 'webhook_deliveries'
+
+ id = db.Column(db.Integer, primary_key=True)
+ endpoint_id = db.Column(db.Integer, db.ForeignKey('webhook_endpoints.id', ondelete='CASCADE'), nullable=False, index=True)
+ event_id = db.Column(db.String(300), nullable=False, unique=True, index=True)
+ payload = db.Column(db.Text, nullable=True)
+ headers = db.Column(db.Text, nullable=True)
+ signature_valid = db.Column(db.Boolean, nullable=True)
+ status = db.Column(db.String(50), default='received') # received, filtered, forwarded, failed
+ response_status = db.Column(db.Integer, nullable=True)
+ response_body = db.Column(db.Text, nullable=True)
+ error_message = db.Column(db.Text, nullable=True)
+ received_at = db.Column(db.DateTime, default=datetime.utcnow)
+ completed_at = db.Column(db.DateTime, nullable=True)
+
+ def get_headers(self):
+ if not self.headers:
+ return {}
+ try:
+ return json.loads(self.headers)
+ except Exception:
+ return {}
+
+ def set_headers(self, headers):
+ self.headers = json.dumps(dict(headers)) if headers else None
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'endpoint_id': self.endpoint_id,
+ 'event_id': self.event_id,
+ 'payload': json.loads(self.payload) if self.payload else None,
+ 'signature_valid': self.signature_valid,
+ 'status': self.status,
+ 'response_status': self.response_status,
+ 'error_message': self.error_message,
+ 'received_at': self.received_at.isoformat() if self.received_at else None,
+ 'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+ }
diff --git a/backend/app/services/secret_vault_service.py b/backend/app/services/secret_vault_service.py
new file mode 100644
index 00000000..fc36d45a
--- /dev/null
+++ b/backend/app/services/secret_vault_service.py
@@ -0,0 +1,214 @@
+"""Encrypted secrets manager (vault + secret) service."""
+import json
+import logging
+import re
+import secrets
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from app import db
+from app.models import Secret, SecretVault
+from app.utils.crypto import encrypt_secret, decrypt_secret_safe
+
+logger = logging.getLogger(__name__)
+
+
+def _slugify(name: str) -> str:
+ base = re.sub(r'[^a-z0-9]+', '-', name.lower()).strip('-')
+ return base or 'vault'
+
+
+def _unique_slug(name: str) -> str:
+ base = _slugify(name)
+ slug = base
+ counter = 1
+ while SecretVault.query.filter_by(slug=slug).first():
+ slug = f'{base}-{counter}'
+ counter += 1
+ return slug
+
+
+class SecretVaultService:
+ """Manage encrypted secret vaults."""
+
+ @classmethod
+ def list_vaults(cls) -> List[Dict]:
+ return [v.to_dict() for v in SecretVault.query.order_by(SecretVault.name).all()]
+
+ @classmethod
+ def get_vault(cls, vault_id: int) -> Optional[SecretVault]:
+ return SecretVault.query.get(vault_id)
+
+ @classmethod
+ def create_vault(cls, name: str, description: str = None, user_id: int = None) -> Dict:
+ if SecretVault.query.filter_by(name=name).first():
+ return {'success': False, 'error': 'Vault name already exists'}
+ vault = SecretVault(
+ name=name,
+ slug=_unique_slug(name),
+ description=description,
+ created_by=user_id,
+ )
+ db.session.add(vault)
+ db.session.commit()
+ return {'success': True, 'vault': vault.to_dict()}
+
+ @classmethod
+ def update_vault(cls, vault_id: int, name: str = None, description: str = None) -> Dict:
+ vault = cls.get_vault(vault_id)
+ if not vault:
+ return {'success': False, 'error': 'Vault not found'}
+ if name is not None:
+ existing = SecretVault.query.filter(SecretVault.name == name, SecretVault.id != vault_id).first()
+ if existing:
+ return {'success': False, 'error': 'Vault name already exists'}
+ vault.name = name
+ if description is not None:
+ vault.description = description
+ db.session.commit()
+ return {'success': True, 'vault': vault.to_dict()}
+
+ @classmethod
+ def delete_vault(cls, vault_id: int) -> Dict:
+ vault = cls.get_vault(vault_id)
+ if not vault:
+ return {'success': False, 'error': 'Vault not found'}
+ db.session.delete(vault)
+ db.session.commit()
+ return {'success': True, 'message': 'Vault deleted'}
+
+
+class SecretService:
+ """Manage encrypted secrets inside vaults."""
+
+ _NAME_RE = re.compile(r'^[A-Z_][A-Z0-9_]*$', re.IGNORECASE)
+
+ @classmethod
+ def list_secrets(cls, vault_id: int) -> List[Dict]:
+ return [s.to_dict(include_value=True, mask=True) for s in Secret.query.filter_by(vault_id=vault_id).order_by(Secret.name).all()]
+
+ @classmethod
+ def get_secret(cls, secret_id: int) -> Optional[Secret]:
+ return Secret.query.get(secret_id)
+
+ @classmethod
+ def get_secret_by_name(cls, vault_id: int, name: str) -> Optional[Secret]:
+ return Secret.query.filter_by(vault_id=vault_id, name=name).first()
+
+ @classmethod
+ def _validate_name(cls, name: str) -> Optional[str]:
+ if not name:
+ return 'Name is required'
+ if not cls._NAME_RE.match(name):
+ return 'Name must start with a letter or underscore and contain only letters, digits, and underscores'
+ return None
+
+ @classmethod
+ def create_secret(cls, vault_id: int, name: str, value: str,
+ description: str = None, expires_at=None) -> Dict:
+ if not SecretVault.query.get(vault_id):
+ return {'success': False, 'error': 'Vault not found'}
+ err = cls._validate_name(name)
+ if err:
+ return {'success': False, 'error': err}
+ if Secret.query.filter_by(vault_id=vault_id, name=name).first():
+ return {'success': False, 'error': 'Secret name already exists in this vault'}
+ try:
+ encrypted = encrypt_secret(value)
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+ secret = Secret(
+ vault_id=vault_id,
+ name=name,
+ encrypted_value=encrypted,
+ description=description,
+ expires_at=expires_at,
+ )
+ db.session.add(secret)
+ db.session.commit()
+ return {'success': True, 'secret': secret.to_dict(include_value=True, mask=True)}
+
+ @classmethod
+ def update_secret(cls, secret_id: int, value: str = None, description: str = None,
+ expires_at=None, rotate: bool = False) -> Dict:
+ secret = cls.get_secret(secret_id)
+ if not secret:
+ return {'success': False, 'error': 'Secret not found'}
+ if value is not None:
+ try:
+ secret.encrypted_value = encrypt_secret(value)
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+ secret.updated_at = datetime.utcnow()
+ if description is not None:
+ secret.description = description
+ if expires_at is not None:
+ secret.expires_at = expires_at
+ if rotate:
+ decrypted = secret.value
+ if decrypted:
+ try:
+ secret.encrypted_value = encrypt_secret(decrypted)
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+ secret.updated_at = datetime.utcnow()
+ db.session.commit()
+ return {'success': True, 'secret': secret.to_dict(include_value=True, mask=True)}
+
+ @classmethod
+ def delete_secret(cls, secret_id: int) -> Dict:
+ secret = cls.get_secret(secret_id)
+ if not secret:
+ return {'success': False, 'error': 'Secret not found'}
+ db.session.delete(secret)
+ db.session.commit()
+ return {'success': True, 'message': 'Secret deleted'}
+
+ @classmethod
+ def reveal_secret(cls, secret_id: int) -> Dict:
+ secret = cls.get_secret(secret_id)
+ if not secret:
+ return {'success': False, 'error': 'Secret not found'}
+ value = secret.value
+ if value is None:
+ return {'success': False, 'error': 'Unable to decrypt secret'}
+ return {'success': True, 'secret': secret.to_dict(include_value=True, mask=False)}
+
+ @classmethod
+ def bulk_create_or_update(cls, vault_id: int, secrets_list: List[Dict]) -> Dict:
+ """Create or update many secrets. Each item needs name and value."""
+ if not SecretVault.query.get(vault_id):
+ return {'success': False, 'error': 'Vault not found'}
+ results = []
+ errors = []
+ for item in secrets_list:
+ name = item.get('name')
+ value = item.get('value')
+ if not name or value is None:
+ errors.append({'name': name, 'error': 'name and value required'})
+ continue
+ existing = cls.get_secret_by_name(vault_id, name)
+ if existing:
+ result = cls.update_secret(existing.id, value=value)
+ else:
+ result = cls.create_secret(vault_id, name, value, description=item.get('description'))
+ if result.get('success'):
+ results.append(result['secret'])
+ else:
+ errors.append({'name': name, 'error': result.get('error')})
+ return {'success': True, 'secrets': results, 'errors': errors}
+
+ @classmethod
+ def resolve_env_dict(cls, vault_id: int, prefix: str = '') -> Dict[str, str]:
+ """Resolve vault secrets to an env-style dict (server-side use only)."""
+ secrets = Secret.query.filter_by(vault_id=vault_id).all()
+ env = {}
+ for s in secrets:
+ if s.is_expired:
+ continue
+ value = s.value
+ if value is None:
+ continue
+ key = f'{prefix}{s.name}'
+ env[key] = value
+ return env
diff --git a/backend/app/services/webhook_gateway_service.py b/backend/app/services/webhook_gateway_service.py
new file mode 100644
index 00000000..5471102e
--- /dev/null
+++ b/backend/app/services/webhook_gateway_service.py
@@ -0,0 +1,260 @@
+"""Inbound webhook gateway service with HMAC verification and delivery logging."""
+import hashlib
+import hmac
+import json
+import logging
+import re
+import secrets
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional
+
+import requests
+
+from app import db
+from app.models import WebhookEndpoint, WebhookDelivery
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookGatewayService:
+ """Receive, inspect, route, and replay inbound webhooks."""
+
+ @classmethod
+ def list_endpoints(cls) -> List[Dict]:
+ return [e.to_dict() for e in WebhookEndpoint.query.order_by(WebhookEndpoint.name).all()]
+
+ @classmethod
+ def get_endpoint(cls, endpoint_id: int) -> Optional[WebhookEndpoint]:
+ return WebhookEndpoint.query.get(endpoint_id)
+
+ @classmethod
+ def get_endpoint_by_slug(cls, slug: str) -> Optional[WebhookEndpoint]:
+ return WebhookEndpoint.query.filter_by(slug=slug, is_active=True).first()
+
+ @classmethod
+ def _slugify(cls, name: str) -> str:
+ base = re.sub(r'[^a-z0-9]+', '-', name.lower()).strip('-')
+ return base or 'endpoint'
+
+ @classmethod
+ def _unique_slug(cls, name: str) -> str:
+ base = cls._slugify(name)
+ slug = base
+ counter = 1
+ while WebhookEndpoint.query.filter_by(slug=slug).first():
+ slug = f'{base}-{counter}'
+ counter += 1
+ return slug
+
+ @classmethod
+ def create_endpoint(cls, name: str, secret: str = None, forward_url: str = None,
+ filter_paths: List[str] = None, retry_count: int = 3,
+ user_id: int = None) -> Dict:
+ if WebhookEndpoint.query.filter_by(name=name).first():
+ return {'success': False, 'error': 'Endpoint name already exists'}
+ endpoint = WebhookEndpoint(
+ name=name,
+ slug=cls._unique_slug(name),
+ secret=secret or secrets.token_urlsafe(32),
+ forward_url=forward_url,
+ retry_count=retry_count,
+ created_by=user_id,
+ )
+ if filter_paths:
+ endpoint.set_filter_paths(filter_paths)
+ db.session.add(endpoint)
+ db.session.commit()
+ return {'success': True, 'endpoint': endpoint.to_dict()}
+
+ @classmethod
+ def update_endpoint(cls, endpoint_id: int, name: str = None, forward_url: str = None,
+ filter_paths: List[str] = None, retry_count: int = None,
+ is_active: bool = None) -> Dict:
+ endpoint = cls.get_endpoint(endpoint_id)
+ if not endpoint:
+ return {'success': False, 'error': 'Endpoint not found'}
+ if name is not None:
+ existing = WebhookEndpoint.query.filter(WebhookEndpoint.name == name, WebhookEndpoint.id != endpoint_id).first()
+ if existing:
+ return {'success': False, 'error': 'Endpoint name already exists'}
+ endpoint.name = name
+ if forward_url is not None:
+ endpoint.forward_url = forward_url
+ if filter_paths is not None:
+ endpoint.set_filter_paths(filter_paths)
+ if retry_count is not None:
+ endpoint.retry_count = retry_count
+ if is_active is not None:
+ endpoint.is_active = is_active
+ db.session.commit()
+ return {'success': True, 'endpoint': endpoint.to_dict()}
+
+ @classmethod
+ def delete_endpoint(cls, endpoint_id: int) -> Dict:
+ endpoint = cls.get_endpoint(endpoint_id)
+ if not endpoint:
+ return {'success': False, 'error': 'Endpoint not found'}
+ db.session.delete(endpoint)
+ db.session.commit()
+ return {'success': True, 'message': 'Endpoint deleted'}
+
+ @classmethod
+ def regenerate_secret(cls, endpoint_id: int) -> Dict:
+ endpoint = cls.get_endpoint(endpoint_id)
+ if not endpoint:
+ return {'success': False, 'error': 'Endpoint not found'}
+ endpoint.secret = secrets.token_urlsafe(32)
+ db.session.commit()
+ return {'success': True, 'endpoint': endpoint.to_dict(), 'secret': endpoint.secret}
+
+ @classmethod
+ def _extract_signature(cls, headers: Dict) -> tuple:
+ for key, value in headers.items():
+ if key.lower() == 'x-hub-signature-256' and isinstance(value, str):
+ return value, 'sha256'
+ if key.lower() == 'x-hub-signature' and isinstance(value, str):
+ return value, 'sha1'
+ if key.lower() == 'x-signature' and isinstance(value, str):
+ return value, 'sha256'
+ return '', ''
+
+ @classmethod
+ def _matches_filters(cls, payload: Dict, filter_paths: List[str]) -> bool:
+ """Simple dotted-path filter. Returns True if no filters or any filter matches."""
+ if not filter_paths:
+ return True
+ for path in filter_paths:
+ parts = path.strip('.').split('.')
+ node = payload
+ try:
+ for part in parts:
+ if isinstance(node, dict):
+ node = node[part]
+ elif isinstance(node, list) and part.isdigit():
+ node = node[int(part)]
+ else:
+ break
+ else:
+ return True
+ except (KeyError, IndexError, TypeError):
+ continue
+ return False
+
+ @classmethod
+ def receive(cls, slug: str, payload: bytes, headers: Dict) -> Dict:
+ """Receive an inbound webhook, verify signature, log, and optionally forward."""
+ endpoint = cls.get_endpoint_by_slug(slug)
+ if not endpoint:
+ return {'success': False, 'error': 'Endpoint not found'}, 404
+
+ event_id = headers.get('X-Webhook-Event-ID') or headers.get('x-webhook-event-id') or str(uuid.uuid4())
+
+ # Avoid duplicate deliveries
+ if WebhookDelivery.query.filter_by(event_id=event_id).first():
+ return {'success': True, 'message': 'Duplicate delivery ignored', 'event_id': event_id}, 200
+
+ signature_header, algorithm = cls._extract_signature(headers)
+ signature_valid = endpoint.verify_signature(payload, signature_header, algorithm)
+
+ delivery = WebhookDelivery(
+ endpoint_id=endpoint.id,
+ event_id=event_id,
+ payload=payload.decode('utf-8', errors='replace') if payload else None,
+ signature_valid=signature_valid,
+ )
+ delivery.set_headers(headers)
+ db.session.add(delivery)
+ db.session.commit()
+
+ if not signature_valid and signature_header:
+ delivery.status = 'failed'
+ delivery.error_message = 'Invalid signature'
+ delivery.completed_at = datetime.utcnow()
+ db.session.commit()
+ return {'success': False, 'error': 'Invalid signature', 'event_id': event_id}, 401
+
+ try:
+ payload_json = json.loads(payload.decode('utf-8', errors='replace')) if payload else {}
+ except Exception:
+ payload_json = {}
+
+ if not cls._matches_filters(payload_json, endpoint.get_filter_paths()):
+ delivery.status = 'filtered'
+ delivery.completed_at = datetime.utcnow()
+ db.session.commit()
+ return {'success': True, 'message': 'Filtered', 'event_id': event_id}, 200
+
+ if endpoint.forward_url:
+ forwarded = cls._forward(endpoint, delivery, payload, headers)
+ delivery.response_status = forwarded.get('status')
+ delivery.response_body = forwarded.get('body', '')[:2000]
+ if forwarded.get('success'):
+ delivery.status = 'forwarded'
+ else:
+ delivery.status = 'failed'
+ delivery.error_message = forwarded.get('error')
+ else:
+ delivery.status = 'received'
+
+ delivery.completed_at = datetime.utcnow()
+ db.session.commit()
+ return {'success': True, 'event_id': event_id, 'status': delivery.status}, 200
+
+ @classmethod
+ def _forward(cls, endpoint: WebhookEndpoint, delivery: WebhookDelivery,
+ payload: bytes, headers: Dict) -> Dict:
+ forward_headers = {
+ 'Content-Type': headers.get('Content-Type', 'application/json'),
+ 'X-Webhook-Event-ID': delivery.event_id,
+ 'X-Webhook-Source': 'serverkit-gateway',
+ }
+ for attempt in range(max(1, endpoint.retry_count)):
+ try:
+ resp = requests.post(
+ endpoint.forward_url,
+ data=payload,
+ headers=forward_headers,
+ timeout=30,
+ verify=True,
+ )
+ return {
+ 'success': 200 <= resp.status_code < 300,
+ 'status': resp.status_code,
+ 'body': resp.text[:1000]
+ }
+ except Exception as e:
+ if attempt == max(1, endpoint.retry_count) - 1:
+ return {'success': False, 'error': str(e)}
+ return {'success': False, 'error': 'Forward failed'}
+
+ @classmethod
+ def list_deliveries(cls, endpoint_id: int, limit: int = 50, status: str = None) -> List[Dict]:
+ query = WebhookDelivery.query.filter_by(endpoint_id=endpoint_id)
+ if status:
+ query = query.filter_by(status=status)
+ deliveries = query.order_by(WebhookDelivery.received_at.desc()).limit(limit).all()
+ return [d.to_dict() for d in deliveries]
+
+ @classmethod
+ def get_delivery(cls, delivery_id: int) -> Optional[WebhookDelivery]:
+ return WebhookDelivery.query.get(delivery_id)
+
+ @classmethod
+ def replay_delivery(cls, delivery_id: int) -> Dict:
+ delivery = cls.get_delivery(delivery_id)
+ if not delivery:
+ return {'success': False, 'error': 'Delivery not found'}
+ endpoint = delivery.endpoint
+ if not endpoint or not endpoint.forward_url:
+ return {'success': False, 'error': 'Endpoint has no forward URL'}
+ payload = (delivery.payload or '').encode('utf-8')
+ headers = delivery.get_headers()
+ result = cls._forward(endpoint, delivery, payload, headers)
+ delivery.response_status = result.get('status')
+ delivery.response_body = result.get('body', '')[:2000]
+ delivery.status = 'forwarded' if result.get('success') else 'failed'
+ delivery.error_message = result.get('error')
+ delivery.completed_at = datetime.utcnow()
+ db.session.commit()
+ return {'success': result.get('success', False), 'delivery': delivery.to_dict()}
diff --git a/backend/migrations/versions/020_secrets_webhooks.py b/backend/migrations/versions/020_secrets_webhooks.py
new file mode 100644
index 00000000..c60429e7
--- /dev/null
+++ b/backend/migrations/versions/020_secrets_webhooks.py
@@ -0,0 +1,150 @@
+"""Secrets manager and inbound webhook gateway.
+
+Adds:
+- secret_vaults table
+- secrets table
+- webhook_endpoints table
+- webhook_deliveries table
+
+Revision ID: 020_secrets_webhooks
+Revises: 019_passkey_credentials
+Create Date: 2026-06-19
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = '020_secrets_webhooks'
+down_revision = '019_passkey_credentials'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ tables = inspector.get_table_names()
+
+ if 'secret_vaults' not in tables:
+ op.create_table(
+ 'secret_vaults',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('name', sa.String(length=200), nullable=False),
+ sa.Column('slug', sa.String(length=220), nullable=False),
+ sa.Column('description', sa.Text(), nullable=True),
+ sa.Column('created_by', sa.Integer(), nullable=True),
+ sa.Column('created_at', sa.DateTime(), nullable=True),
+ sa.Column('updated_at', sa.DateTime(), nullable=True),
+ sa.ForeignKeyConstraint(['created_by'], ['users.id']),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('name'),
+ sa.UniqueConstraint('slug')
+ )
+ op.create_index(
+ op.f('ix_secret_vaults_created_by'),
+ 'secret_vaults',
+ ['created_by'],
+ unique=False
+ )
+
+ if 'secrets' not in tables:
+ op.create_table(
+ 'secrets',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('vault_id', sa.Integer(), nullable=False),
+ sa.Column('name', sa.String(length=200), nullable=False),
+ sa.Column('encrypted_value', sa.Text(), nullable=False),
+ sa.Column('description', sa.Text(), nullable=True),
+ sa.Column('expires_at', sa.DateTime(), nullable=True),
+ sa.Column('created_at', sa.DateTime(), nullable=True),
+ sa.Column('updated_at', sa.DateTime(), nullable=True),
+ sa.ForeignKeyConstraint(['vault_id'], ['secret_vaults.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('vault_id', 'name')
+ )
+ op.create_index(
+ op.f('ix_secrets_vault_id'),
+ 'secrets',
+ ['vault_id'],
+ unique=False
+ )
+
+ if 'webhook_endpoints' not in tables:
+ op.create_table(
+ 'webhook_endpoints',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('name', sa.String(length=200), nullable=False),
+ sa.Column('slug', sa.String(length=220), nullable=False),
+ sa.Column('secret', sa.String(length=500), nullable=False),
+ sa.Column('forward_url', sa.String(length=500), nullable=True),
+ sa.Column('filter_paths', sa.Text(), nullable=True),
+ sa.Column('retry_count', sa.Integer(), nullable=True),
+ sa.Column('is_active', sa.Boolean(), nullable=True),
+ sa.Column('created_by', sa.Integer(), nullable=True),
+ sa.Column('created_at', sa.DateTime(), nullable=True),
+ sa.Column('updated_at', sa.DateTime(), nullable=True),
+ sa.ForeignKeyConstraint(['created_by'], ['users.id']),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('name'),
+ sa.UniqueConstraint('slug')
+ )
+ op.create_index(
+ op.f('ix_webhook_endpoints_created_by'),
+ 'webhook_endpoints',
+ ['created_by'],
+ unique=False
+ )
+
+ if 'webhook_deliveries' not in tables:
+ op.create_table(
+ 'webhook_deliveries',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('endpoint_id', sa.Integer(), nullable=False),
+ sa.Column('event_id', sa.String(length=300), nullable=False),
+ sa.Column('payload', sa.Text(), nullable=True),
+ sa.Column('headers', sa.Text(), nullable=True),
+ sa.Column('signature_valid', sa.Boolean(), nullable=True),
+ sa.Column('status', sa.String(length=50), nullable=True),
+ sa.Column('response_status', sa.Integer(), nullable=True),
+ sa.Column('response_body', sa.Text(), nullable=True),
+ sa.Column('error_message', sa.Text(), nullable=True),
+ sa.Column('received_at', sa.DateTime(), nullable=True),
+ sa.Column('completed_at', sa.DateTime(), nullable=True),
+ sa.ForeignKeyConstraint(['endpoint_id'], ['webhook_endpoints.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('endpoint_id', 'event_id')
+ )
+ op.create_index(
+ op.f('ix_webhook_deliveries_endpoint_id'),
+ 'webhook_deliveries',
+ ['endpoint_id'],
+ unique=False
+ )
+ op.create_index(
+ op.f('ix_webhook_deliveries_event_id'),
+ 'webhook_deliveries',
+ ['event_id'],
+ unique=False
+ )
+
+
+def downgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ tables = inspector.get_table_names()
+
+ if 'webhook_deliveries' in tables:
+ op.drop_index(op.f('ix_webhook_deliveries_event_id'), table_name='webhook_deliveries')
+ op.drop_index(op.f('ix_webhook_deliveries_endpoint_id'), table_name='webhook_deliveries')
+ op.drop_table('webhook_deliveries')
+
+ if 'webhook_endpoints' in tables:
+ op.drop_index(op.f('ix_webhook_endpoints_created_by'), table_name='webhook_endpoints')
+ op.drop_table('webhook_endpoints')
+
+ if 'secrets' in tables:
+ op.drop_index(op.f('ix_secrets_vault_id'), table_name='secrets')
+ op.drop_table('secrets')
+
+ if 'secret_vaults' in tables:
+ op.drop_index(op.f('ix_secret_vaults_created_by'), table_name='secret_vaults')
+ op.drop_table('secret_vaults')
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index b712387c..266fdcf3 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -51,6 +51,7 @@ import StatusPages from './pages/StatusPages';
import PublicStatusPage from './pages/PublicStatusPage';
import CloudProvision from './pages/CloudProvision';
import Marketplace from './pages/Marketplace';
+import SecretsWebhooks from './pages/SecretsWebhooks';
import StyleGuide from './pages/StyleGuide';
import AppMap from './pages/AppMap';
import Documentation from './pages/Documentation';
@@ -98,6 +99,8 @@ const PAGE_TITLES = {
'/status-pages': 'Status Pages',
'/cloud': 'Cloud Provisioning',
'/marketplace': 'Marketplace',
+ '/secrets': 'Secrets & Webhooks',
+ '/secrets/:tab': 'Secrets & Webhooks',
'/style-guide': 'Style Guide',
'/app-map': 'App Map',
'/documentation': 'Documentation',
@@ -301,6 +304,8 @@ function AppRoutes() {
<Route path="email/:tab" element={<Email />} />
<Route path="terminal" element={<Terminal />} />
<Route path="terminal/:tab" element={<Terminal />} />
+ <Route path="secrets" element={<SecretsWebhooks />} />
+ <Route path="secrets/:tab" element={<SecretsWebhooks />} />
<Route path="settings" element={<Settings />} />
<Route path="settings/:tab" element={<Settings />} />
{dashboardRoutes}
diff --git a/frontend/src/components/sidebarItems.js b/frontend/src/components/sidebarItems.js
index 63feb479..83a20635 100644
--- a/frontend/src/components/sidebarItems.js
+++ b/frontend/src/components/sidebarItems.js
@@ -161,6 +161,13 @@ export const SIDEBAR_ITEMS = [
category: 'system',
icon: '<path d="M4 17l6-6-6-6M12 19h8"/>'
},
+ {
+ id: 'secrets',
+ label: 'Secrets & Webhooks',
+ route: '/secrets',
+ category: 'system',
+ icon: '<path d="M12 2a10 10 0 1 0 10 10A10 10 0 0 0 12 2zm0 18a8 8 0 1 1 8-8 8 8 0 0 1-8 8z"/><circle cx="12" cy="12" r="2"/><path d="M12 12v-6"/><path d="M16 12h3"/><path d="M8 12H5"/>'
+ },
{
// Redesign: Marketplace uses the top-bar layout (REDESIGN_MAP §6 dec. 3).
// Downloads now lives in the page's top bar (PageTopbar MARKET_TABS), not
diff --git a/frontend/src/pages/SecretsWebhooks.jsx b/frontend/src/pages/SecretsWebhooks.jsx
new file mode 100644
index 00000000..ad64a191
--- /dev/null
+++ b/frontend/src/pages/SecretsWebhooks.jsx
@@ -0,0 +1,548 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import { useNavigate, useParams } from 'react-router-dom';
+import api from '../services/api';
+import { PageTopbar } from '@/components/ds';
+import { Tabs, TabsList, TabsTrigger, TabsContent } from '@/components/ui/tabs';
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Textarea } from '@/components/ui/textarea';
+import { Badge } from '@/components/ui/badge';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, DialogFooter } from '@/components/ui/dialog';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from '@/components/ui/dropdown-menu';
+import { useToast } from '../contexts/ToastContext';
+import { KeyRound, Webhook, Plus, MoreVertical, Copy, Eye, EyeOff, Trash2, RefreshCw, ArrowRightLeft } from 'lucide-react';
+import EmptyState from '../components/EmptyState';
+
+const VALID_TABS = ['vaults', 'webhooks'];
+
+const formatDate = (d) => (d ? new Date(d).toLocaleString() : '—');
+
+export default function SecretsWebhooks() {
+ const { tab } = useParams();
+ const navigate = useNavigate();
+ const { toast } = useToast();
+ const activeTab = VALID_TABS.includes(tab) ? tab : 'vaults';
+
+ const [vaults, setVaults] = useState([]);
+ const [endpoints, setEndpoints] = useState([]);
+ const [loading, setLoading] = useState(true);
+
+ // Vault modals
+ const [vaultForm, setVaultForm] = useState({ open: false, name: '', description: '' });
+ const [selectedVault, setSelectedVault] = useState(null);
+ const [secretForm, setSecretForm] = useState({ open: false, name: '', value: '', description: '' });
+ const [revealSecretId, setRevealSecretId] = useState(null);
+ const [revealedValue, setRevealedValue] = useState('');
+
+ // Webhook modals
+ const [endpointForm, setEndpointForm] = useState({ open: false, name: '', forward_url: '', filter_paths: '', retry_count: 3 });
+ const [selectedEndpoint, setSelectedEndpoint] = useState(null);
+ const [deliveries, setDeliveries] = useState([]);
+ const [regeneratedSecret, setRegeneratedSecret] = useState(null);
+
+ useEffect(() => {
+ loadAll();
+ }, []);
+
+ async function loadAll() {
+ setLoading(true);
+ try {
+ const [v, e] = await Promise.all([api.listVaults(), api.listWebhookEndpoints()]);
+ setVaults(v.vaults || []);
+ setEndpoints(e.endpoints || []);
+ } catch (err) {
+ toast.error(`Load failed: ${err.message}`);
+ } finally {
+ setLoading(false);
+ }
+ }
+
+ async function createVault(e) {
+ e.preventDefault();
+ try {
+ await api.createVault({ name: vaultForm.name, description: vaultForm.description });
+ setVaultForm({ open: false, name: '', description: '' });
+ loadAll();
+ toast.success('Vault created');
+ } catch (err) {
+ toast.error(`Failed to create vault: ${err.message}`);
+ }
+ }
+
+ async function deleteVault(id) {
+ if (!confirm('Delete this vault and all its secrets?')) return;
+ try {
+ await api.deleteVault(id);
+ if (selectedVault?.id === id) setSelectedVault(null);
+ loadAll();
+ toast.success('Vault deleted');
+ } catch (err) {
+ toast.error(`Failed to delete vault: ${err.message}`);
+ }
+ }
+
+ async function createSecret(e) {
+ e.preventDefault();
+ try {
+ await api.createSecret(selectedVault.id, {
+ name: secretForm.name,
+ value: secretForm.value,
+ description: secretForm.description,
+ });
+ setSecretForm({ open: false, name: '', value: '', description: '' });
+ openVault(selectedVault.id);
+ toast.success('Secret created')
+ } catch (err) {
+ toast.error(`Failed to create secret: ${err.message}`)
+ }
+ }
+
+ async function openVault(id) {
+ try {
+ const { vault } = await api.getVault(id);
+ const { secrets } = await api.listSecrets(id);
+ setSelectedVault({ ...vault, secrets });
+ } catch (err) {
+ toast.error(`Failed to load vault: ${err.message}`)
+ }
+ }
+
+ async function revealSecret(secret) {
+ try {
+ const { secret: data } = await api.revealSecret(secret.id);
+ setRevealSecretId(secret.id);
+ setRevealedValue(data.value || '');
+ } catch (err) {
+ toast.error(`Reveal failed: ${err.message}`)
+ }
+ }
+
+ async function deleteSecret(id) {
+ if (!confirm('Delete this secret?')) return;
+ try {
+ await api.deleteSecret(id);
+ openVault(selectedVault.id);
+ toast.success('Secret deleted')
+ } catch (err) {
+ toast.error(`Failed to delete secret: ${err.message}`)
+ }
+ }
+
+ async function createEndpoint(e) {
+ e.preventDefault();
+ try {
+ const paths = endpointForm.filter_paths.split('\n').map(s => s.trim()).filter(Boolean);
+ await api.createWebhookEndpoint({
+ name: endpointForm.name,
+ forward_url: endpointForm.forward_url,
+ filter_paths: paths,
+ retry_count: parseInt(endpointForm.retry_count, 10) || 3,
+ });
+ setEndpointForm({ open: false, name: '', forward_url: '', filter_paths: '', retry_count: 3 });
+ loadAll();
+ toast.success('Endpoint created')
+ } catch (err) {
+ toast.error(`Failed to create endpoint: ${err.message}`)
+ }
+ }
+
+ async function deleteEndpoint(id) {
+ if (!confirm('Delete this webhook endpoint?')) return;
+ try {
+ await api.deleteWebhookEndpoint(id);
+ if (selectedEndpoint?.id === id) setSelectedEndpoint(null);
+ loadAll();
+ toast.success('Endpoint deleted')
+ } catch (err) {
+ toast.error(`Failed to delete endpoint: ${err.message}`)
+ }
+ }
+
+ async function regenerateSecret(id) {
+ try {
+ const data = await api.regenerateWebhookSecret(id);
+ setRegeneratedSecret({ name: data.endpoint.name, secret: data.secret });
+ loadAll();
+ if (selectedEndpoint?.id === id) openEndpoint(data.endpoint.id);
+ } catch (err) {
+ toast.error(`Regenerate failed: ${err.message}`)
+ }
+ }
+
+ async function openEndpoint(id) {
+ try {
+ const { endpoint } = await api.getWebhookEndpoint(id);
+ const { deliveries } = await api.listWebhookDeliveries(id, { limit: 50 });
+ setSelectedEndpoint(endpoint);
+ setDeliveries(deliveries || []);
+ } catch (err) {
+ toast.error(`Failed to load endpoint: ${err.message}`)
+ }
+ }
+
+ async function replayDelivery(deliveryId) {
+ try {
+ await api.replayWebhookDelivery(deliveryId);
+ openEndpoint(selectedEndpoint.id);
+ toast.success('Replayed delivery')
+ } catch (err) {
+ toast.error(`Replay failed: ${err.message}`)
+ }
+ }
+
+ const receiverUrl = useMemo(() => {
+ if (!selectedEndpoint) return '';
+ const base = window.location.origin.replace(/\/$/, '');
+ return `${base}/api/v1/webhooks/receive/${selectedEndpoint.slug}`;
+ }, [selectedEndpoint]);
+
+ if (loading) {
+ return (
+ <div className="page-container secrets-page">
+ <EmptyState loading title="Loading secrets & webhooks..." />
+ </div>
+ );
+ }
+
+ return (
+ <div className="page-container secrets-page">
+ <PageTopbar icon={<KeyRound size={18} />} title="Secrets & Webhooks" />
+
+ <Tabs value={activeTab} onValueChange={(v) => navigate(`/secrets/${v}`)} className="tabs">
+ <TabsList>
+ <TabsTrigger value="vaults"><KeyRound size={14} /> Vaults</TabsTrigger>
+ <TabsTrigger value="webhooks"><Webhook size={14} /> Webhooks</TabsTrigger>
+ </TabsList>
+
+ <TabsContent value="vaults" className="tab-content">
+ {!selectedVault ? (
+ <Card>
+ <CardHeader>
+ <div className="secrets__header">
+ <div>
+ <CardTitle>Secret Vaults</CardTitle>
+ <CardDescription>Encrypted key/value stores for credentials and tokens.</CardDescription>
+ </div>
+ <Button onClick={() => setVaultForm({ open: true, name: '', description: '' })}>
+ <Plus size={14} /> New Vault
+ </Button>
+ </div>
+ </CardHeader>
+ <CardContent>
+ {vaults.length === 0 ? (
+ <EmptyState title="No vaults yet" description="Create a vault to start storing secrets." />
+ ) : (
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead>Name</TableHead>
+ <TableHead>Description</TableHead>
+ <TableHead>Secrets</TableHead>
+ <TableHead className="text-right">Actions</TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {vaults.map(vault => (
+ <TableRow key={vault.id} className="cursor-pointer" onClick={() => openVault(vault.id)}>
+ <TableCell className="font-medium">{vault.name}</TableCell>
+ <TableCell>{vault.description || '—'}</TableCell>
+ <TableCell>{vault.secret_count ?? '—'}</TableCell>
+ <TableCell className="text-right">
+ <DropdownMenu>
+ <DropdownMenuTrigger asChild onClick={(e) => e.stopPropagation()}>
+ <Button variant="ghost" size="icon"><MoreVertical size={14} /></Button>
+ </DropdownMenuTrigger>
+ <DropdownMenuContent align="end">
+ <DropdownMenuItem onClick={() => openVault(vault.id)}>Open</DropdownMenuItem>
+ <DropdownMenuItem className="text-destructive" onClick={() => deleteVault(vault.id)}>Delete</DropdownMenuItem>
+ </DropdownMenuContent>
+ </DropdownMenu>
+ </TableCell>
+ </TableRow>
+ ))}
+ </TableBody>
+ </Table>
+ )}
+ </CardContent>
+ </Card>
+ ) : (
+ <Card>
+ <CardHeader>
+ <div className="secrets__header">
+ <div>
+ <Button variant="ghost" size="sm" onClick={() => setSelectedVault(null)}>← Back</Button>
+ <CardTitle className="mt-2">{selectedVault.name}</CardTitle>
+ <CardDescription>{selectedVault.description || 'No description'}</CardDescription>
+ </div>
+ <Button onClick={() => setSecretForm({ open: true, name: '', value: '', description: '' })}>
+ <Plus size={14} /> Add Secret
+ </Button>
+ </div>
+ </CardHeader>
+ <CardContent>
+ {(selectedVault.secrets || []).length === 0 ? (
+ <EmptyState title="No secrets yet" description="Add your first secret to this vault." />
+ ) : (
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead>Name</TableHead>
+ <TableHead>Value</TableHead>
+ <TableHead>Description</TableHead>
+ <TableHead>Updated</TableHead>
+ <TableHead className="text-right">Actions</TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {selectedVault.secrets.map(secret => {
+ const revealed = revealSecretId === secret.id;
+ return (
+ <TableRow key={secret.id}>
+ <TableCell className="font-medium">{secret.name}</TableCell>
+ <TableCell>
+ <code className="secrets__value">
+ {revealed ? revealedValue : secret.value}
+ </code>
+ </TableCell>
+ <TableCell>{secret.description || '—'}</TableCell>
+ <TableCell>{formatDate(secret.updated_at)}</TableCell>
+ <TableCell className="text-right">
+ <Button variant="ghost" size="icon" onClick={() => revealed ? setRevealSecretId(null) : revealSecret(secret)}>
+ {revealed ? <EyeOff size={14} /> : <Eye size={14} />}
+ </Button>
+ <Button variant="ghost" size="icon" onClick={() => { navigator.clipboard.writeText(revealed ? revealedValue : secret.value); toast.success('Copied') }}>
+ <Copy size={14} />
+ </Button>
+ <Button variant="ghost" size="icon" className="text-destructive" onClick={() => deleteSecret(secret.id)}>
+ <Trash2 size={14} />
+ </Button>
+ </TableCell>
+ </TableRow>
+ );
+ })}
+ </TableBody>
+ </Table>
+ )}
+ </CardContent>
+ </Card>
+ )}
+ </TabsContent>
+
+ <TabsContent value="webhooks" className="tab-content">
+ {!selectedEndpoint ? (
+ <Card>
+ <CardHeader>
+ <div className="secrets__header">
+ <div>
+ <CardTitle>Webhook Endpoints</CardTitle>
+ <CardDescription>Receive, verify, and forward inbound webhooks.</CardDescription>
+ </div>
+ <Button onClick={() => setEndpointForm({ open: true, name: '', forward_url: '', filter_paths: '', retry_count: 3 })}>
+ <Plus size={14} /> New Endpoint
+ </Button>
+ </div>
+ </CardHeader>
+ <CardContent>
+ {endpoints.length === 0 ? (
+ <EmptyState title="No webhook endpoints" description="Create an endpoint to receive webhooks." />
+ ) : (
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead>Name</TableHead>
+ <TableHead>Slug</TableHead>
+ <TableHead>Forward URL</TableHead>
+ <TableHead>Status</TableHead>
+ <TableHead className="text-right">Actions</TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {endpoints.map(ep => (
+ <TableRow key={ep.id} className="cursor-pointer" onClick={() => openEndpoint(ep.id)}>
+ <TableCell className="font-medium">{ep.name}</TableCell>
+ <TableCell>{ep.slug}</TableCell>
+ <TableCell>{ep.forward_url || '—'}</TableCell>
+ <TableCell><Badge variant={ep.is_active ? 'default' : 'secondary'}>{ep.is_active ? 'Active' : 'Inactive'}</Badge></TableCell>
+ <TableCell className="text-right">
+ <DropdownMenu>
+ <DropdownMenuTrigger asChild onClick={(e) => e.stopPropagation()}>
+ <Button variant="ghost" size="icon"><MoreVertical size={14} /></Button>
+ </DropdownMenuTrigger>
+ <DropdownMenuContent align="end">
+ <DropdownMenuItem onClick={() => openEndpoint(ep.id)}>View deliveries</DropdownMenuItem>
+ <DropdownMenuItem onClick={() => regenerateSecret(ep.id)}><RefreshCw size={12} className="mr-2" /> Regenerate secret</DropdownMenuItem>
+ <DropdownMenuItem className="text-destructive" onClick={() => deleteEndpoint(ep.id)}>Delete</DropdownMenuItem>
+ </DropdownMenuContent>
+ </DropdownMenu>
+ </TableCell>
+ </TableRow>
+ ))}
+ </TableBody>
+ </Table>
+ )}
+ </CardContent>
+ </Card>
+ ) : (
+ <Card>
+ <CardHeader>
+ <div className="secrets__header">
+ <div>
+ <Button variant="ghost" size="sm" onClick={() => setSelectedEndpoint(null)}>← Back</Button>
+ <CardTitle className="mt-2">{selectedEndpoint.name}</CardTitle>
+ <CardDescription>
+ POST to <code className="secrets__code">{receiverUrl}</code>
+ </CardDescription>
+ </div>
+ <Button variant="outline" onClick={() => regenerateSecret(selectedEndpoint.id)}>
+ <RefreshCw size={14} /> Regenerate secret
+ </Button>
+ </div>
+ </CardHeader>
+ <CardContent>
+ {deliveries.length === 0 ? (
+ <EmptyState title="No deliveries yet" description="Send a test payload to see it here." />
+ ) : (
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead>Event ID</TableHead>
+ <TableHead>Status</TableHead>
+ <TableHead>Signature</TableHead>
+ <TableHead>Received</TableHead>
+ <TableHead className="text-right">Actions</TableHead>
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {deliveries.map(d => (
+ <TableRow key={d.id}>
+ <TableCell className="font-mono text-xs max-w-[200px] truncate">{d.event_id}</TableCell>
+ <TableCell><WebhookStatusBadge status={d.status} /></TableCell>
+ <TableCell>{d.signature_valid === true ? 'Valid' : d.signature_valid === false ? 'Invalid' : '—'}</TableCell>
+ <TableCell>{formatDate(d.received_at)}</TableCell>
+ <TableCell className="text-right">
+ <Button variant="ghost" size="icon" onClick={() => replayDelivery(d.id)} title="Replay">
+ <ArrowRightLeft size={14} />
+ </Button>
+ </TableCell>
+ </TableRow>
+ ))}
+ </TableBody>
+ </Table>
+ )}
+ </CardContent>
+ </Card>
+ )}
+ </TabsContent>
+ </Tabs>
+
+ <Dialog open={vaultForm.open} onOpenChange={(open) => setVaultForm({ ...vaultForm, open })}>
+ <DialogContent>
+ <DialogHeader>
+ <DialogTitle>New Vault</DialogTitle>
+ <DialogDescription>Create an encrypted vault to group secrets.</DialogDescription>
+ </DialogHeader>
+ <form onSubmit={createVault} className="space-y-4">
+ <div>
+ <Label htmlFor="vaultName">Name</Label>
+ <Input id="vaultName" value={vaultForm.name} onChange={(e) => setVaultForm({ ...vaultForm, name: e.target.value })} required />
+ </div>
+ <div>
+ <Label htmlFor="vaultDesc">Description</Label>
+ <Textarea id="vaultDesc" value={vaultForm.description} onChange={(e) => setVaultForm({ ...vaultForm, description: e.target.value })} />
+ </div>
+ <DialogFooter>
+ <Button type="submit">Create Vault</Button>
+ </DialogFooter>
+ </form>
+ </DialogContent>
+ </Dialog>
+
+ <Dialog open={secretForm.open} onOpenChange={(open) => setSecretForm({ ...secretForm, open })}>
+ <DialogContent>
+ <DialogHeader>
+ <DialogTitle>Add Secret</DialogTitle>
+ <DialogDescription>Add an encrypted secret to {selectedVault?.name}.</DialogDescription>
+ </DialogHeader>
+ <form onSubmit={createSecret} className="space-y-4">
+ <div>
+ <Label htmlFor="secretName">Name</Label>
+ <Input id="secretName" value={secretForm.name} onChange={(e) => setSecretForm({ ...secretForm, name: e.target.value })} required />
+ </div>
+ <div>
+ <Label htmlFor="secretValue">Value</Label>
+ <Textarea id="secretValue" value={secretForm.value} onChange={(e) => setSecretForm({ ...secretForm, value: e.target.value })} required />
+ </div>
+ <div>
+ <Label htmlFor="secretDesc">Description</Label>
+ <Textarea id="secretDesc" value={secretForm.description} onChange={(e) => setSecretForm({ ...secretForm, description: e.target.value })} />
+ </div>
+ <DialogFooter>
+ <Button type="submit">Save Secret</Button>
+ </DialogFooter>
+ </form>
+ </DialogContent>
+ </Dialog>
+
+ <Dialog open={endpointForm.open} onOpenChange={(open) => setEndpointForm({ ...endpointForm, open })}>
+ <DialogContent>
+ <DialogHeader>
+ <DialogTitle>New Webhook Endpoint</DialogTitle>
+ <DialogDescription>Create a slug, secret, and optional forward URL.</DialogDescription>
+ </DialogHeader>
+ <form onSubmit={createEndpoint} className="space-y-4">
+ <div>
+ <Label htmlFor="epName">Name</Label>
+ <Input id="epName" value={endpointForm.name} onChange={(e) => setEndpointForm({ ...endpointForm, name: e.target.value })} required />
+ </div>
+ <div>
+ <Label htmlFor="epForward">Forward URL (optional)</Label>
+ <Input id="epForward" type="url" value={endpointForm.forward_url} onChange={(e) => setEndpointForm({ ...endpointForm, forward_url: e.target.value })} />
+ </div>
+ <div>
+ <Label htmlFor="epFilters">Filter paths (one per line, optional)</Label>
+ <Textarea id="epFilters" value={endpointForm.filter_paths} onChange={(e) => setEndpointForm({ ...endpointForm, filter_paths: e.target.value })} placeholder="repository.full_name&#10;action" />
+ </div>
+ <div>
+ <Label htmlFor="epRetry">Retries</Label>
+ <Input id="epRetry" type="number" min={0} max={10} value={endpointForm.retry_count} onChange={(e) => setEndpointForm({ ...endpointForm, retry_count: e.target.value })} />
+ </div>
+ <DialogFooter>
+ <Button type="submit">Create Endpoint</Button>
+ </DialogFooter>
+ </form>
+ </DialogContent>
+ </Dialog>
+
+ <Dialog open={!!regeneratedSecret} onOpenChange={() => setRegeneratedSecret(null)}>
+ <DialogContent>
+ <DialogHeader>
+ <DialogTitle>Webhook Secret</DialogTitle>
+ <DialogDescription>Copy this secret now. It will not be shown again.</DialogDescription>
+ </DialogHeader>
+ <div className="space-y-2">
+ <Label>Endpoint</Label>
+ <Input readOnly value={regeneratedSecret?.name || ''} />
+ <Label>Secret</Label>
+ <div className="flex gap-2">
+ <Input readOnly type="text" value={regeneratedSecret?.secret || ''} />
+ <Button variant="outline" onClick={() => { navigator.clipboard.writeText(regeneratedSecret?.secret || ''); toast.success('Copied') }}>
+ <Copy size={14} />
+ </Button>
+ </div>
+ </div>
+ <DialogFooter>
+ <Button onClick={() => setRegeneratedSecret(null)}>Done</Button>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
+ </div>
+ );
+}
+
+function WebhookStatusBadge({ status }) {
+ const variant = status === 'forwarded' ? 'default' : status === 'received' ? 'secondary' : status === 'filtered' ? 'outline' : 'destructive';
+ return <Badge variant={variant}>{status}</Badge>;
+}
diff --git a/frontend/src/services/api/index.js b/frontend/src/services/api/index.js
index 4e623052..1dc47a10 100644
--- a/frontend/src/services/api/index.js
+++ b/frontend/src/services/api/index.js
@@ -16,6 +16,7 @@ import * as sourceConnectionMethods from './sourceConnections.js';
import * as connectionMethods from './connections.js';
import * as aiMethods from './ai.js';
import * as tunnelMethods from './tunnels.js';
+import * as secretsWebhooksMethods from './secretsWebhooks.js';
class ApiService extends ApiClient {
constructor() {
@@ -39,6 +40,7 @@ class ApiService extends ApiClient {
connectionMethods,
aiMethods,
tunnelMethods,
+ secretsWebhooksMethods,
];
for (const mod of modules) {
for (const [key, fn] of Object.entries(mod)) {
diff --git a/frontend/src/services/api/secretsWebhooks.js b/frontend/src/services/api/secretsWebhooks.js
new file mode 100644
index 00000000..af963723
--- /dev/null
+++ b/frontend/src/services/api/secretsWebhooks.js
@@ -0,0 +1,82 @@
+// Secrets manager + inbound webhook gateway API methods
+
+export async function listVaults() {
+ return this.get('/vaults');
+}
+
+export async function createVault(data) {
+ return this.post('/vaults', data);
+}
+
+export async function getVault(id) {
+ return this.get(`/vaults/${id}`);
+}
+
+export async function updateVault(id, data) {
+ return this.patch(`/vaults/${id}`, data);
+}
+
+export async function deleteVault(id) {
+ return this.delete(`/vaults/${id}`);
+}
+
+export async function listSecrets(vaultId) {
+ return this.get(`/vaults/${vaultId}/secrets`);
+}
+
+export async function createSecret(vaultId, data) {
+ return this.post(`/vaults/${vaultId}/secrets`, data);
+}
+
+export async function bulkCreateSecrets(vaultId, secrets) {
+ return this.post(`/vaults/${vaultId}/secrets/bulk`, { secrets });
+}
+
+export async function getSecret(id) {
+ return this.get(`/secrets/${id}`);
+}
+
+export async function updateSecret(id, data) {
+ return this.patch(`/secrets/${id}`, data);
+}
+
+export async function revealSecret(id) {
+ return this.post(`/secrets/${id}/reveal`);
+}
+
+export async function deleteSecret(id) {
+ return this.delete(`/secrets/${id}`);
+}
+
+export async function listWebhookEndpoints() {
+ return this.get('/webhooks/endpoints');
+}
+
+export async function createWebhookEndpoint(data) {
+ return this.post('/webhooks/endpoints', data);
+}
+
+export async function getWebhookEndpoint(id) {
+ return this.get(`/webhooks/endpoints/${id}`);
+}
+
+export async function updateWebhookEndpoint(id, data) {
+ return this.patch(`/webhooks/endpoints/${id}`, data);
+}
+
+export async function regenerateWebhookSecret(id) {
+ return this.post(`/webhooks/endpoints/${id}/regenerate-secret`);
+}
+
+export async function deleteWebhookEndpoint(id) {
+ return this.delete(`/webhooks/endpoints/${id}`);
+}
+
+export async function listWebhookDeliveries(endpointId, params = {}) {
+ const query = new URLSearchParams(params).toString();
+ return this.get(`/webhooks/endpoints/${endpointId}/deliveries${query ? `?${query}` : ''}`);
+}
+
+export async function replayWebhookDelivery(deliveryId) {
+ return this.post(`/webhooks/deliveries/${deliveryId}/replay`);
+}
diff --git a/frontend/src/styles/main.scss b/frontend/src/styles/main.scss
index e72ac2ea..d9ef9ebe 100644
--- a/frontend/src/styles/main.scss
+++ b/frontend/src/styles/main.scss
@@ -112,3 +112,4 @@
@import 'pages/_marketplace';
@import 'pages/_style-guide';
@import 'pages/_app-map';
+@import 'pages/_secrets';
diff --git a/frontend/src/styles/pages/_secrets.scss b/frontend/src/styles/pages/_secrets.scss
new file mode 100644
index 00000000..91cadb13
--- /dev/null
+++ b/frontend/src/styles/pages/_secrets.scss
@@ -0,0 +1,33 @@
+.secrets-page {
+ .tabs {
+ margin-top: $spacing-lg;
+ }
+
+ .tab-content {
+ margin-top: $spacing-md;
+ }
+
+ .secrets__header {
+ display: flex;
+ align-items: flex-start;
+ justify-content: space-between;
+ gap: $spacing-md;
+ }
+
+ .secrets__code {
+ background: var(--bg-tertiary);
+ padding: $spacing-xs $spacing-sm;
+ border-radius: $radius-sm;
+ font-family: $font-mono;
+ font-size: 0.85rem;
+ word-break: break-all;
+ }
+
+ .secrets__value {
+ background: var(--bg-tertiary);
+ padding: $spacing-xs $spacing-sm;
+ border-radius: $radius-sm;
+ font-family: $font-mono;
+ font-size: 0.8rem;
+ }
+}