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: add secrets manager and inbound webhook gateway
Juan Denisbf9fee131e2c
diff --git a/.env.example b/.env.exampleindex 84ed8843..9394618e 100644--- a/.env.example+++ b/.env.example@@ -11,6 +11,9 @@# Generate unique keys for production!SECRET_KEY=your-secret-key-hereJWT_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 Configurationdiff --git a/backend/app/__init__.py b/backend/app/__init__.pyindex 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_bpapp.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 Jobsfrom app.api.cron import cron_bpapp.register_blueprint(cron_bp, url_prefix='/api/v1/cron')diff --git a/backend/app/api/secrets_webhooks.py b/backend/app/api/secrets_webhooks.pynew file mode 100644index 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, statusdiff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex d4799fe2..2dd53349 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -39,6 +39,8 @@ from app.models.plugin import InstalledPluginfrom app.models.ai import AiConversation, AiMessage, AiPendingActionfrom app.models.image_scan import ImageVulnerabilityScan, SbomArtifactfrom 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.pynew file mode 100644index 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 resultdiff --git a/backend/app/models/webhook_gateway.py b/backend/app/models/webhook_gateway.pynew file mode 100644index 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.pynew file mode 100644index 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 envdiff --git a/backend/app/services/webhook_gateway_service.py b/backend/app/services/webhook_gateway_service.pynew file mode 100644index 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.pynew file mode 100644index 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.jsxindex 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.jsindex 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), notdiff --git a/frontend/src/pages/SecretsWebhooks.jsx b/frontend/src/pages/SecretsWebhooks.jsxnew file mode 100644index 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 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.jsindex 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.jsnew file mode 100644index 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.scssindex 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.scssnew file mode 100644index 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;+ }+}