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(secrets): scope vaults & webhooks to the active workspace

Juan Deniscb83d24f7c63
diff --git a/backend/app/api/secrets_webhooks.py b/backend/app/api/secrets_webhooks.py
index 48741c25..56e3874d 100644
--- a/backend/app/api/secrets_webhooks.py
+++ b/backend/app/api/secrets_webhooks.py
@@ -16,6 +16,18 @@ def _current_user_id() -> int:
return int(identity) if identity else None
+def _resolve_ws():
+ """Resolve the active workspace context (X-Workspace-Id header or
+ ?workspace_id) to a workspace id, or None for an unscoped view — mirrors the
+ servers/apps scoping (#33). Lenient: a stale/unknown context degrades to
+ None rather than erroring."""
+ from app.models import User
+ from app.services.workspace_service import WorkspaceService
+ user = User.query.get(get_jwt_identity())
+ return WorkspaceService.resolve_workspace_id(
+ user, request.headers.get('X-Workspace-Id') or request.args.get('workspace_id'))
+
+
def _json_or_form() -> dict:
"""Return JSON body if available, otherwise an empty dict."""
if request.is_json:
@@ -38,7 +50,7 @@ def admin_required(fn):
@bp.route('/vaults', methods=['GET'])
@jwt_required()
def list_vaults():
- return {'success': True, 'vaults': SecretVaultService.list_vaults()}
+ return {'success': True, 'vaults': SecretVaultService.list_vaults(workspace_id=_resolve_ws())}
@bp.route('/vaults', methods=['POST'])
@@ -48,7 +60,8 @@ def create_vault():
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())
+ result = SecretVaultService.create_vault(name, description=data.get('description'),
+ user_id=_current_user_id(), workspace_id=_resolve_ws())
if not result.get('success'):
return {'error': result.get('error')}, 409
return result, 201
@@ -175,7 +188,7 @@ def delete_secret(secret_id):
@bp.route('/webhooks/endpoints', methods=['GET'])
@jwt_required()
def list_webhook_endpoints():
- return {'success': True, 'endpoints': WebhookGatewayService.list_endpoints()}
+ return {'success': True, 'endpoints': WebhookGatewayService.list_endpoints(workspace_id=_resolve_ws())}
@bp.route('/webhooks/endpoints', methods=['POST'])
@@ -192,6 +205,7 @@ def create_webhook_endpoint():
filter_paths=data.get('filter_paths'),
retry_count=data.get('retry_count', 3),
user_id=_current_user_id(),
+ workspace_id=_resolve_ws(),
)
if not result.get('success'):
return {'error': result.get('error')}, 409
diff --git a/backend/app/models/secret_vault.py b/backend/app/models/secret_vault.py
index bbdcc1ce..627e71ae 100644
--- a/backend/app/models/secret_vault.py
+++ b/backend/app/models/secret_vault.py
@@ -13,6 +13,9 @@ class SecretVault(db.Model):
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)
+ # Workspace scoping (#33): a vault belongs to a workspace. Backfilled to the
+ # Default workspace by migration 021; new rows are stamped on create.
+ workspace_id = db.Column(db.Integer, db.ForeignKey('workspaces.id'), nullable=True, index=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@@ -24,6 +27,7 @@ class SecretVault(db.Model):
'name': self.name,
'slug': self.slug,
'description': self.description,
+ 'workspace_id': self.workspace_id,
'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,
diff --git a/backend/app/models/webhook_gateway.py b/backend/app/models/webhook_gateway.py
index 4445dd1b..614e1810 100644
--- a/backend/app/models/webhook_gateway.py
+++ b/backend/app/models/webhook_gateway.py
@@ -19,6 +19,8 @@ class WebhookEndpoint(db.Model):
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)
+ # Workspace scoping (#33): backfilled to the Default workspace by migration 021.
+ workspace_id = db.Column(db.Integer, db.ForeignKey('workspaces.id'), nullable=True, index=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@@ -56,6 +58,7 @@ class WebhookEndpoint(db.Model):
'filter_paths': self.get_filter_paths(),
'forward_url': self.forward_url,
'retry_count': self.retry_count,
+ 'workspace_id': self.workspace_id,
'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,
diff --git a/backend/app/services/secret_vault_service.py b/backend/app/services/secret_vault_service.py
index fc36d45a..1937d0f3 100644
--- a/backend/app/services/secret_vault_service.py
+++ b/backend/app/services/secret_vault_service.py
@@ -32,15 +32,19 @@ 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()]
+ def list_vaults(cls, workspace_id: int = None) -> List[Dict]:
+ query = SecretVault.query
+ if workspace_id is not None:
+ query = query.filter(SecretVault.workspace_id == workspace_id)
+ return [v.to_dict() for v in 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:
+ def create_vault(cls, name: str, description: str = None, user_id: int = None,
+ workspace_id: int = None) -> Dict:
if SecretVault.query.filter_by(name=name).first():
return {'success': False, 'error': 'Vault name already exists'}
vault = SecretVault(
@@ -48,6 +52,7 @@ class SecretVaultService:
slug=_unique_slug(name),
description=description,
created_by=user_id,
+ workspace_id=workspace_id,
)
db.session.add(vault)
db.session.commit()
diff --git a/backend/app/services/webhook_gateway_service.py b/backend/app/services/webhook_gateway_service.py
index 5471102e..ddbaf3cd 100644
--- a/backend/app/services/webhook_gateway_service.py
+++ b/backend/app/services/webhook_gateway_service.py
@@ -21,8 +21,11 @@ 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()]
+ def list_endpoints(cls, workspace_id: int = None) -> List[Dict]:
+ query = WebhookEndpoint.query
+ if workspace_id is not None:
+ query = query.filter(WebhookEndpoint.workspace_id == workspace_id)
+ return [e.to_dict() for e in query.order_by(WebhookEndpoint.name).all()]
@classmethod
def get_endpoint(cls, endpoint_id: int) -> Optional[WebhookEndpoint]:
@@ -50,7 +53,7 @@ class WebhookGatewayService:
@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:
+ user_id: int = None, workspace_id: int = None) -> Dict:
if WebhookEndpoint.query.filter_by(name=name).first():
return {'success': False, 'error': 'Endpoint name already exists'}
endpoint = WebhookEndpoint(
@@ -60,6 +63,7 @@ class WebhookGatewayService:
forward_url=forward_url,
retry_count=retry_count,
created_by=user_id,
+ workspace_id=workspace_id,
)
if filter_paths:
endpoint.set_filter_paths(filter_paths)
diff --git a/backend/migrations/versions/021_secrets_webhooks_workspace.py b/backend/migrations/versions/021_secrets_webhooks_workspace.py
new file mode 100644
index 00000000..b6b25283
--- /dev/null
+++ b/backend/migrations/versions/021_secrets_webhooks_workspace.py
@@ -0,0 +1,97 @@
+"""Workspace-scope secrets & webhooks (#33 follow-up).
+
+Adds:
+- secret_vaults.workspace_id (nullable FK -> workspaces.id)
+- webhook_endpoints.workspace_id (nullable FK -> workspaces.id)
+
+Backfill (idempotent, raw SQL like 015_workspace_scope): attach every
+workspace-less vault/endpoint to the "Default" workspace, so nothing disappears
+once secrets scoping is active.
+
+Scoping itself is opt-in (a request only filters by workspace when it carries a
+workspace context), so this migration changes no behavior on its own — it only
+gives every vault/endpoint a workspace home.
+
+Idempotent: MigrationService runs db.create_all() on boot before Alembic
+(a fresh install already has the columns + indexes from the models), so guard
+on the live schema exactly like 015.
+
+Revision ID: 021_secrets_webhooks_workspace
+Revises: 020_secrets_webhooks
+Create Date: 2026-06-20
+"""
+from alembic import op
+import sqlalchemy as sa
+
+revision = '021_secrets_webhooks_workspace'
+down_revision = '020_secrets_webhooks'
+branch_labels = None
+depends_on = None
+
+_TABLES = ('secret_vaults', 'webhook_endpoints')
+
+
+def _has_col(inspector, table, col):
+ if table not in inspector.get_table_names():
+ return False
+ return col in {c['name'] for c in inspector.get_columns(table)}
+
+
+def _ensure_index(inspector, name, table, col):
+ """Create the model's ix_<table>_<col> index idempotently (a fresh
+ create_all install already has it; an ADD COLUMN upgrade would not)."""
+ if not _has_col(inspector, table, col):
+ return
+ if name not in {ix['name'] for ix in inspector.get_indexes(table)}:
+ op.create_index(name, table, [col])
+
+
+def upgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ tables = set(inspector.get_table_names())
+
+ # The FK target (workspaces) is created by db.create_all() on boot, not by a
+ # migration — guard on it so a standalone `alembic upgrade` (workspaces
+ # absent) doesn't fail adding a FK to a missing table.
+ if 'workspaces' in tables:
+ for table in _TABLES:
+ if table in tables and not _has_col(inspector, table, 'workspace_id'):
+ with op.batch_alter_table(table) as batch_op:
+ batch_op.add_column(sa.Column('workspace_id', sa.Integer(),
+ sa.ForeignKey('workspaces.id'), nullable=True))
+
+ inspector = sa.inspect(conn)
+ for table in _TABLES:
+ _ensure_index(inspector, f'ix_{table}_workspace_id', table, 'workspace_id')
+
+ if 'workspaces' in tables:
+ _backfill(conn)
+
+
+def _backfill(conn):
+ row = conn.execute(sa.text(
+ "SELECT id FROM workspaces WHERE slug = :slug"), {'slug': 'default'}).fetchone()
+ if not row:
+ # 015_workspace_scope creates the Default workspace; without it there is
+ # nothing to attach to, so leave rows unscoped (workspace_id IS NULL).
+ return
+ ws_id = row[0]
+ tables = set(sa.inspect(conn).get_table_names())
+ for table in _TABLES:
+ if table in tables:
+ conn.execute(sa.text(
+ f"UPDATE {table} SET workspace_id = :ws WHERE workspace_id IS NULL"), {'ws': ws_id})
+
+
+def downgrade():
+ conn = op.get_bind()
+ inspector = sa.inspect(conn)
+ for table in _TABLES:
+ name = f'ix_{table}_workspace_id'
+ if table in inspector.get_table_names() and name in {ix['name'] for ix in inspector.get_indexes(table)}:
+ op.drop_index(name, table_name=table)
+ for table in _TABLES:
+ if _has_col(inspector, table, 'workspace_id'):
+ with op.batch_alter_table(table) as batch_op:
+ batch_op.drop_column('workspace_id')