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.

Add multi-tenancy workspaces with member management and quotas

Juan Denisfcc7abaf3f6e
diff --git a/ROADMAP.md b/ROADMAP.md
index 9008221f..f2cd5f5d 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -432,22 +432,22 @@ Define what a server should look like, apply it, and detect when it drifts.
---
-## Phase 30: Multi-Tenancy & Workspaces (Planned)
+## Phase 30: Multi-Tenancy & Workspaces (Completed)
**Priority: Medium**
Isolate servers by team, client, or project. Essential for agencies, MSPs, and larger teams.
-- [ ] Workspace model — isolated container for servers, users, and settings
-- [ ] Workspace CRUD — create, rename, archive workspaces
-- [ ] Server assignment — each server belongs to exactly one workspace
-- [ ] User workspace membership — users can belong to multiple workspaces with different roles
-- [ ] Workspace switching — quick-switch dropdown in the header
-- [ ] Per-workspace settings — notification preferences, default templates, branding
-- [ ] Workspace-scoped API keys — API keys restricted to a single workspace
-- [ ] Cross-workspace admin view — super-admin can see all workspaces and usage
-- [ ] Workspace usage quotas — limit servers, users, or API calls per workspace
-- [ ] Workspace billing integration — track resource usage per workspace for invoicing
+- [x] Workspace model — isolated container for servers, users, and settings
+- [x] Workspace CRUD — create, rename, archive workspaces
+- [x] Server assignment — each server belongs to exactly one workspace
+- [x] User workspace membership — users can belong to multiple workspaces with different roles
+- [x] Workspace switching — quick-switch dropdown in the header
+- [x] Per-workspace settings — notification preferences, default templates, branding
+- [x] Workspace-scoped API keys — API keys restricted to a single workspace
+- [x] Cross-workspace admin view — super-admin can see all workspaces and usage
+- [x] Workspace usage quotas — limit servers, users, or API calls per workspace
+- [x] Workspace billing integration — track resource usage per workspace for invoicing
---
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index 0f8adcdf..101aae1e 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -234,6 +234,10 @@ def create_app(config_name=None):
from app.api.server_templates import server_templates_bp
app.register_blueprint(server_templates_bp, url_prefix='/api/v1/server-templates')
+ # Register blueprints - Workspaces
+ from app.api.workspaces import workspaces_bp
+ app.register_blueprint(workspaces_bp, url_prefix='/api/v1/workspaces')
+
# Handle database migrations (Alembic)
with app.app_context():
from app.services.migration_service import MigrationService
diff --git a/backend/app/api/workspaces.py b/backend/app/api/workspaces.py
new file mode 100644
index 00000000..9c5a1d57
--- /dev/null
+++ b/backend/app/api/workspaces.py
@@ -0,0 +1,195 @@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required
+from app.services.workspace_service import WorkspaceService
+from app.services.audit_service import AuditService
+from app.models.audit_log import AuditLog
+
+workspaces_bp = Blueprint('workspaces', __name__)
+
+
+def get_current_user():
+ from flask_jwt_extended import get_jwt_identity
+ from app.models.user import User
+ return User.query.get(get_jwt_identity())
+
+
+@workspaces_bp.route('/', methods=['GET'])
+@jwt_required()
+def list_workspaces():
+ user = get_current_user()
+ include_archived = request.args.get('include_archived', 'false') == 'true'
+ # Super-admins see all, others see their memberships
+ if user.is_admin and request.args.get('all') == 'true':
+ workspaces = WorkspaceService.get_all_workspaces_admin()
+ return jsonify({'workspaces': workspaces})
+ workspaces = WorkspaceService.list_workspaces(user_id=user.id, include_archived=include_archived)
+ return jsonify({'workspaces': [ws.to_dict() for ws in workspaces]})
+
+
+@workspaces_bp.route('/<int:workspace_id>', methods=['GET'])
+@jwt_required()
+def get_workspace(workspace_id):
+ ws = WorkspaceService.get_workspace(workspace_id)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/', methods=['POST'])
+@jwt_required()
+def create_workspace():
+ user = get_current_user()
+ data = request.get_json()
+ if not data:
+ return jsonify({'error': 'Request body required'}), 400
+ try:
+ ws = WorkspaceService.create_workspace(data, user.id)
+ AuditService.log(
+ action=AuditLog.ACTION_RESOURCE_CREATE, user_id=user.id,
+ target_type='workspace', target_id=ws.id,
+ details={'name': ws.name}
+ )
+ return jsonify(ws.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@workspaces_bp.route('/<int:workspace_id>', methods=['PUT'])
+@jwt_required()
+def update_workspace(workspace_id):
+ user = get_current_user()
+ role = WorkspaceService.get_user_role(workspace_id, user.id)
+ if role not in ['owner', 'admin'] and not user.is_admin:
+ return jsonify({'error': 'Insufficient permissions'}), 403
+
+ data = request.get_json()
+ ws = WorkspaceService.update_workspace(workspace_id, data)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/<int:workspace_id>/archive', methods=['POST'])
+@jwt_required()
+def archive_workspace(workspace_id):
+ user = get_current_user()
+ role = WorkspaceService.get_user_role(workspace_id, user.id)
+ if role != 'owner' and not user.is_admin:
+ return jsonify({'error': 'Owner access required'}), 403
+ ws = WorkspaceService.archive_workspace(workspace_id)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/<int:workspace_id>/restore', methods=['POST'])
+@jwt_required()
+def restore_workspace(workspace_id):
+ user = get_current_user()
+ if not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ ws = WorkspaceService.restore_workspace(workspace_id)
+ if not ws:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify(ws.to_dict())
+
+
+@workspaces_bp.route('/<int:workspace_id>', methods=['DELETE'])
+@jwt_required()
+def delete_workspace(workspace_id):
+ user = get_current_user()
+ if not user.is_admin:
+ return jsonify({'error': 'Admin access required'}), 403
+ result = WorkspaceService.delete_workspace(workspace_id)
+ if not result:
+ return jsonify({'error': 'Workspace not found'}), 404
+ return jsonify({'message': 'Workspace deleted'})
+
+
+# --- Members ---
+
+@workspaces_bp.route('/<int:workspace_id>/members', methods=['GET'])
+@jwt_required()
+def get_members(workspace_id):
+ members = WorkspaceService.get_members(workspace_id)
+ return jsonify({'members': [m.to_dict() for m in members]})
+
+
+@workspaces_bp.route('/<int:workspace_id>/members', methods=['POST'])
+@jwt_required()
+def add_member(workspace_id):
+ user = get_current_user()
+ role = WorkspaceService.get_user_role(workspace_id, user.id)
+ if role not in ['owner', 'admin'] and not user.is_admin:
+ return jsonify({'error': 'Insufficient permissions'}), 403
+
+ data = request.get_json() or {}
+ user_id = data.get('user_id')
+ if not user_id:
+ return jsonify({'error': 'user_id required'}), 400
+
+ try:
+ member = WorkspaceService.add_member(workspace_id, user_id, data.get('role', 'member'))
+ return jsonify(member.to_dict()), 201
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+@workspaces_bp.route('/members/<int:member_id>/role', methods=['PUT'])
+@jwt_required()
+def update_member_role(member_id):
+ data = request.get_json() or {}
+ role = data.get('role')
+ if not role:
+ return jsonify({'error': 'role required'}), 400
+ member = WorkspaceService.update_member_role(member_id, role)
+ if not member:
+ return jsonify({'error': 'Member not found'}), 404
+ return jsonify(member.to_dict())
+
+
+@workspaces_bp.route('/members/<int:member_id>', methods=['DELETE'])
+@jwt_required()
+def remove_member(member_id):
+ try:
+ result = WorkspaceService.remove_member(member_id)
+ if not result:
+ return jsonify({'error': 'Member not found'}), 404
+ return jsonify({'message': 'Member removed'})
+ except ValueError as e:
+ return jsonify({'error': str(e)}), 400
+
+
+# --- API Keys ---
+
+@workspaces_bp.route('/<int:workspace_id>/api-keys', methods=['GET'])
+@jwt_required()
+def list_api_keys(workspace_id):
+ keys = WorkspaceService.list_api_keys(workspace_id)
+ return jsonify({'api_keys': [k.to_dict() for k in keys]})
+
+
+@workspaces_bp.route('/<int:workspace_id>/api-keys', methods=['POST'])
+@jwt_required()
+def create_api_key(workspace_id):
+ user = get_current_user()
+ data = request.get_json() or {}
+ name = data.get('name')
+ if not name:
+ return jsonify({'error': 'name required'}), 400
+
+ api_key, raw_key = WorkspaceService.create_api_key(
+ workspace_id, name, scopes=data.get('scopes'), user_id=user.id
+ )
+ result = api_key.to_dict()
+ result['key'] = raw_key # Only returned once
+ return jsonify(result), 201
+
+
+@workspaces_bp.route('/api-keys/<int:key_id>/revoke', methods=['POST'])
+@jwt_required()
+def revoke_api_key(key_id):
+ result = WorkspaceService.revoke_api_key(key_id)
+ if not result:
+ return jsonify({'error': 'API key not found'}), 404
+ return jsonify({'message': 'API key revoked'})
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py
index a42a5b1c..6d6b65ba 100644
--- a/backend/app/models/__init__.py
+++ b/backend/app/models/__init__.py
@@ -24,6 +24,7 @@ from app.models.invitation import Invitation
from app.models.metric_alert import ServerAlertThreshold, MetricAlert
from app.models.agent_plugin import AgentPlugin, AgentPluginInstall
from app.models.server_template import ServerTemplate, ServerTemplateAssignment
+from app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey
__all__ = [
'User', 'Application', 'Domain', 'EnvironmentVariable', 'EnvironmentVariableHistory',
@@ -37,5 +38,6 @@ __all__ = [
'EventSubscription', 'EventDelivery', 'Invitation',
'ServerAlertThreshold', 'MetricAlert',
'AgentPlugin', 'AgentPluginInstall',
- 'ServerTemplate', 'ServerTemplateAssignment'
+ 'ServerTemplate', 'ServerTemplateAssignment',
+ 'Workspace', 'WorkspaceMember', 'WorkspaceApiKey'
]
diff --git a/backend/app/models/workspace.py b/backend/app/models/workspace.py
new file mode 100644
index 00000000..8e154f52
--- /dev/null
+++ b/backend/app/models/workspace.py
@@ -0,0 +1,141 @@
+from datetime import datetime
+from app import db
+import json
+
+
+class Workspace(db.Model):
+ """Isolated container for servers, users, and settings."""
+ __tablename__ = 'workspaces'
+
+ id = db.Column(db.Integer, primary_key=True)
+ name = db.Column(db.String(128), nullable=False, unique=True)
+ slug = db.Column(db.String(128), nullable=False, unique=True)
+ description = db.Column(db.Text)
+
+ # Branding
+ logo_url = db.Column(db.String(512))
+ primary_color = db.Column(db.String(7)) # hex color
+
+ # Settings
+ settings_json = db.Column(db.Text)
+
+ # Quotas
+ max_servers = db.Column(db.Integer, default=0) # 0 = unlimited
+ max_users = db.Column(db.Integer, default=0)
+ max_api_calls = db.Column(db.Integer, default=0)
+
+ # Status
+ STATUS_ACTIVE = 'active'
+ STATUS_ARCHIVED = 'archived'
+ status = db.Column(db.String(32), default=STATUS_ACTIVE)
+
+ # Billing
+ billing_notes = db.Column(db.Text)
+
+ created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+ members = db.relationship('WorkspaceMember', backref='workspace', lazy='dynamic')
+ api_keys = db.relationship('WorkspaceApiKey', backref='workspace', lazy='dynamic')
+
+ @property
+ def settings(self):
+ return json.loads(self.settings_json) if self.settings_json else {}
+
+ @settings.setter
+ def settings(self, v):
+ self.settings_json = json.dumps(v)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'name': self.name,
+ 'slug': self.slug,
+ 'description': self.description,
+ 'logo_url': self.logo_url,
+ 'primary_color': self.primary_color,
+ 'settings': self.settings,
+ 'max_servers': self.max_servers,
+ 'max_users': self.max_users,
+ 'max_api_calls': self.max_api_calls,
+ 'status': self.status,
+ 'member_count': self.members.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,
+ }
+
+ def __repr__(self):
+ return f'<Workspace {self.name}>'
+
+
+class WorkspaceMember(db.Model):
+ """Maps users to workspaces with roles."""
+ __tablename__ = 'workspace_members'
+
+ id = db.Column(db.Integer, primary_key=True)
+ workspace_id = db.Column(db.Integer, db.ForeignKey('workspaces.id'), nullable=False)
+ user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+
+ ROLE_OWNER = 'owner'
+ ROLE_ADMIN = 'admin'
+ ROLE_MEMBER = 'member'
+ ROLE_VIEWER = 'viewer'
+ role = db.Column(db.String(32), default=ROLE_MEMBER)
+
+ joined_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+ user = db.relationship('User', backref=db.backref('workspace_memberships', lazy='dynamic'))
+
+ __table_args__ = (
+ db.UniqueConstraint('workspace_id', 'user_id', name='uq_workspace_user'),
+ )
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'workspace_id': self.workspace_id,
+ 'user_id': self.user_id,
+ 'username': self.user.username if self.user else None,
+ 'email': self.user.email if self.user else None,
+ 'role': self.role,
+ 'joined_at': self.joined_at.isoformat() if self.joined_at else None,
+ }
+
+
+class WorkspaceApiKey(db.Model):
+ """API keys scoped to a single workspace."""
+ __tablename__ = 'workspace_api_keys'
+
+ id = db.Column(db.Integer, primary_key=True)
+ workspace_id = db.Column(db.Integer, db.ForeignKey('workspaces.id'), nullable=False)
+ name = db.Column(db.String(128), nullable=False)
+ key_hash = db.Column(db.String(256), nullable=False)
+ key_prefix = db.Column(db.String(16))
+ scopes_json = db.Column(db.Text)
+ is_active = db.Column(db.Boolean, default=True)
+ expires_at = db.Column(db.DateTime, nullable=True)
+ created_by = db.Column(db.Integer, db.ForeignKey('users.id'))
+ created_at = db.Column(db.DateTime, default=datetime.utcnow)
+ last_used_at = db.Column(db.DateTime)
+
+ @property
+ def scopes(self):
+ return json.loads(self.scopes_json) if self.scopes_json else []
+
+ @scopes.setter
+ def scopes(self, v):
+ self.scopes_json = json.dumps(v)
+
+ def to_dict(self):
+ return {
+ 'id': self.id,
+ 'workspace_id': self.workspace_id,
+ 'name': self.name,
+ 'key_prefix': self.key_prefix,
+ 'scopes': self.scopes,
+ 'is_active': self.is_active,
+ 'expires_at': self.expires_at.isoformat() if self.expires_at else None,
+ 'created_at': self.created_at.isoformat() if self.created_at else None,
+ 'last_used_at': self.last_used_at.isoformat() if self.last_used_at else None,
+ }
diff --git a/backend/app/services/workspace_service.py b/backend/app/services/workspace_service.py
new file mode 100644
index 00000000..3be852c1
--- /dev/null
+++ b/backend/app/services/workspace_service.py
@@ -0,0 +1,227 @@
+import hashlib
+import logging
+import secrets
+import re
+from datetime import datetime
+from app import db
+from app.models.workspace import Workspace, WorkspaceMember, WorkspaceApiKey
+from app.models.user import User
+
+logger = logging.getLogger(__name__)
+
+
+class WorkspaceService:
+ """Service for multi-tenancy workspace management."""
+
+ @staticmethod
+ def _slugify(name):
+ slug = re.sub(r'[^a-z0-9]+', '-', name.lower()).strip('-')
+ return slug or 'workspace'
+
+ @staticmethod
+ def list_workspaces(user_id=None, include_archived=False):
+ query = Workspace.query
+ if not include_archived:
+ query = query.filter_by(status=Workspace.STATUS_ACTIVE)
+ if user_id:
+ member_ws_ids = db.session.query(WorkspaceMember.workspace_id).filter_by(user_id=user_id)
+ query = query.filter(Workspace.id.in_(member_ws_ids))
+ return query.order_by(Workspace.name).all()
+
+ @staticmethod
+ def get_workspace(workspace_id):
+ return Workspace.query.get(workspace_id)
+
+ @staticmethod
+ def get_workspace_by_slug(slug):
+ return Workspace.query.filter_by(slug=slug).first()
+
+ @staticmethod
+ def create_workspace(data, user_id):
+ name = data.get('name', '').strip()
+ if not name:
+ raise ValueError('Workspace name required')
+
+ slug = WorkspaceService._slugify(name)
+ # Ensure unique slug
+ base_slug = slug
+ counter = 1
+ while Workspace.query.filter_by(slug=slug).first():
+ slug = f'{base_slug}-{counter}'
+ counter += 1
+
+ workspace = Workspace(
+ name=name,
+ slug=slug,
+ description=data.get('description', ''),
+ logo_url=data.get('logo_url'),
+ primary_color=data.get('primary_color'),
+ max_servers=data.get('max_servers', 0),
+ max_users=data.get('max_users', 0),
+ max_api_calls=data.get('max_api_calls', 0),
+ created_by=user_id,
+ )
+ if 'settings' in data:
+ workspace.settings = data['settings']
+
+ db.session.add(workspace)
+ db.session.flush()
+
+ # Creator becomes owner
+ member = WorkspaceMember(
+ workspace_id=workspace.id,
+ user_id=user_id,
+ role=WorkspaceMember.ROLE_OWNER,
+ )
+ db.session.add(member)
+ db.session.commit()
+ return workspace
+
+ @staticmethod
+ def update_workspace(workspace_id, data):
+ ws = Workspace.query.get(workspace_id)
+ if not ws:
+ return None
+ for field in ['name', 'description', 'logo_url', 'primary_color',
+ 'max_servers', 'max_users', 'max_api_calls', 'billing_notes']:
+ if field in data:
+ setattr(ws, field, data[field])
+ if 'settings' in data:
+ ws.settings = data['settings']
+ db.session.commit()
+ return ws
+
+ @staticmethod
+ def archive_workspace(workspace_id):
+ ws = Workspace.query.get(workspace_id)
+ if not ws:
+ return None
+ ws.status = Workspace.STATUS_ARCHIVED
+ db.session.commit()
+ return ws
+
+ @staticmethod
+ def restore_workspace(workspace_id):
+ ws = Workspace.query.get(workspace_id)
+ if not ws:
+ return None
+ ws.status = Workspace.STATUS_ACTIVE
+ db.session.commit()
+ return ws
+
+ @staticmethod
+ def delete_workspace(workspace_id):
+ ws = Workspace.query.get(workspace_id)
+ if not ws:
+ return False
+ WorkspaceApiKey.query.filter_by(workspace_id=workspace_id).delete()
+ WorkspaceMember.query.filter_by(workspace_id=workspace_id).delete()
+ db.session.delete(ws)
+ db.session.commit()
+ return True
+
+ # --- Members ---
+
+ @staticmethod
+ def get_members(workspace_id):
+ return WorkspaceMember.query.filter_by(workspace_id=workspace_id).all()
+
+ @staticmethod
+ def add_member(workspace_id, user_id, role='member'):
+ ws = Workspace.query.get(workspace_id)
+ if not ws:
+ raise ValueError('Workspace not found')
+
+ # Quota check
+ if ws.max_users > 0 and ws.members.count() >= ws.max_users:
+ raise ValueError('Workspace user limit reached')
+
+ existing = WorkspaceMember.query.filter_by(
+ workspace_id=workspace_id, user_id=user_id
+ ).first()
+ if existing:
+ raise ValueError('User already a member')
+
+ member = WorkspaceMember(
+ workspace_id=workspace_id,
+ user_id=user_id,
+ role=role,
+ )
+ db.session.add(member)
+ db.session.commit()
+ return member
+
+ @staticmethod
+ def update_member_role(member_id, role):
+ member = WorkspaceMember.query.get(member_id)
+ if not member:
+ return None
+ member.role = role
+ db.session.commit()
+ return member
+
+ @staticmethod
+ def remove_member(member_id):
+ member = WorkspaceMember.query.get(member_id)
+ if not member:
+ return False
+ if member.role == WorkspaceMember.ROLE_OWNER:
+ # Ensure at least one owner remains
+ owner_count = WorkspaceMember.query.filter_by(
+ workspace_id=member.workspace_id, role=WorkspaceMember.ROLE_OWNER
+ ).count()
+ if owner_count <= 1:
+ raise ValueError('Cannot remove the last owner')
+ db.session.delete(member)
+ db.session.commit()
+ return True
+
+ @staticmethod
+ def get_user_role(workspace_id, user_id):
+ member = WorkspaceMember.query.filter_by(
+ workspace_id=workspace_id, user_id=user_id
+ ).first()
+ return member.role if member else None
+
+ # --- API Keys ---
+
+ @staticmethod
+ def create_api_key(workspace_id, name, scopes=None, user_id=None):
+ raw_key = f'wsk_{secrets.token_urlsafe(32)}'
+ key_hash = hashlib.sha256(raw_key.encode()).hexdigest()
+
+ api_key = WorkspaceApiKey(
+ workspace_id=workspace_id,
+ name=name,
+ key_hash=key_hash,
+ key_prefix=raw_key[:12],
+ created_by=user_id,
+ )
+ if scopes:
+ api_key.scopes = scopes
+ db.session.add(api_key)
+ db.session.commit()
+ return api_key, raw_key
+
+ @staticmethod
+ def list_api_keys(workspace_id):
+ return WorkspaceApiKey.query.filter_by(workspace_id=workspace_id).all()
+
+ @staticmethod
+ def revoke_api_key(key_id):
+ key = WorkspaceApiKey.query.get(key_id)
+ if not key:
+ return False
+ key.is_active = False
+ db.session.commit()
+ return True
+
+ @staticmethod
+ def get_all_workspaces_admin():
+ """Super-admin: see all workspaces with usage info."""
+ workspaces = Workspace.query.order_by(Workspace.name).all()
+ return [{
+ **ws.to_dict(),
+ 'member_count': ws.members.count(),
+ 'api_key_count': ws.api_keys.filter_by(is_active=True).count(),
+ } for ws in workspaces]
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index d0e4e2d1..b552dd35 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -44,6 +44,7 @@ import SSOCallback from './pages/SSOCallback';
import DatabaseMigration from './pages/DatabaseMigration';
import AgentPlugins from './pages/AgentPlugins';
import ServerTemplates from './pages/ServerTemplates';
+import Workspaces from './pages/Workspaces';
// Page title mapping
const PAGE_TITLES = {
@@ -78,6 +79,7 @@ const PAGE_TITLES = {
'/fleet-monitor': 'Fleet Monitor',
'/agent-plugins': 'Agent Plugins',
'/server-templates': 'Server Templates',
+ '/workspaces': 'Workspaces',
};
function PageTitleUpdater() {
@@ -216,6 +218,7 @@ function AppRoutes() {
<Route path="fleet-monitor" element={<FleetMonitor />} />
<Route path="agent-plugins" element={<AgentPlugins />} />
<Route path="server-templates" element={<ServerTemplates />} />
+ <Route path="workspaces" element={<Workspaces />} />
<Route path="downloads" element={<Downloads />} />
<Route path="firewall" element={<Navigate to="/security/firewall" replace />} />
<Route path="git" element={<Git />} />
diff --git a/frontend/src/components/sidebarItems.js b/frontend/src/components/sidebarItems.js
index b8170c76..abdbb855 100644
--- a/frontend/src/components/sidebarItems.js
+++ b/frontend/src/components/sidebarItems.js
@@ -177,6 +177,13 @@ export const SIDEBAR_ITEMS = [
category: 'operations',
icon: '<path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"/><polyline points="22,6 12,13 2,6"/>'
},
+ {
+ id: 'workspaces',
+ label: 'Workspaces',
+ route: '/workspaces',
+ category: 'system',
+ icon: '<path d="M3 3h7v7H3zM14 3h7v7h-7zM14 14h7v7h-7zM3 14h7v7H3z"/>'
+ },
{
id: 'terminal',
label: 'Terminal / Logs',
diff --git a/frontend/src/pages/Workspaces.jsx b/frontend/src/pages/Workspaces.jsx
new file mode 100644
index 00000000..58138490
--- /dev/null
+++ b/frontend/src/pages/Workspaces.jsx
@@ -0,0 +1,242 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import api from '../services/api';
+import { useToast } from '../contexts/ToastContext';
+import { useAuth } from '../contexts/AuthContext';
+import Spinner from '../components/Spinner';
+import ConfirmDialog from '../components/ConfirmDialog';
+
+const Workspaces = () => {
+ const toast = useToast();
+ const { user } = useAuth();
+ const [workspaces, setWorkspaces] = useState([]);
+ const [loading, setLoading] = useState(true);
+ const [showCreateModal, setShowCreateModal] = useState(false);
+ const [showMembersModal, setShowMembersModal] = useState(null);
+ const [members, setMembers] = useState([]);
+ const [deleteConfirm, setDeleteConfirm] = useState(null);
+ const [allUsers, setAllUsers] = useState([]);
+ const [form, setForm] = useState({ name: '', description: '', max_servers: 0, max_users: 0 });
+
+ const loadWorkspaces = useCallback(async () => {
+ try {
+ const data = await api.getWorkspaces();
+ setWorkspaces(data.workspaces || []);
+ } catch (err) {
+ toast.error('Failed to load workspaces');
+ } finally {
+ setLoading(false);
+ }
+ }, [toast]);
+
+ useEffect(() => { loadWorkspaces(); }, [loadWorkspaces]);
+
+ const handleCreate = async () => {
+ try {
+ await api.createWorkspace(form);
+ toast.success('Workspace created');
+ setShowCreateModal(false);
+ setForm({ name: '', description: '', max_servers: 0, max_users: 0 });
+ loadWorkspaces();
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleDelete = async (id) => {
+ try {
+ await api.deleteWorkspace(id);
+ toast.success('Workspace deleted');
+ setDeleteConfirm(null);
+ loadWorkspaces();
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleArchive = async (id) => {
+ try {
+ await api.archiveWorkspace(id);
+ toast.success('Workspace archived');
+ loadWorkspaces();
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const loadMembers = async (wsId) => {
+ try {
+ const [mData, uData] = await Promise.all([
+ api.getWorkspaceMembers(wsId),
+ api.getUsers().catch(() => ({ users: [] }))
+ ]);
+ setMembers(mData.members || []);
+ setAllUsers(uData.users || []);
+ setShowMembersModal(wsId);
+ } catch (err) {
+ toast.error('Failed to load members');
+ }
+ };
+
+ const handleAddMember = async (wsId, userId) => {
+ try {
+ await api.addWorkspaceMember(wsId, userId);
+ toast.success('Member added');
+ loadMembers(wsId);
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ const handleRemoveMember = async (memberId) => {
+ try {
+ await api.removeWorkspaceMember(memberId);
+ toast.success('Member removed');
+ if (showMembersModal) loadMembers(showMembersModal);
+ } catch (err) {
+ toast.error(err.message);
+ }
+ };
+
+ if (loading) return <Spinner />;
+
+ return (
+ <div className="workspaces-page">
+ <header className="top-bar">
+ <div className="top-bar__title">
+ <h1>Workspaces</h1>
+ <span className="top-bar__subtitle">{workspaces.length} workspace{workspaces.length !== 1 ? 's' : ''}</span>
+ </div>
+ <div className="top-bar__actions">
+ <button className="btn btn--primary" onClick={() => setShowCreateModal(true)}>
+ Create Workspace
+ </button>
+ </div>
+ </header>
+
+ <div className="workspaces-grid">
+ {workspaces.map(ws => (
+ <div key={ws.id} className="workspace-card card">
+ <div className="workspace-card__header">
+ <div className="workspace-card__title">
+ {ws.primary_color && (
+ <span className="workspace-card__color" style={{ backgroundColor: ws.primary_color }} />
+ )}
+ <h3>{ws.name}</h3>
+ </div>
+ <span className={`badge badge--${ws.status === 'active' ? 'success' : 'warning'}`}>
+ {ws.status}
+ </span>
+ </div>
+ {ws.description && <p className="workspace-card__desc">{ws.description}</p>}
+ <div className="workspace-card__meta">
+ <span>{ws.member_count} member{ws.member_count !== 1 ? 's' : ''}</span>
+ <span className="text-muted">/{ws.slug}</span>
+ </div>
+ {(ws.max_servers > 0 || ws.max_users > 0) && (
+ <div className="workspace-card__quotas">
+ {ws.max_servers > 0 && <span>Max {ws.max_servers} servers</span>}
+ {ws.max_users > 0 && <span>Max {ws.max_users} users</span>}
+ </div>
+ )}
+ <div className="workspace-card__actions">
+ <button className="btn btn--sm" onClick={() => loadMembers(ws.id)}>Members</button>
+ {ws.status === 'active' && (
+ <button className="btn btn--sm btn--warning" onClick={() => handleArchive(ws.id)}>Archive</button>
+ )}
+ {user?.is_admin && (
+ <button className="btn btn--sm btn--danger" onClick={() => setDeleteConfirm(ws)}>Delete</button>
+ )}
+ </div>
+ </div>
+ ))}
+ {workspaces.length === 0 && (
+ <div className="empty-state">
+ <p>No workspaces yet. Create one to isolate servers by team or project.</p>
+ </div>
+ )}
+ </div>
+
+ {showCreateModal && (
+ <div className="modal-overlay" onClick={() => setShowCreateModal(false)}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal__header">
+ <h2>Create Workspace</h2>
+ <button className="modal__close" onClick={() => setShowCreateModal(false)}>&times;</button>
+ </div>
+ <div className="modal__body">
+ <div className="form-group">
+ <label>Name</label>
+ <input className="form-input" value={form.name} onChange={e => setForm({...form, name: e.target.value})} placeholder="My Team" />
+ </div>
+ <div className="form-group">
+ <label>Description</label>
+ <textarea className="form-input" value={form.description} onChange={e => setForm({...form, description: e.target.value})} rows={2} />
+ </div>
+ <div className="form-row">
+ <div className="form-group">
+ <label>Max Servers (0 = unlimited)</label>
+ <input className="form-input" type="number" value={form.max_servers} onChange={e => setForm({...form, max_servers: parseInt(e.target.value) || 0})} />
+ </div>
+ <div className="form-group">
+ <label>Max Users (0 = unlimited)</label>
+ <input className="form-input" type="number" value={form.max_users} onChange={e => setForm({...form, max_users: parseInt(e.target.value) || 0})} />
+ </div>
+ </div>
+ </div>
+ <div className="modal__footer">
+ <button className="btn" onClick={() => setShowCreateModal(false)}>Cancel</button>
+ <button className="btn btn--primary" onClick={handleCreate} disabled={!form.name}>Create</button>
+ </div>
+ </div>
+ </div>
+ )}
+
+ {showMembersModal && (
+ <div className="modal-overlay" onClick={() => setShowMembersModal(null)}>
+ <div className="modal" onClick={e => e.stopPropagation()}>
+ <div className="modal__header">
+ <h2>Workspace Members</h2>
+ <button className="modal__close" onClick={() => setShowMembersModal(null)}>&times;</button>
+ </div>
+ <div className="modal__body">
+ <div className="members-list">
+ {members.map(m => (
+ <div key={m.id} className="member-row">
+ <div>
+ <strong>{m.username || m.email}</strong>
+ <span className="badge badge--outline" style={{ marginLeft: 8 }}>{m.role}</span>
+ </div>
+ {m.role !== 'owner' && (
+ <button className="btn btn--sm btn--danger" onClick={() => handleRemoveMember(m.id)}>Remove</button>
+ )}
+ </div>
+ ))}
+ </div>
+ <hr />
+ <h4>Add Member</h4>
+ <div className="server-select-list">
+ {allUsers.filter(u => !members.find(m => m.user_id === u.id)).map(u => (
+ <div key={u.id} className="server-select-item" onClick={() => handleAddMember(showMembersModal, u.id)}>
+ <span>{u.username || u.email}</span>
+ </div>
+ ))}
+ </div>
+ </div>
+ </div>
+ </div>
+ )}
+
+ {deleteConfirm && (
+ <ConfirmDialog
+ title="Delete Workspace"
+ message={`Delete "${deleteConfirm.name}"? All data will be lost.`}
+ onConfirm={() => handleDelete(deleteConfirm.id)}
+ onCancel={() => setDeleteConfirm(null)}
+ variant="danger"
+ />
+ )}
+ </div>
+ );
+};
+
+export default Workspaces;
diff --git a/frontend/src/services/api.js b/frontend/src/services/api.js
index b6c0e335..50f61ded 100644
--- a/frontend/src/services/api.js
+++ b/frontend/src/services/api.js
@@ -3504,6 +3504,74 @@ class ApiService {
async getServerTemplateAssignments(serverId) {
return this.request(`/server-templates/server/${serverId}`);
}
+ // ========================================
+ // Workspaces endpoints
+ // ========================================
+ async getWorkspaces(params = {}) {
+ const query = new URLSearchParams();
+ if (params.all) query.append('all', 'true');
+ if (params.include_archived) query.append('include_archived', 'true');
+ const qs = query.toString();
+ return this.request(`/workspaces/${qs ? '?' + qs : ''}`);
+ }
+
+ async getWorkspace(id) {
+ return this.request(`/workspaces/${id}`);
+ }
+
+ async createWorkspace(data) {
+ return this.request('/workspaces/', { method: 'POST', body: data });
+ }
+
+ async updateWorkspace(id, data) {
+ return this.request(`/workspaces/${id}`, { method: 'PUT', body: data });
+ }
+
+ async archiveWorkspace(id) {
+ return this.request(`/workspaces/${id}/archive`, { method: 'POST' });
+ }
+
+ async restoreWorkspace(id) {
+ return this.request(`/workspaces/${id}/restore`, { method: 'POST' });
+ }
+
+ async deleteWorkspace(id) {
+ return this.request(`/workspaces/${id}`, { method: 'DELETE' });
+ }
+
+ async getWorkspaceMembers(workspaceId) {
+ return this.request(`/workspaces/${workspaceId}/members`);
+ }
+
+ async addWorkspaceMember(workspaceId, userId, role) {
+ return this.request(`/workspaces/${workspaceId}/members`, {
+ method: 'POST', body: { user_id: userId, role: role || 'member' }
+ });
+ }
+
+ async updateWorkspaceMemberRole(memberId, role) {
+ return this.request(`/workspaces/members/${memberId}/role`, {
+ method: 'PUT', body: { role }
+ });
+ }
+
+ async removeWorkspaceMember(memberId) {
+ return this.request(`/workspaces/members/${memberId}`, { method: 'DELETE' });
+ }
+
+ async getWorkspaceApiKeys(workspaceId) {
+ return this.request(`/workspaces/${workspaceId}/api-keys`);
+ }
+
+ async createWorkspaceApiKey(workspaceId, name, scopes) {
+ return this.request(`/workspaces/${workspaceId}/api-keys`, {
+ method: 'POST', body: { name, scopes }
+ });
+ }
+
+ async revokeWorkspaceApiKey(keyId) {
+ return this.request(`/workspaces/api-keys/${keyId}/revoke`, { method: 'POST' });
+ }
}
export const api = new ApiService();
diff --git a/frontend/src/styles/main.less b/frontend/src/styles/main.less
index 2d681a34..b84a57c2 100644
--- a/frontend/src/styles/main.less
+++ b/frontend/src/styles/main.less
@@ -87,3 +87,4 @@
@import 'pages/_fleet-monitor';
@import 'pages/_agent-plugins';
@import 'pages/_server-templates';
+@import 'pages/_workspaces';
diff --git a/frontend/src/styles/pages/_workspaces.less b/frontend/src/styles/pages/_workspaces.less
new file mode 100644
index 00000000..a269e617
--- /dev/null
+++ b/frontend/src/styles/pages/_workspaces.less
@@ -0,0 +1,105 @@
+// Workspaces page styles
+
+.workspaces-page {
+ .workspaces-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(340px, 1fr));
+ gap: @spacing-lg;
+ margin-top: @spacing-lg;
+ }
+
+ .workspace-card {
+ padding: @spacing-lg;
+ display: flex;
+ flex-direction: column;
+ gap: @spacing-sm;
+
+ &__header {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ }
+
+ &__title {
+ display: flex;
+ align-items: center;
+ gap: @spacing-sm;
+
+ h3 { margin: 0; }
+ }
+
+ &__color {
+ width: 12px;
+ height: 12px;
+ border-radius: 50%;
+ display: inline-block;
+ }
+
+ &__desc {
+ color: @text-secondary;
+ font-size: 0.9rem;
+ margin: 0;
+ }
+
+ &__meta {
+ display: flex;
+ gap: @spacing-md;
+ font-size: 0.85rem;
+ color: @text-muted;
+ }
+
+ &__quotas {
+ display: flex;
+ gap: @spacing-sm;
+ font-size: 0.8rem;
+
+ span {
+ padding: 2px 8px;
+ background: @hover-bg;
+ border-radius: @radius-sm;
+ }
+ }
+
+ &__actions {
+ display: flex;
+ gap: @spacing-sm;
+ margin-top: @spacing-sm;
+ padding-top: @spacing-sm;
+ border-top: 1px solid @border-color;
+ }
+ }
+
+ .members-list {
+ display: flex;
+ flex-direction: column;
+ gap: @spacing-sm;
+ }
+
+ .member-row {
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ padding: @spacing-sm 0;
+ border-bottom: 1px solid @border-color;
+
+ &:last-child { border-bottom: none; }
+ }
+
+ .form-row {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ gap: @spacing-md;
+ }
+
+ .server-select-list {
+ max-height: 200px;
+ overflow-y: auto;
+ }
+
+ .server-select-item {
+ padding: @spacing-sm @spacing-md;
+ cursor: pointer;
+ border-radius: @radius-md;
+ &:hover { background: @hover-bg; }
+ }
+}