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
Add multi-tenancy workspaces with member management and quotas
Juan Denisfcc7abaf3f6e
diff --git a/ROADMAP.md b/ROADMAP.mdindex 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__.pyindex 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_bpapp.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 MigrationServicediff --git a/backend/app/api/workspaces.py b/backend/app/api/workspaces.pynew file mode 100644index 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__.pyindex a42a5b1c..6d6b65ba 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -24,6 +24,7 @@ from app.models.invitation import Invitationfrom app.models.metric_alert import ServerAlertThreshold, MetricAlertfrom app.models.agent_plugin import AgentPlugin, AgentPluginInstallfrom 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.pynew file mode 100644index 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.pynew file mode 100644index 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.jsxindex 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 mappingconst 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.jsindex 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.jsxnew file mode 100644index 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)}>×</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)}>×</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.jsindex 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.lessindex 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.lessnew file mode 100644index 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; }+ }+}