chore: bump version to 0.3.2

- Add multi-stage Dockerfile (Flutter build → nginx:alpine)
- Add nginx.conf with SPA routing, gzip, and caching
- Add Gitea workflow for release-triggered builds
- Document release procedure in AGENTS.md

Deploys to port 8092, auto-updates via Watchtower.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.gitea/workflows/build.yml

@@ -0,0 +1,34 @@
+name: Build and Push
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Login to Gitea Registry
+        uses: docker/login-action@v3
+        with:
+          registry: git.schweitz.internal
+          username: ${{ secrets.REGISTRY_USER }}
+          password: ${{ secrets.REGISTRY_PASSWORD }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: |
+            git.schweitz.internal/jpmschweitzer/tatlock-ui:latest
+            git.schweitz.internal/jpmschweitzer/tatlock-ui:${{ github.ref_name }}
+
+      - name: Trigger Watchtower update
+        if: success()
+        run: |
+          curl -sf -H "Authorization: Bearer ${{ secrets.WATCHTOWER_TOKEN }}" \
+            http://watchtower:8080/v1/update

.gitignore

@@ -12,7 +12,6 @@ pubspec.lock
 *.freezed.dart
 *.gr.dart
 *.mocks.dart
-lib/generated_plugin_registrant.dart
 
 # Keep version.g.dart - it's generated but should be committed
 # so CI/CD builds have version info without running the generator
@@ -120,3 +119,4 @@ secrets/
 # Uploads (reference images, not tracked)
 uploads/
 logs/
+.vscode/launch.json

AGENTS.md

@@ -42,7 +42,36 @@ This document contains instructions and documentation references for AI assistan
     * Tag after updating `pubspec.yaml` version and CHANGELOG
     * Push tags with `git push --tags`
 
+### 🚀 Release Procedure
+
+This project uses version-tag-based CI/CD. Releases trigger automated Docker builds and deployments.
+
+**Release Steps:**
+
+1. Update version in `pubspec.yaml` (bump major.minor.patch, not build number)
+2. Update `CHANGELOG.md` with changes under `## [x.x.x] - YYYY-MM-DD`
+3. Commit changes: `git commit -m "chore: release vX.X.X"`
+4. Create git tag: `git tag vX.X.X`
+5. Push with tags: `git push origin master --tags`
+6. Create release in Gitea UI (git.schweitz.net → Releases → New Release)
+   * Select the tag
+   * Add release notes (can copy from CHANGELOG)
+   * **Publish** the release (this triggers CI/CD)
+
+**What happens on release:**
+
+* Gitea CI builds Flutter web app in Docker
+* Image pushed to `git.schweitz.internal/jpmschweitzer/tatlock-ui:latest` and `:vX.X.X`
+* Watchtower detects new image and auto-updates running container
+* App available at `http://tower:8092` (and eventually `home.schweitz.net`)
+
+**Rollback:**
+
+* In Portainer, update image tag to previous version (e.g., `:v0.2.0`)
+* Or: `docker pull git.schweitz.internal/jpmschweitzer/tatlock-ui:v0.2.0`
+
 ### 🧪 Testing Requirements
+
 * **Always add tests for new code before committing.** No exceptions.
 * Tests should cover the happy path and key edge cases.
 * Run `flutter test` before committing to ensure all tests pass.
@@ -50,5 +79,14 @@ This document contains instructions and documentation references for AI assistan
 * Code coverage should not decrease with new commits.
 
 ### 📝 Changelog Maintenance
+
 * **Update `CHANGELOG.md`** with every user-facing change.
 * Format: `## [Unreleased] - YYYY-MM-DD` followed by `### Added`, `### Changed`, or `### Fixed`.
+
+### 🎨 UI Patterns (MUST READ BEFORE CHANGES)
+
+* **Before modifying the widget tree**, read `docs/UI_LAYOUT.md` to understand established patterns.
+* Investigate existing implementations in the codebase before creating new components.
+* **DO NOT** reinvent wheels - check if shared components already exist in `lib/shared/components/`.
+* Look at similar features for reference patterns (e.g., how other list views, forms, or CRUD screens are built).
+* Deviating from established patterns creates inconsistency and technical debt.

Dockerfile

@@ -0,0 +1,41 @@
+# Stage 1: Build Flutter web application
+FROM ghcr.io/cirruslabs/flutter:stable AS builder
+
+WORKDIR /app
+
+# Copy dependency files first for better caching
+COPY pubspec.yaml ./
+
+# Get dependencies (generates pubspec.lock)
+RUN flutter pub get
+
+# Copy the rest of the application
+COPY . .
+
+# Generate code with build_runner
+RUN dart run build_runner build --delete-conflicting-outputs
+
+# Build for web release
+RUN flutter build web --release
+
+# Stage 2: Serve with nginx
+FROM nginx:alpine
+
+# Install curl for healthcheck
+RUN apk add --no-cache curl
+
+# Copy custom nginx configuration
+COPY nginx.conf /etc/nginx/nginx.conf
+
+# Copy built web app to nginx html directory
+COPY --from=builder /app/build/web /usr/share/nginx/html
+
+# Expose port 80
+EXPOSE 80
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:80/ || exit 1
+
+# Run nginx in foreground
+CMD ["nginx", "-g", "daemon off;"]

analysis_options.yaml

@@ -9,6 +9,12 @@
 # packages, and plugins designed to encourage good coding practices.
 include: package:flutter_lints/flutter.yaml
 
+analyzer:
+  errors:
+    # Freezed uses @JsonKey on constructor parameters which triggers this warning
+    # but is the correct pattern for freezed classes
+    invalid_annotation_target: ignore
+
 linter:
   # The lint rules applied to this project can be customized in the
   # section below to disable rules from the `package:flutter_lints/flutter.yaml`

lib/app.dart

@@ -12,7 +12,7 @@ class TatlockApp extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final router = ref.watch(appRouterProvider);
-    final themeAsync = ref.watch(themeNotifierProvider);
+    final themeAsync = ref.watch(themeProvider);
 
     // Get theme mode, defaulting to system while loading
     final themeMode = switch (themeAsync) {

lib/core/api/api_client.dart

@@ -7,7 +7,7 @@ part 'api_client.g.dart';
 
 /// Provides the Dio instance for Core API.
 @riverpod
-Dio coreApiClient(CoreApiClientRef ref) {
+Dio coreApiClient(Ref ref) {
   final dio = Dio(
     BaseOptions(
       baseUrl: AppConfig.coreApiUrl,
@@ -31,7 +31,7 @@ Dio coreApiClient(CoreApiClientRef ref) {
 
 /// Provides the Dio instance for Tatlock API.
 @riverpod
-Dio tatlockApiClient(TatlockApiClientRef ref) {
+Dio tatlockApiClient(Ref ref) {
   final dio = Dio(
     BaseOptions(
       baseUrl: AppConfig.tatlockApiUrl,

lib/core/api/api_interceptors.dart

@@ -22,7 +22,7 @@ class AuthInterceptor extends Interceptor {
       return;
     }
 
-    final authState = _ref.read(authNotifierProvider);
+    final authState = _ref.read(authProvider);
 
     authState.whenData((auth) {
       if (auth.isAuthenticated && auth.accessToken != null) {
@@ -43,7 +43,7 @@ class AuthInterceptor extends Interceptor {
 
     if (err.response?.statusCode == 401) {
       // Token expired - trigger re-authentication
-      _ref.read(authNotifierProvider.notifier).signOut();
+      _ref.read(authProvider.notifier).signOut();
     }
     handler.next(err);
   }

lib/core/auth/auth_state.dart

@@ -4,7 +4,7 @@ part 'auth_state.freezed.dart';
 
 /// Authentication state.
 @freezed
-class AuthState with _$AuthState {
+sealed class AuthState with _$AuthState {
   const factory AuthState({
     @Default(false) bool isAuthenticated,
     String? accessToken,

lib/features/control_room/containers/data/datasources/containers_datasource.dart

@@ -1,5 +1,4 @@
 import 'package:dio/dio.dart';
-import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 import 'package:tatlock_ui/core/api/api_client.dart';
 import 'package:tatlock_ui/features/control_room/containers/data/models/container_model.dart';

lib/features/control_room/containers/data/models/container_model.dart

@@ -6,7 +6,7 @@ part 'container_model.g.dart';
 
 /// Container data model for API serialization.
 @freezed
-class ContainerModel with _$ContainerModel {
+sealed class ContainerModel with _$ContainerModel {
   const factory ContainerModel({
     @JsonKey(name: 'Id') required String id,
     @JsonKey(name: 'Names') required List<String> names,
@@ -68,7 +68,7 @@ class ContainerModel with _$ContainerModel {
 
 /// Port mapping model.
 @freezed
-class PortModel with _$PortModel {
+sealed class PortModel with _$PortModel {
   const factory PortModel({
     @JsonKey(name: 'IP') String? ip,
     @JsonKey(name: 'PrivatePort') required int privatePort,
@@ -93,7 +93,7 @@ class PortModel with _$PortModel {
 
 /// Mount model.
 @freezed
-class MountModel with _$MountModel {
+sealed class MountModel with _$MountModel {
   const factory MountModel({
     @JsonKey(name: 'Type') required String type,
     @JsonKey(name: 'Source') required String source,
@@ -119,7 +119,7 @@ class MountModel with _$MountModel {
 
 /// Network settings model.
 @freezed
-class NetworkSettingsModel with _$NetworkSettingsModel {
+sealed class NetworkSettingsModel with _$NetworkSettingsModel {
   const factory NetworkSettingsModel({
     @JsonKey(name: 'Networks') @Default({}) Map<String, dynamic> networks,
   }) = _NetworkSettingsModel;

lib/features/control_room/containers/data/repositories/container_repository_impl.dart

@@ -77,7 +77,7 @@ class ContainerRepositoryImpl implements ContainerRepository {
 
 /// Provides the container repository.
 @riverpod
-ContainerRepository containerRepository(ContainerRepositoryRef ref) {
+ContainerRepository containerRepository(Ref ref) {
   final datasource = ref.watch(containersDatasourceProvider);
   return ContainerRepositoryImpl(datasource);
 }

lib/features/control_room/containers/domain/entities/container.dart

@@ -4,7 +4,7 @@ part 'container.freezed.dart';
 
 /// Docker container entity.
 @freezed
-class Container with _$Container {
+sealed class Container with _$Container {
   const factory Container({
     /// Container ID (short form).
     required String id,
@@ -122,7 +122,7 @@ enum ContainerState {
 
 /// Port mapping configuration.
 @freezed
-class PortMapping with _$PortMapping {
+sealed class PortMapping with _$PortMapping {
   const factory PortMapping({
     /// Host IP (usually 0.0.0.0).
     String? hostIp,
@@ -149,7 +149,7 @@ class PortMapping with _$PortMapping {
 
 /// Volume mount configuration.
 @freezed
-class VolumeMount with _$VolumeMount {
+sealed class VolumeMount with _$VolumeMount {
   const factory VolumeMount({
     /// Mount type (bind, volume, tmpfs).
     required String type,

lib/features/control_room/containers/presentation/pages/containers_list_page.dart

@@ -1,17 +1,180 @@
 import 'package:flutter/material.dart' hide Container;
 import 'package:flutter_riverpod/flutter_riverpod.dart';
-import 'package:tatlock_ui/features/control_room/containers/domain/entities/container.dart';
+import 'package:tatlock_ui/core/api/api_client.dart';
 import 'package:tatlock_ui/features/control_room/containers/presentation/providers/containers_provider.dart';
 import 'package:tatlock_ui/features/control_room/containers/presentation/widgets/container_logs_viewer.dart';
 import 'package:tatlock_ui/features/control_room/containers/presentation/widgets/container_status_badge.dart';
+import 'package:tatlock_ui/shared/components/data_grid/adapters/core_api_source.dart';
+import 'package:tatlock_ui/shared/components/data_grid/data_grid_exports.dart';
+
+/// Container data class for DataGrid display.
+class ContainerData {
+  ContainerData({
+    required this.id,
+    required this.fullId,
+    required this.name,
+    required this.image,
+    required this.state,
+    required this.status,
+    required this.ports,
+  });
+
+  factory ContainerData.fromJson(Map<String, dynamic> json) {
+    final ports = (json['ports'] as List<dynamic>?)
+            ?.map((p) => ContainerPort.fromJson(p as Map<String, dynamic>))
+            .toList() ??
+        [];
+
+    return ContainerData(
+      id: json['id'] as String,
+      fullId: json['full_id'] as String? ?? json['id'] as String,
+      name: json['name'] as String,
+      image: json['image'] as String,
+      state: json['state'] as String,
+      status: json['status'] as String,
+      ports: ports,
+    );
+  }
+
+  final String id;
+  final String fullId;
+  final String name;
+  final String image;
+  final String state;
+  final String status;
+  final List<ContainerPort> ports;
+
+  bool get canStart => state == 'exited' || state == 'created';
+  bool get canStop => state == 'running';
+  bool get canRestart => state == 'running';
+}
+
+class ContainerPort {
+  ContainerPort({required this.privatePort, this.publicPort, this.type = 'tcp'});
+
+  factory ContainerPort.fromJson(Map<String, dynamic> json) => ContainerPort(
+        privatePort: json['private_port'] as int? ?? json['PrivatePort'] as int? ?? 0,
+        publicPort: json['public_port'] as int? ?? json['PublicPort'] as int?,
+        type: json['type'] as String? ?? json['Type'] as String? ?? 'tcp',
+      );
+
+  final int privatePort;
+  final int? publicPort;
+  final String type;
+
+  String get formatted => publicPort != null ? '$publicPort:$privatePort' : '$privatePort';
+}
 
 /// Page displaying the list of containers using DataGrid.
-class ContainersListPage extends ConsumerWidget {
+class ContainersListPage extends ConsumerStatefulWidget {
   const ContainersListPage({super.key});
 
   @override
-  Widget build(BuildContext context, WidgetRef ref) {
+  ConsumerState<ContainersListPage> createState() => _ContainersListPageState();
-    final containersAsync = ref.watch(containersProvider);
+}
+
+class _ContainersListPageState extends ConsumerState<ContainersListPage> {
+  late final StateNotifierProvider<DataGridController<ContainerData>,
+      DataGridState<ContainerData>> _gridProvider;
+
+  @override
+  void initState() {
+    super.initState();
+    final dio = ref.read(coreApiClientProvider);
+    final source = CoreApiDataSource<ContainerData>(
+      dio: dio,
+      endpoint: '/infrastructure/containers',
+      fromJson: ContainerData.fromJson,
+    );
+
+    _gridProvider = dataGridProvider<ContainerData>(
+      source: source,
+      config: _buildConfig(),
+      idSelector: (c) => c.id,
+    );
+  }
+
+  DataGridConfig<ContainerData> _buildConfig() {
+    return DataGridConfig<ContainerData>(
+      columns: [
+        DataGridColumn<ContainerData>(
+          header: 'Container',
+          valueBuilder: (c) => c.name,
+          sortable: true,
+          searchable: true,
+          width: const DataGridColumnWidth.flex(2),
+          cellBuilder: (context, c) => _ContainerCell(container: c),
+        ),
+        DataGridColumn<ContainerData>(
+          header: 'Ports',
+          valueBuilder: (c) => c.ports.map((p) => p.formatted).join(', '),
+          width: const DataGridColumnWidth.flex(1),
+          cellBuilder: (context, c) => _PortsCell(ports: c.ports),
+        ),
+        DataGridColumn<ContainerData>(
+          header: 'Status',
+          valueBuilder: (c) => c.status,
+          width: const DataGridColumnWidth.fixed(140),
+          alignment: DataGridColumnAlignment.end,
+        ),
+      ],
+      actions: [
+        DataGridAction<ContainerData>(
+          icon: Icons.play_arrow,
+          label: 'Start',
+          onTap: (c) async => _handleAction(c, 'start'),
+          showWhen: (c) => c.canStart,
+        ),
+        DataGridAction<ContainerData>(
+          icon: Icons.stop,
+          label: 'Stop',
+          onTap: (c) async => _handleAction(c, 'stop'),
+          showWhen: (c) => c.canStop,
+        ),
+        DataGridAction<ContainerData>(
+          icon: Icons.refresh,
+          label: 'Restart',
+          onTap: (c) async => _handleAction(c, 'restart'),
+          showWhen: (c) => c.canRestart,
+        ),
+        DataGridAction<ContainerData>(
+          icon: Icons.article,
+          label: 'View Logs',
+          onTap: (c) async => _showLogs(c),
+        ),
+      ],
+      enableSearch: true,
+      searchHint: 'Search containers...',
+      showHeader: true,
+      showFooter: true,
+    );
+  }
+
+  Future<void> _handleAction(ContainerData container, String action) async {
+    final actions = ref.read(containerActionsProvider.notifier);
+    switch (action) {
+      case 'start':
+        await actions.start(container.fullId);
+      case 'stop':
+        await actions.stop(container.fullId);
+      case 'restart':
+        await actions.restart(container.fullId);
+    }
+    // Refresh the grid after action
+    ref.read(_gridProvider.notifier).refresh();
+  }
+
+  Future<void> _showLogs(ContainerData container) async {
+    if (!mounted) return;
+    showContainerLogs(
+      context,
+      containerId: container.fullId,
+      containerName: container.name,
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
 
     // Listen for container action results to show snackbars
@@ -53,343 +216,87 @@ class ContainersListPage extends ConsumerWidget {
       }
     });
 
-    return containersAsync.when(
+    return DataGrid<ContainerData>(
-      loading: () => const Center(child: CircularProgressIndicator()),
+      provider: _gridProvider,
-      error: (error, stack) => Center(
+      config: _buildConfig(),
-        child: Column(
+      idSelector: (c) => c.id,
-          mainAxisSize: MainAxisSize.min,
+      toolbarActions: [
-          children: [
+        IconButton(
-            Icon(
+          icon: const Icon(Icons.refresh),
-              Icons.error_outline,
+          tooltip: 'Refresh',
-              size: 48,
+          onPressed: () => ref.read(_gridProvider.notifier).refresh(),
-              color: colorScheme.error,
-            ),
-            const SizedBox(height: 16),
-            const Text('Failed to load containers'),
-            const SizedBox(height: 8),
-            Text(
-              error.toString(),
-              style: TextStyle(color: colorScheme.outline),
-            ),
-            const SizedBox(height: 16),
-            FilledButton.icon(
-              onPressed: () => ref.invalidate(containersProvider),
-              icon: const Icon(Icons.refresh),
-              label: const Text('Retry'),
-            ),
-          ],
-        ),
-      ),
-      data: (containers) => _ContainersList(
-        containers: containers,
-        onAction: (container, action) => _handleAction(ref, container, action),
-        onViewLogs: (c) => showContainerLogs(
-          context,
-          containerId: c.fullId,
-          containerName: c.name,
-        ),
-        onRefresh: () => ref.invalidate(containersProvider),
-      ),
-    );
-  }
-
-  void _handleAction(WidgetRef ref, Container container, String action) {
-    final actions = ref.read(containerActionsProvider.notifier);
-    switch (action) {
-      case 'start':
-        actions.start(container.fullId);
-      case 'stop':
-        actions.stop(container.fullId);
-      case 'restart':
-        actions.restart(container.fullId);
-    }
-  }
-}
-
-class _ContainersList extends StatefulWidget {
-  const _ContainersList({
-    required this.containers,
-    required this.onAction,
-    required this.onViewLogs,
-    required this.onRefresh,
-  });
-
-  final List<Container> containers;
-  final void Function(Container, String) onAction;
-  final void Function(Container) onViewLogs;
-  final VoidCallback onRefresh;
-
-  @override
-  State<_ContainersList> createState() => _ContainersListState();
-}
-
-class _ContainersListState extends State<_ContainersList> {
-  final _searchController = TextEditingController();
-  String _searchQuery = '';
-
-  @override
-  void dispose() {
-    _searchController.dispose();
-    super.dispose();
-  }
-
-  List<Container> get _filteredContainers {
-    if (_searchQuery.isEmpty) return widget.containers;
-    final query = _searchQuery.toLowerCase();
-    return widget.containers.where((c) {
-      return c.name.toLowerCase().contains(query) ||
-          c.image.toLowerCase().contains(query) ||
-          c.status.toLowerCase().contains(query);
-    }).toList();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    final filtered = _filteredContainers;
-
-    return Column(
-      children: [
-        // Toolbar with search
-        Padding(
-          padding: const EdgeInsets.all(16),
-          child: Row(
-            children: [
-              Text(
-                '${filtered.length} of ${widget.containers.length} containers',
-                style: Theme.of(context).textTheme.titleSmall?.copyWith(
-                      color: colorScheme.onSurfaceVariant,
-                    ),
-              ),
-              const Spacer(),
-              SizedBox(
-                width: 250,
-                child: TextField(
-                  controller: _searchController,
-                  decoration: InputDecoration(
-                    hintText: 'Search containers...',
-                    prefixIcon: const Icon(Icons.search, size: 20),
-                    suffixIcon: _searchQuery.isNotEmpty
-                        ? IconButton(
-                            icon: const Icon(Icons.clear, size: 18),
-                            onPressed: () {
-                              _searchController.clear();
-                              setState(() => _searchQuery = '');
-                            },
-                          )
-                        : null,
-                    isDense: true,
-                    contentPadding: const EdgeInsets.symmetric(
-                      horizontal: 12,
-                      vertical: 8,
-                    ),
-                    border: OutlineInputBorder(
-                      borderRadius: BorderRadius.circular(8),
-                    ),
-                  ),
-                  onChanged: (value) => setState(() => _searchQuery = value),
-                ),
-              ),
-              const SizedBox(width: 8),
-              IconButton(
-                icon: const Icon(Icons.refresh),
-                tooltip: 'Refresh',
-                onPressed: widget.onRefresh,
-              ),
-            ],
-          ),
-        ),
-        // Container list or empty state
-        Expanded(
-          child: filtered.isEmpty
-              ? Center(
-                  child: Column(
-                    mainAxisSize: MainAxisSize.min,
-                    children: [
-                      Icon(
-                        _searchQuery.isEmpty
-                            ? Icons.inbox_outlined
-                            : Icons.search_off,
-                        size: 64,
-                        color: colorScheme.outline,
-                      ),
-                      const SizedBox(height: 16),
-                      Text(
-                        _searchQuery.isEmpty
-                            ? 'No containers found'
-                            : 'No containers match "$_searchQuery"',
-                        style: Theme.of(context).textTheme.titleMedium?.copyWith(
-                              color: colorScheme.onSurfaceVariant,
-                            ),
-                      ),
-                      if (_searchQuery.isNotEmpty) ...[
-                        const SizedBox(height: 8),
-                        TextButton(
-                          onPressed: () {
-                            _searchController.clear();
-                            setState(() => _searchQuery = '');
-                          },
-                          child: const Text('Clear search'),
-                        ),
-                      ],
-                    ],
-                  ),
-                )
-              : ListView.builder(
-                  itemCount: filtered.length,
-                  itemBuilder: (context, index) {
-                    final container = filtered[index];
-                    return _ContainerListTile(
-                      container: container,
-                      onAction: (action) => widget.onAction(container, action),
-                      onViewLogs: () => widget.onViewLogs(container),
-                    );
-                  },
-                ),
         ),
       ],
     );
   }
 }
 
-class _ContainerListTile extends StatelessWidget {
+class _ContainerCell extends StatelessWidget {
-  const _ContainerListTile({
+  const _ContainerCell({required this.container});
-    required this.container,
-    required this.onAction,
-    required this.onViewLogs,
-  });
 
-  final Container container;
+  final ContainerData container;
-  final void Function(String) onAction;
-  final VoidCallback onViewLogs;
 
   @override
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
 
-    return Card(
+    return Row(
-      margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
+      children: [
-      child: Padding(
+        ContainerStatusBadge.fromString(container.state),
-        padding: const EdgeInsets.all(12),
+        const SizedBox(width: 8),
-        child: Row(
+        Expanded(
-          children: [
+          child: Column(
-            // Status and name
+            crossAxisAlignment: CrossAxisAlignment.start,
-            Expanded(
+            mainAxisSize: MainAxisSize.min,
-              flex: 2,
+            children: [
-              child: Column(
+              Text(
-                crossAxisAlignment: CrossAxisAlignment.start,
+                container.name,
-                children: [
+                style: const TextStyle(fontWeight: FontWeight.w500),
-                  Row(
+                overflow: TextOverflow.ellipsis,
-                    children: [
-                      ContainerStatusBadge(state: container.state),
-                      const SizedBox(width: 8),
-                      Expanded(
-                        child: Text(
-                          container.name,
-                          style: const TextStyle(fontWeight: FontWeight.w500),
-                          overflow: TextOverflow.ellipsis,
-                        ),
-                      ),
-                    ],
-                  ),
-                  const SizedBox(height: 4),
-                  Text(
-                    container.image,
-                    style: TextStyle(
-                      fontSize: 12,
-                      color: colorScheme.onSurfaceVariant,
-                    ),
-                    overflow: TextOverflow.ellipsis,
-                  ),
-                ],
               ),
-            ),
+              Text(
-            // Ports
+                container.image,
-            if (container.ports.isNotEmpty)
-              Expanded(
-                child: Text(
-                  container.ports.map((p) => p.formatted).join(', '),
-                  style: TextStyle(
-                    fontSize: 12,
-                    color: colorScheme.onSurfaceVariant,
-                    fontFamily: 'monospace',
-                  ),
-                  overflow: TextOverflow.ellipsis,
-                ),
-              ),
-            // Status text
-            SizedBox(
-              width: 120,
-              child: Text(
-                container.status,
                 style: TextStyle(
                   fontSize: 12,
                   color: colorScheme.onSurfaceVariant,
                 ),
-                textAlign: TextAlign.end,
+                overflow: TextOverflow.ellipsis,
               ),
-            ),
+            ],
-            // Actions
+          ),
-            const SizedBox(width: 8),
-            PopupMenuButton<String>(
-              icon: const Icon(Icons.more_vert),
-              tooltip: 'Actions',
-              onSelected: (action) {
-                if (action == 'logs') {
-                  onViewLogs();
-                } else {
-                  onAction(action);
-                }
-              },
-              itemBuilder: (context) => [
-                if (container.canStart)
-                  const PopupMenuItem(
-                    value: 'start',
-                    child: Row(
-                      children: [
-                        Icon(Icons.play_arrow, size: 18),
-                        SizedBox(width: 8),
-                        Text('Start'),
-                      ],
-                    ),
-                  ),
-                if (container.canStop)
-                  const PopupMenuItem(
-                    value: 'stop',
-                    child: Row(
-                      children: [
-                        Icon(Icons.stop, size: 18),
-                        SizedBox(width: 8),
-                        Text('Stop'),
-                      ],
-                    ),
-                  ),
-                if (container.canRestart)
-                  const PopupMenuItem(
-                    value: 'restart',
-                    child: Row(
-                      children: [
-                        Icon(Icons.refresh, size: 18),
-                        SizedBox(width: 8),
-                        Text('Restart'),
-                      ],
-                    ),
-                  ),
-                const PopupMenuItem(
-                  value: 'logs',
-                  child: Row(
-                    children: [
-                      Icon(Icons.article, size: 18),
-                      SizedBox(width: 8),
-                      Text('View Logs'),
-                    ],
-                  ),
-                ),
-              ],
-            ),
-          ],
         ),
+      ],
+    );
+  }
+}
+
+class _PortsCell extends StatelessWidget {
+  const _PortsCell({required this.ports});
+
+  final List<ContainerPort> ports;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    if (ports.isEmpty) {
+      return Text(
+        '-',
+        style: TextStyle(
+          fontSize: 12,
+          color: colorScheme.outline,
+        ),
+      );
+    }
+
+    return Text(
+      ports.map((p) => p.formatted).join(', '),
+      style: TextStyle(
+        fontSize: 12,
+        color: colorScheme.onSurfaceVariant,
+        fontFamily: 'monospace',
       ),
+      overflow: TextOverflow.ellipsis,
     );
   }
 }

lib/features/control_room/containers/presentation/providers/containers_provider.dart

@@ -7,14 +7,14 @@ part 'containers_provider.g.dart';
 
 /// Provides all containers.
 @riverpod
-Future<List<Container>> allContainers(AllContainersRef ref) async {
+Future<List<Container>> allContainers(Ref ref) async {
   final repository = ref.watch(containerRepositoryProvider);
   return repository.getContainers();
 }
 
 /// Provides containers filtered by the selected stack.
 @riverpod
-Future<List<Container>> containers(ContainersRef ref) async {
+Future<List<Container>> containers(Ref ref) async {
   final repository = ref.watch(containerRepositoryProvider);
   final selectedStack = ref.watch(selectedStackProvider);
 
@@ -27,7 +27,7 @@ Future<List<Container>> containers(ContainersRef ref) async {
 
 /// Provides a single container by ID.
 @riverpod
-Future<Container> container(ContainerRef ref, String id) async {
+Future<Container> container(Ref ref, String id) async {
   final repository = ref.watch(containerRepositoryProvider);
   return repository.getContainer(id);
 }
@@ -82,7 +82,7 @@ class ContainerActions extends _$ContainerActions {
 /// Container logs provider.
 @riverpod
 Future<String> containerLogs(
-  ContainerLogsRef ref,
+  Ref ref,
   String id, {
   int? tail = 100,
 }) async {

lib/features/control_room/containers/presentation/widgets/container_logs_viewer.dart

@@ -22,7 +22,6 @@ class ContainerLogsViewer extends ConsumerStatefulWidget {
 class _ContainerLogsViewerState extends ConsumerState<ContainerLogsViewer> {
   final _scrollController = ScrollController();
   int _tailLines = 100;
-  bool _autoScroll = true;
 
   @override
   void dispose() {

lib/features/control_room/containers/presentation/widgets/container_status_badge.dart

@@ -1,5 +1,23 @@
 import 'package:flutter/material.dart' hide Container;
-import 'package:tatlock_ui/features/control_room/containers/domain/entities/container.dart';
+
+/// Container state enum for status display.
+enum ContainerState {
+  created,
+  running,
+  paused,
+  restarting,
+  removing,
+  exited,
+  dead;
+
+  /// Parse a string to ContainerState.
+  static ContainerState fromString(String value) {
+    return ContainerState.values.firstWhere(
+      (s) => s.name == value.toLowerCase(),
+      orElse: () => ContainerState.exited,
+    );
+  }
+}
 
 /// Status badge for container state.
 class ContainerStatusBadge extends StatelessWidget {
@@ -9,6 +27,14 @@ class ContainerStatusBadge extends StatelessWidget {
     this.showLabel = true,
   });
 
+  /// Create badge from a string state value.
+  factory ContainerStatusBadge.fromString(String state, {bool showLabel = true}) {
+    return ContainerStatusBadge(
+      state: ContainerState.fromString(state),
+      showLabel: showLabel,
+    );
+  }
+
   final ContainerState state;
   final bool showLabel;
 

lib/features/control_room/npm/data/datasources/proxy_hosts_datasource.dart

@@ -0,0 +1,68 @@
+import 'package:dio/dio.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:tatlock_ui/core/api/api_client.dart';
+import 'package:tatlock_ui/features/control_room/npm/data/models/proxy_host_model.dart';
+
+part 'proxy_hosts_datasource.g.dart';
+
+/// Remote data source for NPM proxy host operations via Core API.
+class ProxyHostsDatasource {
+  ProxyHostsDatasource(this._dio);
+
+  final Dio _dio;
+
+  /// Gets all configured domains from Core API.
+  Future<List<DomainInfoModel>> getDomains() async {
+    final response = await _dio.get<List<dynamic>>(
+      '/infrastructure/domains',
+    );
+
+    return response.data!
+        .map((json) => DomainInfoModel.fromJson(json as Map<String, dynamic>))
+        .toList();
+  }
+
+  /// Gets detailed proxy host configuration by ID.
+  Future<ProxyHostModel> getProxyHost(int proxyId) async {
+    final response = await _dio.get<Map<String, dynamic>>(
+      '/infrastructure/proxy/$proxyId',
+    );
+
+    return ProxyHostModel.fromJson(response.data!);
+  }
+
+  /// Creates a new proxy host.
+  Future<void> createProxyHost({
+    required List<String> domainNames,
+    required String forwardScheme,
+    required String forwardHost,
+    required int forwardPort,
+    bool sslEnabled = false,
+  }) async {
+    await _dio.post<void>(
+      '/infrastructure/proxy',
+      data: {
+        'domain_names': domainNames,
+        'forward_scheme': forwardScheme,
+        'forward_host': forwardHost,
+        'forward_port': forwardPort,
+        'ssl_enabled': sslEnabled,
+      },
+    );
+  }
+
+  /// Updates an existing proxy host.
+  Future<void> updateProxyHost(int proxyId, Map<String, dynamic> config) async {
+    await _dio.put<void>(
+      '/infrastructure/proxy/$proxyId',
+      data: config,
+    );
+  }
+}
+
+/// Provides the proxy hosts datasource.
+@riverpod
+ProxyHostsDatasource proxyHostsDatasource(Ref ref) {
+  final dio = ref.watch(coreApiClientProvider);
+  return ProxyHostsDatasource(dio);
+}

lib/features/control_room/npm/data/models/proxy_host_model.dart

@@ -0,0 +1,137 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:tatlock_ui/features/control_room/npm/domain/entities/proxy_host.dart';
+
+part 'proxy_host_model.freezed.dart';
+part 'proxy_host_model.g.dart';
+
+/// Converts API values that can be either int or bool (false) to int?.
+/// NPM returns false instead of null for missing IDs.
+class NullableIntOrBoolConverter implements JsonConverter<int?, dynamic> {
+  const NullableIntOrBoolConverter();
+
+  @override
+  int? fromJson(dynamic json) {
+    if (json == null || json == false) return null;
+    if (json is int) return json;
+    if (json is num) return json.toInt();
+    return null;
+  }
+
+  @override
+  dynamic toJson(int? object) => object;
+}
+
+/// Converts API values that can be either int or bool to int.
+/// NPM returns true/false for some 0/1 fields.
+class IntOrBoolConverter implements JsonConverter<int, dynamic> {
+  const IntOrBoolConverter();
+
+  @override
+  int fromJson(dynamic json) {
+    if (json == null) return 0;
+    if (json is bool) return json ? 1 : 0;
+    if (json is int) return json;
+    if (json is num) return json.toInt();
+    return 0;
+  }
+
+  @override
+  dynamic toJson(int object) => object;
+}
+
+/// Proxy host data model for API serialization.
+///
+/// Maps to the NPM API response format via Core API.
+@freezed
+sealed class ProxyHostModel with _$ProxyHostModel {
+  const factory ProxyHostModel({
+    required int id,
+    @JsonKey(name: 'domain_names') required List<String> domainNames,
+    @JsonKey(name: 'forward_scheme') required String forwardScheme,
+    @JsonKey(name: 'forward_host') required String forwardHost,
+    @JsonKey(name: 'forward_port') required int forwardPort,
+    @JsonKey(name: 'ssl_forced') @Default(false) bool sslForced,
+    @NullableIntOrBoolConverter() @JsonKey(name: 'certificate_id') int? certificateId,
+    @IntOrBoolConverter() @Default(1) int enabled,
+    @IntOrBoolConverter() @JsonKey(name: 'http2_support') @Default(0) int http2Support,
+    @IntOrBoolConverter() @JsonKey(name: 'hsts_enabled') @Default(0) int hstsEnabled,
+    @NullableIntOrBoolConverter() @JsonKey(name: 'access_list_id') int? accessListId,
+    @IntOrBoolConverter() @JsonKey(name: 'caching_enabled') @Default(0) int cachingEnabled,
+    @IntOrBoolConverter() @JsonKey(name: 'block_exploits') @Default(0) int blockExploits,
+    @IntOrBoolConverter() @JsonKey(name: 'allow_websocket_upgrade') @Default(0) int allowWebsocketUpgrade,
+    @JsonKey(name: 'created_on') String? createdOn,
+    @JsonKey(name: 'modified_on') String? modifiedOn,
+    @Default([]) List<ProxyLocationModel> locations,
+  }) = _ProxyHostModel;
+
+  const ProxyHostModel._();
+
+  factory ProxyHostModel.fromJson(Map<String, dynamic> json) =>
+      _$ProxyHostModelFromJson(json);
+
+  /// Converts to domain entity.
+  ProxyHost toEntity() {
+    return ProxyHost(
+      id: id,
+      domainNames: domainNames,
+      forwardScheme: forwardScheme,
+      forwardHost: forwardHost,
+      forwardPort: forwardPort,
+      sslEnabled: certificateId != null && certificateId! > 0,
+      certificateId: certificateId,
+      enabled: enabled == 1,
+      http2Support: http2Support == 1,
+      hstsEnabled: hstsEnabled == 1,
+      forceSSL: sslForced,
+      accessListId: accessListId,
+      cacheAssets: cachingEnabled == 1,
+      blockExploits: blockExploits == 1,
+      websocketSupport: allowWebsocketUpgrade == 1,
+      locations: locations.map((l) => l.toEntity()).toList(),
+      createdAt: createdOn != null ? DateTime.tryParse(createdOn!) : null,
+      modifiedAt: modifiedOn != null ? DateTime.tryParse(modifiedOn!) : null,
+    );
+  }
+}
+
+/// Proxy location model.
+@freezed
+sealed class ProxyLocationModel with _$ProxyLocationModel {
+  const factory ProxyLocationModel({
+    required String path,
+    @JsonKey(name: 'forward_scheme') required String forwardScheme,
+    @JsonKey(name: 'forward_host') required String forwardHost,
+    @JsonKey(name: 'forward_port') required int forwardPort,
+  }) = _ProxyLocationModel;
+
+  const ProxyLocationModel._();
+
+  factory ProxyLocationModel.fromJson(Map<String, dynamic> json) =>
+      _$ProxyLocationModelFromJson(json);
+
+  ProxyLocation toEntity() {
+    return ProxyLocation(
+      path: path,
+      forwardScheme: forwardScheme,
+      forwardHost: forwardHost,
+      forwardPort: forwardPort,
+    );
+  }
+}
+
+/// Domain info model for the /infrastructure/domains endpoint.
+///
+/// This is a simpler model used for listing domains.
+@freezed
+sealed class DomainInfoModel with _$DomainInfoModel {
+  const factory DomainInfoModel({
+    required String domain,
+    required String service,
+    @JsonKey(name: 'proxy_host_id') required int proxyHostId,
+    @JsonKey(name: 'ssl_enabled') @Default(false) bool sslEnabled,
+    @JsonKey(name: 'certificate_id') int? certificateId,
+  }) = _DomainInfoModel;
+
+  factory DomainInfoModel.fromJson(Map<String, dynamic> json) =>
+      _$DomainInfoModelFromJson(json);
+}

lib/features/control_room/npm/domain/entities/proxy_host.dart

@@ -0,0 +1,93 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'proxy_host.freezed.dart';
+
+/// NPM proxy host entity representing a domain configuration.
+@freezed
+sealed class ProxyHost with _$ProxyHost {
+  const factory ProxyHost({
+    /// Proxy host ID.
+    required int id,
+
+    /// Domain names (can have multiple).
+    required List<String> domainNames,
+
+    /// Forward scheme (http or https).
+    required String forwardScheme,
+
+    /// Forward host (IP or hostname).
+    required String forwardHost,
+
+    /// Forward port.
+    required int forwardPort,
+
+    /// Whether SSL is enabled.
+    required bool sslEnabled,
+
+    /// SSL certificate ID (if enabled).
+    int? certificateId,
+
+    /// Whether the host is enabled.
+    @Default(true) bool enabled,
+
+    /// Whether HTTP/2 is enabled.
+    @Default(false) bool http2Support,
+
+    /// Whether HSTS is enabled.
+    @Default(false) bool hstsEnabled,
+
+    /// Whether to force SSL.
+    @Default(false) bool forceSSL,
+
+    /// Custom locations (advanced nginx config).
+    @Default([]) List<ProxyLocation> locations,
+
+    /// Access list ID (for auth).
+    int? accessListId,
+
+    /// Cache assets enabled.
+    @Default(false) bool cacheAssets,
+
+    /// Block common exploits.
+    @Default(false) bool blockExploits,
+
+    /// Websocket support.
+    @Default(false) bool websocketSupport,
+
+    /// Created timestamp.
+    DateTime? createdAt,
+
+    /// Modified timestamp.
+    DateTime? modifiedAt,
+  }) = _ProxyHost;
+
+  const ProxyHost._();
+
+  /// Primary domain (first in list).
+  String get primaryDomain =>
+      domainNames.isNotEmpty ? domainNames.first : 'Unknown';
+
+  /// Forward URL (scheme://host:port).
+  String get forwardUrl => '$forwardScheme://$forwardHost:$forwardPort';
+
+  /// SSL status label.
+  String get sslStatus => sslEnabled ? 'SSL Enabled' : 'No SSL';
+}
+
+/// Proxy location for advanced routing.
+@freezed
+sealed class ProxyLocation with _$ProxyLocation {
+  const factory ProxyLocation({
+    /// Location path.
+    required String path,
+
+    /// Forward scheme.
+    required String forwardScheme,
+
+    /// Forward host.
+    required String forwardHost,
+
+    /// Forward port.
+    required int forwardPort,
+  }) = _ProxyLocation;
+}

lib/features/control_room/npm/presentation/pages/proxy_host_page.dart

@@ -0,0 +1,297 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:tatlock_ui/features/control_room/npm/domain/entities/proxy_host.dart';
+import 'package:tatlock_ui/features/control_room/npm/presentation/providers/proxy_hosts_provider.dart';
+import 'package:tatlock_ui/features/control_room/npm/presentation/widgets/proxy_host_form.dart';
+import 'package:tatlock_ui/shared/widgets/entity_page.dart';
+
+/// Unified page for proxy host create, view, and edit.
+///
+/// Usage:
+/// - Create: `ProxyHostPage.create(onClose: ...)`
+/// - View/Edit: `ProxyHostPage(proxyHostId: 123, onClose: ...)`
+class ProxyHostPage extends ConsumerStatefulWidget {
+  const ProxyHostPage({
+    super.key,
+    required this.proxyHostId,
+    required this.onClose,
+  }) : _isCreate = false;
+
+  const ProxyHostPage.create({
+    super.key,
+    required this.onClose,
+  })  : proxyHostId = null,
+        _isCreate = true;
+
+  final int? proxyHostId;
+  final VoidCallback onClose;
+  final bool _isCreate;
+
+  @override
+  ConsumerState<ProxyHostPage> createState() => _ProxyHostPageState();
+}
+
+class _ProxyHostPageState extends ConsumerState<ProxyHostPage>
+    with EntityPageModeMixin {
+  @override
+  void initState() {
+    super.initState();
+    // Start in create mode if no ID, otherwise view mode
+    mode = widget._isCreate ? EntityPageMode.create : EntityPageMode.view;
+  }
+
+  String get _title {
+    switch (mode) {
+      case EntityPageMode.create:
+        return 'New Proxy Host';
+      case EntityPageMode.view:
+        return 'Proxy Host Details';
+      case EntityPageMode.edit:
+        return 'Edit Proxy Host';
+    }
+  }
+
+  void _handleSaved() {
+    if (widget._isCreate) {
+      // After create, close and return to list
+      widget.onClose();
+    } else {
+      // After edit, return to view mode and refresh
+      stopEditing();
+      ref.invalidate(proxyHostProvider(widget.proxyHostId!));
+    }
+    ref.invalidate(domainsProvider);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    // Create mode - no need to fetch existing data
+    if (widget._isCreate) {
+      return EntityPageScaffold(
+        title: _title,
+        onBack: widget.onClose,
+        child: ProxyHostForm(
+          mode: EntityPageMode.create,
+          onCancel: widget.onClose,
+          onSaved: _handleSaved,
+        ),
+      );
+    }
+
+    // View/Edit mode - fetch existing proxy host
+    final proxyHostAsync = ref.watch(proxyHostProvider(widget.proxyHostId!));
+
+    return EntityPageScaffold(
+      title: _title,
+      onBack: widget.onClose,
+      actions: [
+        if (isViewing)
+          IconButton(
+            icon: const Icon(Icons.edit),
+            tooltip: 'Edit',
+            onPressed: startEditing,
+          ),
+        IconButton(
+          icon: const Icon(Icons.refresh),
+          tooltip: 'Refresh',
+          onPressed: () =>
+              ref.invalidate(proxyHostProvider(widget.proxyHostId!)),
+        ),
+      ],
+      child: EntityAsyncContent<ProxyHost>(
+        isLoading: proxyHostAsync.isLoading,
+        error: proxyHostAsync.error,
+        data: proxyHostAsync.value,
+        onRetry: () => ref.invalidate(proxyHostProvider(widget.proxyHostId!)),
+        builder: (proxyHost) {
+          if (isEditing) {
+            return ProxyHostForm(
+              mode: EntityPageMode.edit,
+              proxyHost: proxyHost,
+              onCancel: stopEditing,
+              onSaved: _handleSaved,
+            );
+          }
+          return _ProxyHostView(proxyHost: proxyHost);
+        },
+      ),
+    );
+  }
+}
+
+/// Read-only view of proxy host details.
+class _ProxyHostView extends StatelessWidget {
+  const _ProxyHostView({required this.proxyHost});
+
+  final ProxyHost proxyHost;
+
+  @override
+  Widget build(BuildContext context) {
+    return SingleChildScrollView(
+      padding: const EdgeInsets.all(24),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          // Domain names
+          EntitySection(
+            title: 'Domain Names',
+            icon: Icons.public,
+            child: Wrap(
+              spacing: 8,
+              runSpacing: 8,
+              children: proxyHost.domainNames.map((domain) {
+                return Chip(
+                  avatar: Icon(
+                    proxyHost.sslEnabled ? Icons.lock : Icons.lock_open,
+                    size: 16,
+                    color: proxyHost.sslEnabled ? Colors.green : null,
+                  ),
+                  label: Text(domain),
+                );
+              }).toList(),
+            ),
+          ),
+          const SizedBox(height: 24),
+
+          // Forward destination
+          EntitySection(
+            title: 'Forward Destination',
+            icon: Icons.arrow_forward,
+            child: Card(
+              child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Row(
+                  children: [
+                    Icon(Icons.dns,
+                        color: Theme.of(context).colorScheme.primary),
+                    const SizedBox(width: 12),
+                    Expanded(
+                      child: Column(
+                        crossAxisAlignment: CrossAxisAlignment.start,
+                        children: [
+                          Text(
+                            proxyHost.forwardUrl,
+                            style: Theme.of(context)
+                                .textTheme
+                                .titleMedium
+                                ?.copyWith(fontFamily: 'monospace'),
+                          ),
+                          const SizedBox(height: 4),
+                          Text(
+                            '${proxyHost.forwardScheme.toUpperCase()} → ${proxyHost.forwardHost}:${proxyHost.forwardPort}',
+                            style: TextStyle(
+                                color: Theme.of(context).colorScheme.outline),
+                          ),
+                        ],
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+          const SizedBox(height: 24),
+
+          // SSL Settings
+          EntitySection(
+            title: 'SSL Settings',
+            icon: Icons.verified_user,
+            child: Card(
+              child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Column(
+                  children: [
+                    EntitySettingRow(
+                      label: 'SSL Enabled',
+                      value: proxyHost.sslEnabled,
+                    ),
+                    if (proxyHost.sslEnabled) ...[
+                      const Divider(),
+                      EntitySettingRow(
+                        label: 'Force SSL',
+                        value: proxyHost.forceSSL,
+                        subtitle: 'Redirect HTTP to HTTPS',
+                      ),
+                      const Divider(),
+                      EntitySettingRow(
+                        label: 'HTTP/2 Support',
+                        value: proxyHost.http2Support,
+                      ),
+                      const Divider(),
+                      EntitySettingRow(
+                        label: 'HSTS Enabled',
+                        value: proxyHost.hstsEnabled,
+                      ),
+                    ],
+                  ],
+                ),
+              ),
+            ),
+          ),
+          const SizedBox(height: 24),
+
+          // Advanced Settings
+          EntitySection(
+            title: 'Advanced Settings',
+            icon: Icons.settings,
+            child: Card(
+              child: Padding(
+                padding: const EdgeInsets.all(16),
+                child: Column(
+                  children: [
+                    EntitySettingRow(
+                      label: 'WebSocket Support',
+                      value: proxyHost.websocketSupport,
+                    ),
+                    const Divider(),
+                    EntitySettingRow(
+                      label: 'Block Exploits',
+                      value: proxyHost.blockExploits,
+                    ),
+                    const Divider(),
+                    EntitySettingRow(
+                      label: 'Cache Assets',
+                      value: proxyHost.cacheAssets,
+                    ),
+                    const Divider(),
+                    EntitySettingRow(
+                      label: 'Enabled',
+                      value: proxyHost.enabled,
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ),
+
+          // Locations (if any)
+          if (proxyHost.locations.isNotEmpty) ...[
+            const SizedBox(height: 24),
+            EntitySection(
+              title: 'Custom Locations',
+              icon: Icons.route,
+              child: Card(
+                child: ListView.separated(
+                  shrinkWrap: true,
+                  physics: const NeverScrollableScrollPhysics(),
+                  itemCount: proxyHost.locations.length,
+                  separatorBuilder: (_, index) => const Divider(height: 1),
+                  itemBuilder: (context, index) {
+                    final loc = proxyHost.locations[index];
+                    return ListTile(
+                      leading: const Icon(Icons.subdirectory_arrow_right),
+                      title: Text(loc.path,
+                          style: const TextStyle(fontFamily: 'monospace')),
+                      subtitle: Text(
+                          '${loc.forwardScheme}://${loc.forwardHost}:${loc.forwardPort}'),
+                    );
+                  },
+                ),
+              ),
+            ),
+          ],
+        ],
+      ),
+    );
+  }
+}

lib/features/control_room/npm/presentation/pages/proxy_hosts_page.dart

@@ -0,0 +1,243 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:tatlock_ui/core/api/api_client.dart';
+import 'package:tatlock_ui/features/control_room/npm/presentation/pages/proxy_host_page.dart';
+import 'package:tatlock_ui/features/control_room/npm/presentation/providers/proxy_hosts_provider.dart';
+import 'package:tatlock_ui/shared/components/data_grid/adapters/core_api_source.dart';
+import 'package:tatlock_ui/shared/components/data_grid/data_grid_exports.dart';
+
+/// Domain info data class for DataGrid display.
+class DomainData {
+  DomainData({
+    required this.domain,
+    required this.service,
+    required this.proxyHostId,
+    required this.sslEnabled,
+    this.certificateId,
+  });
+
+  factory DomainData.fromJson(Map<String, dynamic> json) => DomainData(
+        domain: json['domain'] as String,
+        service: json['service'] as String,
+        proxyHostId: json['proxy_host_id'] as int,
+        sslEnabled: json['ssl_enabled'] as bool? ?? false,
+        certificateId: json['certificate_id'] as int?,
+      );
+
+  final String domain;
+  final String service;
+  final int proxyHostId;
+  final bool sslEnabled;
+  final int? certificateId;
+}
+
+/// Page displaying the list of proxy hosts (domains) from NPM.
+class ProxyHostsPage extends ConsumerStatefulWidget {
+  const ProxyHostsPage({super.key});
+
+  @override
+  ConsumerState<ProxyHostsPage> createState() => _ProxyHostsPageState();
+}
+
+class _ProxyHostsPageState extends ConsumerState<ProxyHostsPage> {
+  late final StateNotifierProvider<DataGridController<DomainData>,
+      DataGridState<DomainData>> _gridProvider;
+
+  @override
+  void initState() {
+    super.initState();
+    final dio = ref.read(coreApiClientProvider);
+    final source = CoreApiDataSource<DomainData>(
+      dio: dio,
+      endpoint: '/infrastructure/domains',
+      fromJson: DomainData.fromJson,
+    );
+
+    _gridProvider = dataGridProvider<DomainData>(
+      source: source,
+      config: _buildConfig(),
+      idSelector: (d) => d.proxyHostId.toString(),
+    );
+  }
+
+  DataGridConfig<DomainData> _buildConfig() {
+    return DataGridConfig<DomainData>(
+      columns: [
+        DataGridColumn<DomainData>(
+          header: 'Domain',
+          valueBuilder: (d) => d.domain,
+          sortable: true,
+          searchable: true,
+          width: const DataGridColumnWidth.flex(2),
+          cellBuilder: (context, d) => _DomainCell(domain: d),
+        ),
+        DataGridColumn<DomainData>(
+          header: 'Service',
+          valueBuilder: (d) => d.service,
+          width: const DataGridColumnWidth.flex(1),
+          cellBuilder: (context, d) => _ServiceCell(service: d.service),
+        ),
+        DataGridColumn<DomainData>(
+          header: 'SSL',
+          valueBuilder: (d) => d.sslEnabled ? 'Enabled' : 'Disabled',
+          width: const DataGridColumnWidth.fixed(100),
+          alignment: DataGridColumnAlignment.end,
+          cellBuilder: (context, d) => _SslBadge(enabled: d.sslEnabled),
+        ),
+      ],
+      actions: [
+        DataGridAction<DomainData>(
+          icon: Icons.edit,
+          label: 'Edit',
+          onTap: (d) async => _viewDomain(d),
+        ),
+      ],
+      enableSearch: true,
+      searchHint: 'Search domains...',
+      showHeader: true,
+      showFooter: true,
+    );
+  }
+
+  void _viewDomain(DomainData domain) {
+    ref.read(selectedProxyHostProvider.notifier).select(domain.proxyHostId);
+  }
+
+  void _createNew() {
+    ref.read(creatingProxyHostProvider.notifier).start();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final selectedId = ref.watch(selectedProxyHostProvider);
+    final isCreating = ref.watch(creatingProxyHostProvider);
+
+    // Show create page if creating new
+    if (isCreating) {
+      return ProxyHostPage.create(
+        onClose: () {
+          ref.read(creatingProxyHostProvider.notifier).stop();
+          ref.read(_gridProvider.notifier).refresh();
+        },
+      );
+    }
+
+    // Show detail page if a proxy host is selected
+    if (selectedId != null) {
+      return ProxyHostPage(
+        proxyHostId: selectedId,
+        onClose: () {
+          ref.read(selectedProxyHostProvider.notifier).clear();
+          ref.read(_gridProvider.notifier).refresh();
+        },
+      );
+    }
+
+    return DataGrid<DomainData>(
+      provider: _gridProvider,
+      config: _buildConfig(),
+      idSelector: (d) => d.proxyHostId.toString(),
+      toolbarActions: [
+        IconButton(
+          icon: const Icon(Icons.refresh),
+          tooltip: 'Refresh',
+          onPressed: () => ref.read(_gridProvider.notifier).refresh(),
+        ),
+        const SizedBox(width: 8),
+        FilledButton.icon(
+          onPressed: _createNew,
+          icon: const Icon(Icons.add),
+          label: const Text('New'),
+        ),
+      ],
+    );
+  }
+}
+
+class _DomainCell extends StatelessWidget {
+  const _DomainCell({required this.domain});
+
+  final DomainData domain;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Row(
+      children: [
+        Container(
+          padding: const EdgeInsets.all(8),
+          decoration: BoxDecoration(
+            color: domain.sslEnabled
+                ? Colors.green.withValues(alpha: 0.1)
+                : colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(8),
+          ),
+          child: Icon(
+            domain.sslEnabled ? Icons.lock : Icons.lock_open,
+            size: 20,
+            color: domain.sslEnabled ? Colors.green : colorScheme.outline,
+          ),
+        ),
+        const SizedBox(width: 12),
+        Expanded(
+          child: Text(
+            domain.domain,
+            style: const TextStyle(fontWeight: FontWeight.w500),
+            overflow: TextOverflow.ellipsis,
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _ServiceCell extends StatelessWidget {
+  const _ServiceCell({required this.service});
+
+  final String service;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Text(
+      service,
+      style: TextStyle(
+        fontSize: 12,
+        color: colorScheme.onSurfaceVariant,
+        fontFamily: 'monospace',
+      ),
+      overflow: TextOverflow.ellipsis,
+    );
+  }
+}
+
+class _SslBadge extends StatelessWidget {
+  const _SslBadge({required this.enabled});
+
+  final bool enabled;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+      decoration: BoxDecoration(
+        color: enabled
+            ? Colors.green.withValues(alpha: 0.1)
+            : colorScheme.surfaceContainerHighest,
+        borderRadius: BorderRadius.circular(4),
+      ),
+      child: Text(
+        enabled ? 'SSL' : 'HTTP',
+        style: TextStyle(
+          fontSize: 11,
+          fontWeight: FontWeight.w500,
+          color: enabled ? Colors.green : colorScheme.outline,
+        ),
+      ),
+    );
+  }
+}

lib/features/control_room/npm/presentation/providers/proxy_hosts_provider.dart

@@ -0,0 +1,72 @@
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+import 'package:tatlock_ui/features/control_room/npm/data/datasources/proxy_hosts_datasource.dart';
+import 'package:tatlock_ui/features/control_room/npm/data/models/proxy_host_model.dart';
+import 'package:tatlock_ui/features/control_room/npm/domain/entities/proxy_host.dart';
+
+part 'proxy_hosts_provider.g.dart';
+
+/// Provider for the list of configured domains.
+@riverpod
+Future<List<DomainInfoModel>> domains(Ref ref) async {
+  final datasource = ref.watch(proxyHostsDatasourceProvider);
+  return datasource.getDomains();
+}
+
+/// Provider for a specific proxy host details.
+@riverpod
+Future<ProxyHost> proxyHost(Ref ref, int proxyId) async {
+  final datasource = ref.watch(proxyHostsDatasourceProvider);
+  final model = await datasource.getProxyHost(proxyId);
+  return model.toEntity();
+}
+
+/// Provider for selected proxy host ID (for detail view).
+@riverpod
+class SelectedProxyHost extends _$SelectedProxyHost {
+  @override
+  int? build() => null;
+
+  void select(int id) => state = id;
+  void clear() => state = null;
+}
+
+/// Provider for tracking if we're creating a new proxy host.
+@riverpod
+class CreatingProxyHost extends _$CreatingProxyHost {
+  @override
+  bool build() => false;
+
+  void start() => state = true;
+  void stop() => state = false;
+}
+
+/// Provider for creating a new proxy host.
+@riverpod
+Future<void> createProxyHost(
+  Ref ref, {
+  required List<String> domainNames,
+  required String forwardScheme,
+  required String forwardHost,
+  required int forwardPort,
+  bool sslEnabled = false,
+}) async {
+  final datasource = ref.watch(proxyHostsDatasourceProvider);
+  await datasource.createProxyHost(
+    domainNames: domainNames,
+    forwardScheme: forwardScheme,
+    forwardHost: forwardHost,
+    forwardPort: forwardPort,
+    sslEnabled: sslEnabled,
+  );
+}
+
+/// Provider for updating an existing proxy host.
+@riverpod
+Future<void> updateProxyHost(
+  Ref ref, {
+  required int id,
+  required Map<String, dynamic> config,
+}) async {
+  final datasource = ref.watch(proxyHostsDatasourceProvider);
+  await datasource.updateProxyHost(id, config);
+}

lib/features/control_room/npm/presentation/widgets/proxy_host_form.dart

@@ -0,0 +1,291 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:tatlock_ui/features/control_room/npm/domain/entities/proxy_host.dart';
+import 'package:tatlock_ui/features/control_room/npm/presentation/providers/proxy_hosts_provider.dart';
+import 'package:tatlock_ui/shared/widgets/entity_form_dialog.dart';
+import 'package:tatlock_ui/shared/widgets/entity_page.dart';
+
+/// Form for creating or editing a proxy host.
+class ProxyHostForm extends ConsumerStatefulWidget {
+  const ProxyHostForm({
+    super.key,
+    this.proxyHost,
+    this.mode = EntityPageMode.create,
+    required this.onCancel,
+    required this.onSaved,
+  });
+
+  /// Existing proxy host for editing (null for create).
+  final ProxyHost? proxyHost;
+
+  /// Form mode - create or edit.
+  final EntityPageMode mode;
+
+  final VoidCallback onCancel;
+  final VoidCallback onSaved;
+
+  bool get isEditing => mode == EntityPageMode.edit;
+
+  @override
+  ConsumerState<ProxyHostForm> createState() => _ProxyHostFormState();
+}
+
+class _ProxyHostFormState extends ConsumerState<ProxyHostForm> {
+  final _formKey = GlobalKey<FormState>();
+
+  late final TextEditingController _domainController;
+  late final TextEditingController _forwardHostController;
+  late final TextEditingController _forwardPortController;
+
+  late String _forwardScheme;
+  late bool _forceSSL;
+  late bool _http2Support;
+  late bool _websocketSupport;
+  late bool _blockExploits;
+  late bool _cacheAssets;
+
+  bool _isSaving = false;
+  String? _error;
+
+  @override
+  void initState() {
+    super.initState();
+    final host = widget.proxyHost;
+
+    _domainController = TextEditingController(
+      text: host?.domainNames.join(', ') ?? '',
+    );
+    _forwardHostController = TextEditingController(
+      text: host?.forwardHost ?? '',
+    );
+    _forwardPortController = TextEditingController(
+      text: host?.forwardPort.toString() ?? '80',
+    );
+
+    _forwardScheme = host?.forwardScheme ?? 'http';
+    _forceSSL = host?.forceSSL ?? false;
+    _http2Support = host?.http2Support ?? false;
+    _websocketSupport = host?.websocketSupport ?? false;
+    _blockExploits = host?.blockExploits ?? true;
+    _cacheAssets = host?.cacheAssets ?? false;
+  }
+
+  @override
+  void dispose() {
+    _domainController.dispose();
+    _forwardHostController.dispose();
+    _forwardPortController.dispose();
+    super.dispose();
+  }
+
+  Future<void> _handleSave() async {
+    if (!_formKey.currentState!.validate()) return;
+
+    setState(() {
+      _isSaving = true;
+      _error = null;
+    });
+
+    try {
+      final domains = _domainController.text
+          .split(',')
+          .map((d) => d.trim())
+          .where((d) => d.isNotEmpty)
+          .toList();
+
+      if (widget.isEditing) {
+        await ref.read(updateProxyHostProvider(
+          id: widget.proxyHost!.id,
+          config: {
+            'domain_names': domains,
+            'forward_scheme': _forwardScheme,
+            'forward_host': _forwardHostController.text,
+            'forward_port': int.parse(_forwardPortController.text),
+            'ssl_forced': _forceSSL,
+            'http2_support': _http2Support ? 1 : 0,
+            'allow_websocket_upgrade': _websocketSupport ? 1 : 0,
+            'block_exploits': _blockExploits ? 1 : 0,
+            'caching_enabled': _cacheAssets ? 1 : 0,
+          },
+        ).future);
+      } else {
+        await ref.read(createProxyHostProvider(
+          domainNames: domains,
+          forwardScheme: _forwardScheme,
+          forwardHost: _forwardHostController.text,
+          forwardPort: int.parse(_forwardPortController.text),
+        ).future);
+      }
+
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(
+            content: Text(widget.isEditing
+                ? 'Proxy host updated successfully'
+                : 'Proxy host created successfully'),
+            backgroundColor: Colors.green,
+          ),
+        );
+        widget.onSaved();
+      }
+    } catch (e) {
+      setState(() => _error = e.toString());
+    } finally {
+      if (mounted) {
+        setState(() => _isSaving = false);
+      }
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return EntityForm(
+      formKey: _formKey,
+      mode: widget.mode,
+      onCancel: widget.onCancel,
+      onSave: _handleSave,
+      isSaving: _isSaving,
+      error: _error,
+      children: [
+        // Domain Names
+        Text('Domain Names', style: Theme.of(context).textTheme.titleMedium),
+        const SizedBox(height: 8),
+        TextFormField(
+          controller: _domainController,
+          decoration: const InputDecoration(
+            hintText: 'example.com, www.example.com',
+            helperText: 'Separate multiple domains with commas',
+            border: OutlineInputBorder(),
+          ),
+          validator: (value) {
+            if (value == null || value.trim().isEmpty) {
+              return 'At least one domain is required';
+            }
+            return null;
+          },
+        ),
+        const SizedBox(height: 24),
+
+        // Forward Destination
+        Text('Forward Destination', style: Theme.of(context).textTheme.titleMedium),
+        const SizedBox(height: 8),
+        Row(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            // Scheme dropdown
+            SizedBox(
+              width: 120,
+              child: DropdownButtonFormField<String>(
+                initialValue: _forwardScheme,
+                decoration: const InputDecoration(
+                  labelText: 'Scheme',
+                  border: OutlineInputBorder(),
+                ),
+                items: const [
+                  DropdownMenuItem(value: 'http', child: Text('HTTP')),
+                  DropdownMenuItem(value: 'https', child: Text('HTTPS')),
+                ],
+                onChanged: (value) {
+                  if (value != null) setState(() => _forwardScheme = value);
+                },
+              ),
+            ),
+            const SizedBox(width: 12),
+            // Host
+            Expanded(
+              flex: 2,
+              child: TextFormField(
+                controller: _forwardHostController,
+                decoration: const InputDecoration(
+                  labelText: 'Host',
+                  hintText: '192.168.1.100 or hostname',
+                  border: OutlineInputBorder(),
+                ),
+                validator: (value) {
+                  if (value == null || value.trim().isEmpty) {
+                    return 'Host is required';
+                  }
+                  return null;
+                },
+              ),
+            ),
+            const SizedBox(width: 12),
+            // Port
+            SizedBox(
+              width: 100,
+              child: TextFormField(
+                controller: _forwardPortController,
+                decoration: const InputDecoration(
+                  labelText: 'Port',
+                  border: OutlineInputBorder(),
+                ),
+                keyboardType: TextInputType.number,
+                validator: (value) {
+                  if (value == null || value.trim().isEmpty) {
+                    return 'Required';
+                  }
+                  final port = int.tryParse(value);
+                  if (port == null || port < 1 || port > 65535) {
+                    return 'Invalid';
+                  }
+                  return null;
+                },
+              ),
+            ),
+          ],
+        ),
+        const SizedBox(height: 24),
+
+        // SSL & Security Options
+        Text('SSL & Security', style: Theme.of(context).textTheme.titleMedium),
+        const SizedBox(height: 8),
+        Card(
+          child: Column(
+            children: [
+              SwitchListTile(
+                title: const Text('Force SSL'),
+                subtitle: const Text('Redirect HTTP to HTTPS'),
+                value: _forceSSL,
+                onChanged: (v) => setState(() => _forceSSL = v),
+              ),
+              const Divider(height: 1),
+              SwitchListTile(
+                title: const Text('HTTP/2 Support'),
+                value: _http2Support,
+                onChanged: (v) => setState(() => _http2Support = v),
+              ),
+              const Divider(height: 1),
+              SwitchListTile(
+                title: const Text('Block Common Exploits'),
+                value: _blockExploits,
+                onChanged: (v) => setState(() => _blockExploits = v),
+              ),
+            ],
+          ),
+        ),
+        const SizedBox(height: 24),
+
+        // Advanced Options
+        Text('Advanced', style: Theme.of(context).textTheme.titleMedium),
+        const SizedBox(height: 8),
+        Card(
+          child: Column(
+            children: [
+              SwitchListTile(
+                title: const Text('WebSocket Support'),
+                value: _websocketSupport,
+                onChanged: (v) => setState(() => _websocketSupport = v),
+              ),
+              const Divider(height: 1),
+              SwitchListTile(
+                title: const Text('Cache Assets'),
+                value: _cacheAssets,
+                onChanged: (v) => setState(() => _cacheAssets = v),
+              ),
+            ],
+          ),
+        ),
+      ],
+    );
+  }
+}

lib/features/control_room/presentation/pages/control_room_page.dart

@@ -2,6 +2,7 @@ import 'package:flutter/material.dart' hide Stack;
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
 import 'package:tatlock_ui/features/control_room/containers/presentation/pages/containers_list_page.dart';
+import 'package:tatlock_ui/features/control_room/npm/presentation/pages/proxy_hosts_page.dart';
 import 'package:tatlock_ui/features/control_room/router.dart';
 import 'package:tatlock_ui/features/control_room/stacks/data/repositories/stack_repository_impl.dart';
 import 'package:tatlock_ui/features/control_room/stacks/domain/entities/stack.dart';
@@ -71,6 +72,8 @@ class _SectionContent extends ConsumerWidget {
     switch (nav) {
       case ControlRoomNav.containers:
         return const _ContainersSection();
+      case ControlRoomNav.proxyHosts:
+        return const ProxyHostsPage();
       default:
         return _PlaceholderSection(nav: nav);
     }

lib/features/control_room/router.dart

@@ -16,10 +16,6 @@ abstract class ControlRoomRoutes {
   static const redirections = '/control-room/redirections';
   static const streams = '/control-room/streams';
   static const certificates = '/control-room/certificates';
-  // Authentik
-  static const users = '/control-room/users';
-  static const groups = '/control-room/groups';
-  static const applications = '/control-room/applications';
 }
 
 /// Control Room navigation items with section grouping.
@@ -33,11 +29,7 @@ enum ControlRoomNav {
   proxyHosts('proxy-hosts', 'Proxy Hosts', Icons.public, 'NPM'),
   redirections('redirections', 'Redirections', Icons.alt_route, 'NPM'),
   streams('streams', 'Streams', Icons.stream, 'NPM'),
-  certificates('certificates', 'SSL Certificates', Icons.verified_user, 'NPM'),
+  certificates('certificates', 'SSL Certificates', Icons.verified_user, 'NPM');
-  // Authentik section
-  users('users', 'Users', Icons.people, 'Authentik'),
-  groups('groups', 'Groups', Icons.group_work, 'Authentik'),
-  applications('applications', 'Applications', Icons.apps, 'Authentik');
 
   const ControlRoomNav(this.id, this.label, this.icon, this.section);
 

lib/features/control_room/stacks/data/datasources/stacks_datasource.dart

@@ -125,7 +125,7 @@ class StacksDatasource {
 
 /// Provides the stacks datasource.
 @riverpod
-StacksDatasource stacksDatasource(StacksDatasourceRef ref) {
+StacksDatasource stacksDatasource(Ref ref) {
   final dio = ref.watch(coreApiClientProvider);
   final containersDatasource = ref.watch(containersDatasourceProvider);
   return StacksDatasource(dio, containersDatasource);

lib/features/control_room/stacks/data/models/stack_model.dart

@@ -6,7 +6,7 @@ part 'stack_model.g.dart';
 
 /// Stack data model for API serialization.
 @freezed
-class StackModel with _$StackModel {
+sealed class StackModel with _$StackModel {
   const factory StackModel({
     required String id,
     required String name,

lib/features/control_room/stacks/data/repositories/stack_repository_impl.dart

@@ -75,7 +75,7 @@ class StackRepositoryImpl implements StackRepository {
 
 /// Provides the stack repository.
 @riverpod
-StackRepository stackRepository(StackRepositoryRef ref) {
+StackRepository stackRepository(Ref ref) {
   final datasource = ref.watch(stacksDatasourceProvider);
   return StackRepositoryImpl(datasource);
 }

lib/features/control_room/stacks/domain/entities/stack.dart

@@ -4,7 +4,7 @@ part 'stack.freezed.dart';
 
 /// Container orchestration stack (Docker Compose stack).
 @freezed
-class Stack with _$Stack {
+sealed class Stack with _$Stack {
   const factory Stack({
     /// Unique stack identifier.
     required String id,

lib/features/control_room/stacks/presentation/providers/stacks_provider.dart

@@ -6,14 +6,14 @@ part 'stacks_provider.g.dart';
 
 /// Provides the list of all stacks.
 @riverpod
-Future<List<Stack>> stacks(StacksRef ref) async {
+Future<List<Stack>> stacks(Ref ref) async {
   final repository = ref.watch(stackRepositoryProvider);
   return repository.getStacks();
 }
 
 /// Provides a single stack by ID.
 @riverpod
-Future<Stack> stack(StackRef ref, String id) async {
+Future<Stack> stack(Ref ref, String id) async {
   final repository = ref.watch(stackRepositoryProvider);
   return repository.getStack(id);
 }
@@ -35,14 +35,14 @@ class SelectedStack extends _$SelectedStack {
 
 /// Provides the YAML content for a stack.
 @riverpod
-Future<String> stackYaml(StackYamlRef ref, String stackId) async {
+Future<String> stackYaml(Ref ref, String stackId) async {
   final repository = ref.watch(stackRepositoryProvider);
   return repository.getStackYaml(stackId);
 }
 
 /// Provides the environment variables for a stack.
 @riverpod
-Future<Map<String, String>> stackEnvVars(StackEnvVarsRef ref, String stackId) async {
+Future<Map<String, String>> stackEnvVars(Ref ref, String stackId) async {
   final repository = ref.watch(stackRepositoryProvider);
   return repository.getStackEnvVars(stackId);
 }

lib/features/security/groups/groups_list_page.dart

@@ -0,0 +1,188 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:tatlock_ui/core/api/api_client.dart';
+import 'package:tatlock_ui/shared/components/data_grid/adapters/core_api_source.dart';
+import 'package:tatlock_ui/shared/components/data_grid/data_grid_exports.dart';
+
+/// Simple group data class for display.
+class GroupData {
+  GroupData({
+    required this.id,
+    required this.name,
+    required this.isSuperuser,
+    required this.memberCount,
+    this.parentName,
+  });
+
+  factory GroupData.fromJson(Map<String, dynamic> json) => GroupData(
+        id: json['id'] as String,
+        name: json['name'] as String,
+        isSuperuser: json['is_superuser'] as bool? ?? false,
+        memberCount: json['member_count'] as int? ?? 0,
+        parentName: json['parent_name'] as String?,
+      );
+
+  final String id;
+  final String name;
+  final bool isSuperuser;
+  final int memberCount;
+  final String? parentName;
+}
+
+/// Groups list page using the shared DataGrid component.
+class GroupsListPage extends ConsumerStatefulWidget {
+  const GroupsListPage({super.key});
+
+  @override
+  ConsumerState<GroupsListPage> createState() => _GroupsListPageState();
+}
+
+class _GroupsListPageState extends ConsumerState<GroupsListPage> {
+  late final StateNotifierProvider<DataGridController<GroupData>,
+      DataGridState<GroupData>> _gridProvider;
+  bool _isSyncing = false;
+
+  @override
+  void initState() {
+    super.initState();
+    // Create provider in initState to ensure stable reference
+    final dio = ref.read(coreApiClientProvider);
+    final source = CoreApiDataSource<GroupData>(
+      dio: dio,
+      endpoint: '/auth/groups',
+      fromJson: GroupData.fromJson,
+    );
+
+    _gridProvider = dataGridProvider<GroupData>(
+      source: source,
+      config: _buildConfig(),
+      idSelector: (g) => g.id,
+    );
+  }
+
+  Future<void> _syncFromAuthentik() async {
+    if (_isSyncing) return;
+    setState(() => _isSyncing = true);
+
+    try {
+      final dio = ref.read(coreApiClientProvider);
+      await dio.post<void>('/auth/groups/sync-from-authentik');
+
+      if (!mounted) return;
+      ref.read(_gridProvider.notifier).refresh();
+
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: const Text('Groups synced from Authentik'),
+          behavior: SnackBarBehavior.floating,
+          duration: const Duration(seconds: 2),
+        ),
+      );
+    } catch (e) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text('Sync failed: $e'),
+          behavior: SnackBarBehavior.floating,
+          duration: const Duration(seconds: 4),
+        ),
+      );
+    } finally {
+      if (mounted) setState(() => _isSyncing = false);
+    }
+  }
+
+  DataGridConfig<GroupData> _buildConfig() {
+    return DataGridConfig<GroupData>(
+      columns: [
+        DataGridColumn<GroupData>(
+          header: 'Name',
+          valueBuilder: (g) => g.name,
+          sortable: true,
+          searchable: true,
+          width: const DataGridColumnWidth.flex(2),
+        ),
+        DataGridColumn<GroupData>(
+          header: 'Members',
+          valueBuilder: (g) => g.memberCount.toString(),
+          width: const DataGridColumnWidth.fixed(100),
+          alignment: DataGridColumnAlignment.end,
+        ),
+        DataGridColumn<GroupData>(
+          header: 'Type',
+          valueBuilder: (g) => g.isSuperuser ? 'Superuser' : 'Standard',
+          cellBuilder: (context, g) => _GroupTypeBadge(isSuperuser: g.isSuperuser),
+          width: const DataGridColumnWidth.fixed(120),
+        ),
+        DataGridColumn<GroupData>(
+          header: 'Parent',
+          valueBuilder: (g) => g.parentName ?? '-',
+          width: const DataGridColumnWidth.flex(1),
+        ),
+      ],
+      enableSearch: true,
+      searchHint: 'Search groups...',
+      showHeader: true,
+      showFooter: true,
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return DataGrid<GroupData>(
+      provider: _gridProvider,
+      config: _buildConfig(),
+      idSelector: (g) => g.id,
+      toolbarActions: [
+        IconButton(
+          icon: const Icon(Icons.refresh),
+          tooltip: 'Refresh',
+          onPressed: () => ref.read(_gridProvider.notifier).refresh(),
+        ),
+        const SizedBox(width: 8),
+        FilledButton.icon(
+          onPressed: _isSyncing ? null : _syncFromAuthentik,
+          icon: _isSyncing
+              ? const SizedBox(
+                  width: 16,
+                  height: 16,
+                  child: CircularProgressIndicator(strokeWidth: 2),
+                )
+              : const Icon(Icons.sync),
+          label: const Text('Sync from Authentik'),
+        ),
+      ],
+    );
+  }
+}
+
+class _GroupTypeBadge extends StatelessWidget {
+  const _GroupTypeBadge({required this.isSuperuser});
+
+  final bool isSuperuser;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
+      decoration: BoxDecoration(
+        color: isSuperuser
+            ? colorScheme.primaryContainer
+            : colorScheme.surfaceContainerHighest,
+        borderRadius: BorderRadius.circular(4),
+      ),
+      child: Text(
+        isSuperuser ? 'Superuser' : 'Standard',
+        style: TextStyle(
+          fontSize: 12,
+          fontWeight: FontWeight.w500,
+          color: isSuperuser
+              ? colorScheme.onPrimaryContainer
+              : colorScheme.onSurfaceVariant,
+        ),
+      ),
+    );
+  }
+}

lib/features/security/presentation/pages/security_page.dart

@@ -0,0 +1,113 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:go_router/go_router.dart';
+import 'package:tatlock_ui/features/security/router.dart';
+import 'package:tatlock_ui/features/security/users/users_list_page.dart';
+import 'package:tatlock_ui/features/security/groups/groups_list_page.dart';
+import 'package:tatlock_ui/shared/layouts/widgets/nav_panel.dart';
+
+/// Main Security room page with nav panel and section content.
+class SecurityPage extends ConsumerWidget {
+  const SecurityPage({
+    super.key,
+    this.nav = SecurityNav.users,
+  });
+
+  /// The current nav item to display.
+  final SecurityNav nav;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Scaffold(
+      body: Row(
+        children: [
+          // Nav Panel - section navigation with grouping
+          NavPanel(
+            title: 'Sections',
+            icon: Icons.security_outlined,
+            items: SecurityNav.values.map((n) => n.toNavItem()).toList(),
+            selectedId: nav.id,
+            onItemSelected: (id) {
+              final newNav = SecurityNav.values.firstWhere(
+                (n) => n.id == id,
+              );
+              // Navigate to section URL
+              context.go(pathForSecurityNav(newNav));
+            },
+          ),
+          // Divider
+          VerticalDivider(
+            width: 1,
+            thickness: 1,
+            color: colorScheme.outlineVariant,
+          ),
+          // Section content
+          Expanded(
+            child: _SectionContent(nav: nav),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+/// Renders content for the selected nav item.
+class _SectionContent extends StatelessWidget {
+  const _SectionContent({required this.nav});
+
+  final SecurityNav nav;
+
+  @override
+  Widget build(BuildContext context) {
+    switch (nav) {
+      case SecurityNav.users:
+        return const UsersListPage();
+      case SecurityNav.groups:
+        return const GroupsListPage();
+      default:
+        return _PlaceholderSection(nav: nav);
+    }
+  }
+}
+
+/// Placeholder for nav items not yet implemented.
+class _PlaceholderSection extends StatelessWidget {
+  const _PlaceholderSection({required this.nav});
+
+  final SecurityNav nav;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final textTheme = Theme.of(context).textTheme;
+
+    return Center(
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          Icon(
+            nav.icon,
+            size: 64,
+            color: colorScheme.outline,
+          ),
+          const SizedBox(height: 16),
+          Text(
+            nav.label,
+            style: textTheme.headlineSmall?.copyWith(
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+          const SizedBox(height: 8),
+          Text(
+            '${nav.section} • Coming soon',
+            style: textTheme.bodyMedium?.copyWith(
+              color: colorScheme.outline,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}

lib/features/security/router.dart

@@ -0,0 +1,74 @@
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+import 'package:tatlock_ui/features/security/presentation/pages/security_page.dart';
+import 'package:tatlock_ui/shared/layouts/widgets/nav_panel.dart';
+
+/// Route paths for Security room.
+abstract class SecurityRoutes {
+  static const base = '/security';
+  // User Management (Authentik)
+  static const users = '/security/users';
+  static const groups = '/security/groups';
+  // Monitoring (future)
+  static const cveMonitor = '/security/cve-monitor';
+  static const networkMonitor = '/security/network-monitor';
+  static const dnsAdblock = '/security/dns-adblock';
+}
+
+/// Security room navigation items with section grouping.
+enum SecurityNav {
+  // User Management section (moved from Control Room)
+  users('users', 'Users', Icons.people, 'User Management'),
+  groups('groups', 'Groups', Icons.group_work, 'User Management'),
+  // Monitoring section (placeholders for future)
+  cveMonitor('cve-monitor', 'CVE Monitor', Icons.security, 'Monitoring'),
+  networkMonitor('network-monitor', 'Network Monitor', Icons.router, 'Monitoring'),
+  dnsAdblock('dns-adblock', 'DNS / Adblock', Icons.dns, 'Monitoring');
+
+  const SecurityNav(this.id, this.label, this.icon, this.section);
+
+  final String id;
+  final String label;
+  final IconData icon;
+  final String section;
+
+  NavItem toNavItem() => NavItem(
+        id: id,
+        label: label,
+        icon: icon,
+        section: section,
+      );
+
+  /// Get route path for this nav item.
+  String get path => '/security/$id';
+}
+
+/// Get route path for a nav item.
+String pathForSecurityNav(SecurityNav nav) => nav.path;
+
+/// Security room routes for go_router.
+List<RouteBase> securityRoutes() {
+  return [
+    // Redirect /security to /security/users
+    GoRoute(
+      path: SecurityRoutes.base,
+      name: 'security',
+      redirect: (context, state) => SecurityRoutes.users,
+    ),
+    // Generate routes for all nav items
+    for (final nav in SecurityNav.values)
+      GoRoute(
+        path: nav.path,
+        name: 'security${_capitalize(nav.id.replaceAll('-', '_'))}',
+        builder: (context, state) => SecurityPage(nav: nav),
+      ),
+  ];
+}
+
+String _capitalize(String s) {
+  if (s.isEmpty) return s;
+  return s
+      .split('_')
+      .map((part) => part[0].toUpperCase() + part.substring(1))
+      .join('');
+}

lib/features/security/users/users_list_page.dart

@@ -0,0 +1,306 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:tatlock_ui/core/api/api_client.dart';
+import 'package:tatlock_ui/shared/components/data_grid/adapters/core_api_source.dart';
+import 'package:tatlock_ui/shared/components/data_grid/data_grid_exports.dart';
+
+/// Simple user data class for display.
+class UserData {
+  UserData({
+    required this.id,
+    required this.email,
+    required this.name,
+    this.avatarUrl,
+    required this.createdAt,
+    this.lastLogin,
+    this.roles = const [],
+  });
+
+  factory UserData.fromJson(Map<String, dynamic> json) => UserData(
+        id: json['id'] as String,
+        email: json['email'] as String,
+        name: json['name'] as String,
+        avatarUrl: json['avatar_url'] as String?,
+        createdAt: DateTime.parse(json['created_at'] as String),
+        lastLogin: json['last_login'] != null
+            ? DateTime.parse(json['last_login'] as String)
+            : null,
+        roles: (json['roles'] as List<dynamic>?)?.cast<String>() ?? [],
+      );
+
+  final String id;
+  final String email;
+  final String name;
+  final String? avatarUrl;
+  final DateTime createdAt;
+  final DateTime? lastLogin;
+  final List<String> roles;
+
+  bool get isAdmin => roles.any((r) => r.endsWith(':admin'));
+
+  String get initials {
+    final parts = name.split(' ');
+    if (parts.length >= 2) {
+      return '${parts.first[0]}${parts.last[0]}'.toUpperCase();
+    }
+    return name.substring(0, name.length.clamp(0, 2)).toUpperCase();
+  }
+
+  String get lastLoginFormatted {
+    if (lastLogin == null) return 'Never';
+    final diff = DateTime.now().difference(lastLogin!);
+    if (diff.inDays > 30) {
+      return '${lastLogin!.day}/${lastLogin!.month}/${lastLogin!.year}';
+    }
+    if (diff.inDays > 0) return '${diff.inDays}d ago';
+    if (diff.inHours > 0) return '${diff.inHours}h ago';
+    if (diff.inMinutes > 0) return '${diff.inMinutes}m ago';
+    return 'Just now';
+  }
+}
+
+/// Users list page using the shared DataGrid component.
+class UsersListPage extends ConsumerStatefulWidget {
+  const UsersListPage({super.key});
+
+  @override
+  ConsumerState<UsersListPage> createState() => _UsersListPageState();
+}
+
+class _UsersListPageState extends ConsumerState<UsersListPage> {
+  late final StateNotifierProvider<DataGridController<UserData>,
+      DataGridState<UserData>> _gridProvider;
+  bool _isSyncing = false;
+
+  @override
+  void initState() {
+    super.initState();
+    final dio = ref.read(coreApiClientProvider);
+    final source = CoreApiDataSource<UserData>(
+      dio: dio,
+      endpoint: '/auth/users',
+      fromJson: UserData.fromJson,
+    );
+
+    _gridProvider = dataGridProvider<UserData>(
+      source: source,
+      config: _buildConfig(),
+      idSelector: (u) => u.id,
+    );
+  }
+
+  Future<void> _syncFromAuthentik() async {
+    if (_isSyncing) return;
+    setState(() => _isSyncing = true);
+
+    try {
+      final dio = ref.read(coreApiClientProvider);
+      await dio.post<void>('/auth/users/sync-from-authentik');
+
+      if (!mounted) return;
+      ref.read(_gridProvider.notifier).refresh();
+
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: const Text('Users synced from Authentik'),
+          behavior: SnackBarBehavior.floating,
+          duration: const Duration(seconds: 2),
+        ),
+      );
+    } catch (e) {
+      if (!mounted) return;
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(
+          content: Text('Sync failed: $e'),
+          behavior: SnackBarBehavior.floating,
+          duration: const Duration(seconds: 4),
+        ),
+      );
+    } finally {
+      if (mounted) setState(() => _isSyncing = false);
+    }
+  }
+
+  DataGridConfig<UserData> _buildConfig() {
+    return DataGridConfig<UserData>(
+      columns: [
+        DataGridColumn<UserData>(
+          header: 'User',
+          valueBuilder: (u) => u.name,
+          sortable: true,
+          searchable: true,
+          width: const DataGridColumnWidth.flex(2),
+          cellBuilder: (context, u) => _UserCell(user: u),
+        ),
+        DataGridColumn<UserData>(
+          header: 'Roles',
+          valueBuilder: (u) => u.roles.join(', '),
+          width: const DataGridColumnWidth.flex(1),
+          cellBuilder: (context, u) => _RolesCell(roles: u.roles),
+        ),
+        DataGridColumn<UserData>(
+          header: 'Last Login',
+          valueBuilder: (u) => u.lastLoginFormatted,
+          width: const DataGridColumnWidth.fixed(120),
+          alignment: DataGridColumnAlignment.end,
+        ),
+      ],
+      enableSearch: true,
+      searchHint: 'Search users...',
+      showHeader: true,
+      showFooter: true,
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return DataGrid<UserData>(
+      provider: _gridProvider,
+      config: _buildConfig(),
+      idSelector: (u) => u.id,
+      toolbarActions: [
+        IconButton(
+          icon: const Icon(Icons.refresh),
+          tooltip: 'Refresh',
+          onPressed: () => ref.read(_gridProvider.notifier).refresh(),
+        ),
+        const SizedBox(width: 8),
+        FilledButton.icon(
+          onPressed: _isSyncing ? null : _syncFromAuthentik,
+          icon: _isSyncing
+              ? const SizedBox(
+                  width: 16,
+                  height: 16,
+                  child: CircularProgressIndicator(strokeWidth: 2),
+                )
+              : const Icon(Icons.sync),
+          label: const Text('Sync from Authentik'),
+        ),
+      ],
+    );
+  }
+}
+
+class _UserCell extends StatelessWidget {
+  const _UserCell({required this.user});
+
+  final UserData user;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Row(
+      children: [
+        CircleAvatar(
+          radius: 16,
+          backgroundColor: colorScheme.primaryContainer,
+          backgroundImage:
+              user.avatarUrl != null ? NetworkImage(user.avatarUrl!) : null,
+          child: user.avatarUrl == null
+              ? Text(
+                  user.initials,
+                  style: TextStyle(
+                    fontSize: 12,
+                    color: colorScheme.onPrimaryContainer,
+                    fontWeight: FontWeight.w500,
+                  ),
+                )
+              : null,
+        ),
+        const SizedBox(width: 12),
+        Expanded(
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              Row(
+                children: [
+                  Flexible(
+                    child: Text(
+                      user.name,
+                      style: const TextStyle(fontWeight: FontWeight.w500),
+                      overflow: TextOverflow.ellipsis,
+                    ),
+                  ),
+                  if (user.isAdmin) ...[
+                    const SizedBox(width: 8),
+                    Container(
+                      padding: const EdgeInsets.symmetric(
+                        horizontal: 6,
+                        vertical: 2,
+                      ),
+                      decoration: BoxDecoration(
+                        color: colorScheme.primaryContainer,
+                        borderRadius: BorderRadius.circular(4),
+                      ),
+                      child: Text(
+                        'Admin',
+                        style: TextStyle(
+                          fontSize: 10,
+                          fontWeight: FontWeight.w500,
+                          color: colorScheme.onPrimaryContainer,
+                        ),
+                      ),
+                    ),
+                  ],
+                ],
+              ),
+              Text(
+                user.email,
+                style: TextStyle(
+                  fontSize: 12,
+                  color: colorScheme.onSurfaceVariant,
+                ),
+                overflow: TextOverflow.ellipsis,
+              ),
+            ],
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+class _RolesCell extends StatelessWidget {
+  const _RolesCell({required this.roles});
+
+  final List<String> roles;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    if (roles.isEmpty) {
+      return Text(
+        'No roles',
+        style: TextStyle(
+          fontSize: 12,
+          color: colorScheme.outline,
+          fontStyle: FontStyle.italic,
+        ),
+      );
+    }
+
+    return Wrap(
+      spacing: 4,
+      runSpacing: 4,
+      children: roles.take(3).map((role) {
+        return Container(
+          padding: const EdgeInsets.symmetric(horizontal: 6, vertical: 2),
+          decoration: BoxDecoration(
+            color: colorScheme.surfaceContainerHighest,
+            borderRadius: BorderRadius.circular(4),
+          ),
+          child: Text(
+            role.split(':').last,
+            style: TextStyle(
+              fontSize: 10,
+              color: colorScheme.onSurfaceVariant,
+            ),
+          ),
+        );
+      }).toList(),
+    );
+  }
+}

lib/routing/app_router.dart

@@ -3,6 +3,7 @@ import 'package:go_router/go_router.dart';
 import 'package:riverpod_annotation/riverpod_annotation.dart';
 import 'package:tatlock_ui/features/control_room/router.dart';
 import 'package:tatlock_ui/features/front_hall/presentation/pages/front_hall_page.dart';
+import 'package:tatlock_ui/features/security/router.dart';
 import 'package:tatlock_ui/shared/layouts/app_scaffold.dart';
 
 part 'app_router.g.dart';
@@ -16,7 +17,7 @@ abstract class AppRoutes {
 
 /// Provides the GoRouter instance.
 @riverpod
-GoRouter appRouter(AppRouterRef ref) {
+GoRouter appRouter(Ref ref) {
   return GoRouter(
     initialLocation: AppRoutes.frontHall,
     debugLogDiagnostics: true,
@@ -30,6 +31,7 @@ GoRouter appRouter(AppRouterRef ref) {
             builder: (context, state) => const FrontHallPage(),
           ),
           ...controlRoomRoutes(),
+          ...securityRoutes(),
           GoRoute(
             path: AppRoutes.parlor,
             name: 'parlor',

lib/shared/components/data_grid/adapters/core_api_source.dart

@@ -88,28 +88,37 @@ class CoreApiDataSource<T> extends DataGridSource<T> {
       queryParams[limitParam] = limit;
     }
 
-    final response = await dio.get<Map<String, dynamic>>(
+    final response = await dio.get<dynamic>(
       endpoint,
       queryParameters: queryParams,
     );
 
-    final data = response.data!;
+    final responseData = response.data!;
 
     // Handle both paginated and wrapped responses
     List<dynamic> itemsJson;
     int totalCount;
 
-    if (data.containsKey(itemsKey)) {
+    if (responseData is List) {
-      // Paginated response: { items: [...], total: N }
+      // Direct array response: [...]
-      itemsJson = data[itemsKey] as List<dynamic>;
+      itemsJson = responseData;
-      totalCount = data[totalCountKey] as int? ?? itemsJson.length;
+      totalCount = itemsJson.length;
+    } else if (responseData is Map<String, dynamic>) {
+      final data = responseData;
+      if (data.containsKey(itemsKey)) {
+        // Paginated response: { items: [...], total: N }
+        itemsJson = data[itemsKey] as List<dynamic>;
+        totalCount = data[totalCountKey] as int? ?? itemsJson.length;
+      } else {
+        // Try common wrapper patterns: { data: [...] } or { results: [...] }
+        itemsJson = (data['data'] ?? data['results'] ?? []) as List<dynamic>;
+        totalCount = data['count'] as int? ??
+            data['total'] as int? ??
+            data['totalCount'] as int? ??
+            itemsJson.length;
+      }
     } else {
-      // Try common wrapper patterns: { data: [...] } or { results: [...] }
+      throw FormatException('Unexpected response type: ${responseData.runtimeType}');
-      itemsJson = (data['data'] ?? data['results'] ?? []) as List<dynamic>;
-      totalCount = data['count'] as int? ??
-          data['total'] as int? ??
-          data['totalCount'] as int? ??
-          itemsJson.length;
     }
 
     final items = itemsJson

lib/shared/components/data_grid/data_grid.dart

@@ -1,9 +1,9 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_riverpod/legacy.dart';
 
 import 'data_grid_config.dart';
 import 'data_grid_provider.dart';
-import 'data_grid_source.dart';
 import 'data_grid_state.dart';
 import 'widgets/data_grid_bulk_actions.dart';
 import 'widgets/data_grid_empty_state.dart';

lib/shared/components/data_grid/data_grid_exports.dart

@@ -75,6 +75,9 @@
 /// ```
 library;
 
+export 'package:flutter_riverpod/legacy.dart'
+    show StateNotifierProvider, StateNotifier;
+
 export 'data_grid.dart';
 export 'data_grid_action.dart';
 export 'data_grid_column.dart';

lib/shared/components/data_grid/data_grid_provider.dart

@@ -1,7 +1,7 @@
 import 'dart:async';
 
 import 'package:flutter/foundation.dart';
-import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_riverpod/legacy.dart';
 
 import 'data_grid_config.dart';
 import 'data_grid_source.dart';

lib/shared/components/data_grid/data_grid_state.dart

@@ -4,7 +4,7 @@ part 'data_grid_state.freezed.dart';
 
 /// State for a DataGrid instance.
 @freezed
-class DataGridState<T> with _$DataGridState<T> {
+sealed class DataGridState<T> with _$DataGridState<T> {
   const factory DataGridState({
     /// Current items being displayed.
     @Default([]) List<T> items,

lib/shared/layouts/app_scaffold.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:go_router/go_router.dart';
 import 'package:tatlock_ui/features/control_room/router.dart';
+import 'package:tatlock_ui/features/security/router.dart';
 import 'package:tatlock_ui/routing/app_router.dart';
 import 'package:tatlock_ui/shared/layouts/widgets/top_header_bar.dart';
 
@@ -54,7 +55,8 @@ class AppScaffold extends StatelessWidget {
     final location = GoRouterState.of(context).matchedLocation;
 
     if (location.startsWith(ControlRoomRoutes.base)) return 1;
-    if (location.startsWith(AppRoutes.parlor)) return 2;
+    if (location.startsWith(SecurityRoutes.base)) return 2;
+    if (location.startsWith(AppRoutes.parlor)) return 3;
     // Settings is no longer in main nav (accessed via Profile dropdown)
     return 0; // Front Hall
   }
@@ -63,7 +65,8 @@ class AppScaffold extends StatelessWidget {
     final route = switch (index) {
       0 => AppRoutes.frontHall,
       1 => ControlRoomRoutes.containers,
-      2 => AppRoutes.parlor,
+      2 => SecurityRoutes.users,
+      3 => AppRoutes.parlor,
       _ => AppRoutes.frontHall,
     };
     context.go(route);

lib/shared/layouts/widgets/profile_dropdown.dart

@@ -12,7 +12,7 @@ class ProfileDropdown extends ConsumerWidget {
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    final authState = ref.watch(authNotifierProvider);
+    final authState = ref.watch(authProvider);
     final colorScheme = Theme.of(context).colorScheme;
 
     return authState.when(
@@ -94,7 +94,7 @@ class ProfileDropdown extends ConsumerWidget {
             case 'settings':
               context.go(AppRoutes.settings);
             case 'logout':
-              ref.read(authNotifierProvider.notifier).signOut();
+              ref.read(authProvider.notifier).signOut();
           }
         },
       ),
@@ -106,7 +106,7 @@ class ProfileDropdown extends ConsumerWidget {
           child: CircularProgressIndicator(strokeWidth: 2),
         ),
       ),
-      error: (_, __) => CircleAvatar(
+      error: (err, stack) => CircleAvatar(
         radius: 18,
         backgroundColor: colorScheme.errorContainer,
         child: Icon(

lib/shared/layouts/widgets/top_header_bar.dart

@@ -34,6 +34,11 @@ class TopHeaderBar extends StatelessWidget {
       selectedIcon: Icons.dns,
       label: 'Control Room',
     ),
+    _RoomDestination(
+      icon: Icons.security_outlined,
+      selectedIcon: Icons.security,
+      label: 'Security',
+    ),
     _RoomDestination(
       icon: Icons.lightbulb_outline,
       selectedIcon: Icons.lightbulb,
@@ -76,7 +81,7 @@ class TopHeaderBar extends StatelessWidget {
               'assets/icons/logo.png',
               height: _logoSize,
               width: _logoSize,
-              errorBuilder: (_, __, ___) => Icon(
+              errorBuilder: (context, error, stack) => Icon(
                 Icons.layers,
                 size: 32,
                 color: colorScheme.primary,

lib/shared/widgets/entity_form_dialog.dart

@@ -0,0 +1,288 @@
+import 'package:flutter/material.dart';
+import 'package:tatlock_ui/shared/widgets/entity_page.dart';
+
+/// A reusable dialog wrapper for entity create/edit forms.
+///
+/// Provides consistent styling across all Control Room sections:
+/// - Constrained max width/height
+/// - AppBar with title and close button
+/// - Scrollable content area
+///
+/// Usage:
+/// ```dart
+/// showEntityFormDialog(
+///   context: context,
+///   title: 'New Proxy Host',
+///   child: ProxyHostForm(
+///     onCancel: () => Navigator.of(context).pop(),
+///     onSaved: () {
+///       Navigator.of(context).pop();
+///       ref.invalidate(domainsProvider);
+///     },
+///   ),
+/// );
+/// ```
+void showEntityFormDialog({
+  required BuildContext context,
+  required String title,
+  required Widget child,
+  double maxWidth = 600,
+  double maxHeight = 700,
+}) {
+  showDialog(
+    context: context,
+    builder: (context) => EntityFormDialog(
+      title: title,
+      maxWidth: maxWidth,
+      maxHeight: maxHeight,
+      child: child,
+    ),
+  );
+}
+
+/// Dialog widget for entity forms.
+class EntityFormDialog extends StatelessWidget {
+  const EntityFormDialog({
+    super.key,
+    required this.title,
+    required this.child,
+    this.maxWidth = 600,
+    this.maxHeight = 700,
+  });
+
+  final String title;
+  final Widget child;
+  final double maxWidth;
+  final double maxHeight;
+
+  @override
+  Widget build(BuildContext context) {
+    return Dialog(
+      child: ConstrainedBox(
+        constraints: BoxConstraints(
+          maxWidth: maxWidth,
+          maxHeight: maxHeight,
+        ),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            AppBar(
+              title: Text(title),
+              automaticallyImplyLeading: false,
+              actions: [
+                IconButton(
+                  icon: const Icon(Icons.close),
+                  onPressed: () => Navigator.of(context).pop(),
+                ),
+              ],
+            ),
+            Flexible(child: child),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+/// A standardized form wrapper with common patterns.
+///
+/// Handles:
+/// - Error display banner
+/// - Loading state on save button
+/// - Cancel/Save button row
+/// - Form key management
+/// - Create vs Edit mode awareness
+///
+/// Use [mode] to indicate whether this is a create or edit form.
+/// Child widgets can use [EntityFormScope.of(context)] to check the mode
+/// and disable fields that should only be editable during creation.
+class EntityForm extends StatelessWidget {
+  const EntityForm({
+    super.key,
+    required this.formKey,
+    required this.onCancel,
+    required this.onSave,
+    required this.isSaving,
+    required this.children,
+    this.mode = EntityPageMode.create,
+    this.error,
+    this.saveLabel,
+    this.cancelLabel = 'Cancel',
+  });
+
+  final GlobalKey<FormState> formKey;
+  final VoidCallback onCancel;
+  final VoidCallback onSave;
+  final bool isSaving;
+  final List<Widget> children;
+  final EntityPageMode mode;
+  final String? error;
+  final String? saveLabel;
+  final String cancelLabel;
+
+  bool get isCreating => mode == EntityPageMode.create;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final effectiveSaveLabel = saveLabel ?? (isCreating ? 'Create' : 'Save');
+
+    return EntityFormScope(
+      mode: mode,
+      child: Form(
+        key: formKey,
+        child: SingleChildScrollView(
+          padding: const EdgeInsets.all(24),
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              // Error banner
+              if (error != null)
+                Container(
+                  padding: const EdgeInsets.all(12),
+                  margin: const EdgeInsets.only(bottom: 16),
+                  decoration: BoxDecoration(
+                    color: colorScheme.errorContainer,
+                    borderRadius: BorderRadius.circular(8),
+                  ),
+                  child: Row(
+                    children: [
+                      Icon(Icons.error, color: colorScheme.onErrorContainer),
+                      const SizedBox(width: 8),
+                      Expanded(
+                        child: Text(
+                          error!,
+                          style: TextStyle(color: colorScheme.onErrorContainer),
+                        ),
+                      ),
+                    ],
+                  ),
+                ),
+
+              // Form fields
+              ...children,
+
+              const SizedBox(height: 32),
+
+              // Action buttons
+              Row(
+                mainAxisAlignment: MainAxisAlignment.end,
+                children: [
+                  OutlinedButton(
+                    onPressed: isSaving ? null : onCancel,
+                    child: Text(cancelLabel),
+                  ),
+                  const SizedBox(width: 12),
+                  FilledButton.icon(
+                    onPressed: isSaving ? null : onSave,
+                    icon: isSaving
+                        ? const SizedBox(
+                            width: 16,
+                            height: 16,
+                            child: CircularProgressIndicator(strokeWidth: 2),
+                          )
+                        : const Icon(Icons.save),
+                    label: Text(effectiveSaveLabel),
+                  ),
+                ],
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// InheritedWidget to provide form mode to descendants.
+///
+/// Allows form fields to check if they're in create or edit mode
+/// and adjust their behavior accordingly (e.g., disable create-only fields).
+class EntityFormScope extends InheritedWidget {
+  const EntityFormScope({
+    super.key,
+    required this.mode,
+    required super.child,
+  });
+
+  final EntityPageMode mode;
+
+  bool get isCreating => mode == EntityPageMode.create;
+  bool get isEditing => mode == EntityPageMode.edit;
+
+  static EntityFormScope? maybeOf(BuildContext context) {
+    return context.dependOnInheritedWidgetOfExactType<EntityFormScope>();
+  }
+
+  static EntityFormScope of(BuildContext context) {
+    final scope = maybeOf(context);
+    assert(scope != null, 'No EntityFormScope found in context');
+    return scope!;
+  }
+
+  @override
+  bool updateShouldNotify(EntityFormScope oldWidget) => mode != oldWidget.mode;
+}
+
+/// A form field wrapper that can be marked as create-only.
+///
+/// When [createOnly] is true, the field will be disabled in edit mode.
+/// Shows a lock icon and tooltip to indicate the field is immutable.
+///
+/// Usage:
+/// ```dart
+/// CreateOnlyField(
+///   createOnly: true,
+///   child: TextFormField(
+///     controller: _nameController,
+///     decoration: InputDecoration(labelText: 'Name'),
+///   ),
+/// )
+/// ```
+class CreateOnlyField extends StatelessWidget {
+  const CreateOnlyField({
+    super.key,
+    required this.child,
+    this.createOnly = true,
+    this.disabledHint = 'This field cannot be changed after creation',
+  });
+
+  final Widget child;
+  final bool createOnly;
+  final String disabledHint;
+
+  @override
+  Widget build(BuildContext context) {
+    final scope = EntityFormScope.maybeOf(context);
+    final isEditing = scope?.isEditing ?? false;
+    final shouldDisable = createOnly && isEditing;
+
+    if (!shouldDisable) {
+      return child;
+    }
+
+    return Tooltip(
+      message: disabledHint,
+      child: AbsorbPointer(
+        absorbing: true,
+        child: Opacity(
+          opacity: 0.6,
+          child: Stack(
+            children: [
+              child,
+              Positioned(
+                right: 8,
+                top: 8,
+                child: Icon(
+                  Icons.lock,
+                  size: 16,
+                  color: Theme.of(context).colorScheme.outline,
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

lib/shared/widgets/entity_page.dart

@@ -0,0 +1,272 @@
+import 'package:flutter/material.dart';
+
+/// Reusable scaffold for entity pages (create, view, edit).
+///
+/// Provides consistent layout across all Control Room entity pages:
+/// - AppBar with back button, title, and customizable actions
+/// - Loading, error, and content states
+/// - Consistent padding and styling
+///
+/// Usage:
+/// ```dart
+/// EntityPageScaffold(
+///   title: 'Proxy Host Details',
+///   onBack: () => Navigator.pop(context),
+///   actions: [
+///     IconButton(icon: Icon(Icons.edit), onPressed: onEdit),
+///   ],
+///   child: MyContent(),
+/// )
+/// ```
+class EntityPageScaffold extends StatelessWidget {
+  const EntityPageScaffold({
+    super.key,
+    required this.title,
+    required this.child,
+    this.onBack,
+    this.actions,
+    this.floatingActionButton,
+  });
+
+  final String title;
+  final Widget child;
+  final VoidCallback? onBack;
+  final List<Widget>? actions;
+  final Widget? floatingActionButton;
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(
+        leading: onBack != null
+            ? IconButton(
+                icon: const Icon(Icons.arrow_back),
+                onPressed: onBack,
+              )
+            : null,
+        title: Text(title),
+        actions: actions,
+      ),
+      body: child,
+      floatingActionButton: floatingActionButton,
+    );
+  }
+}
+
+/// Async content wrapper with loading, error, and data states.
+///
+/// Use with Riverpod AsyncValue for consistent loading/error handling.
+class EntityAsyncContent<T> extends StatelessWidget {
+  const EntityAsyncContent({
+    super.key,
+    required this.isLoading,
+    required this.error,
+    required this.data,
+    required this.onRetry,
+    required this.builder,
+  });
+
+  final bool isLoading;
+  final Object? error;
+  final T? data;
+  final VoidCallback onRetry;
+  final Widget Function(T data) builder;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    if (isLoading) {
+      return const Center(child: CircularProgressIndicator());
+    }
+
+    if (error != null) {
+      return Center(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Icon(Icons.error_outline, size: 48, color: colorScheme.error),
+            const SizedBox(height: 16),
+            const Text('Failed to load'),
+            const SizedBox(height: 8),
+            Text(
+              error.toString(),
+              style: TextStyle(color: colorScheme.outline),
+              textAlign: TextAlign.center,
+            ),
+            const SizedBox(height: 16),
+            FilledButton.icon(
+              onPressed: onRetry,
+              icon: const Icon(Icons.refresh),
+              label: const Text('Retry'),
+            ),
+          ],
+        ),
+      );
+    }
+
+    if (data != null) {
+      return builder(data as T);
+    }
+
+    return const SizedBox.shrink();
+  }
+}
+
+/// Section header for entity detail pages.
+///
+/// Consistent styling for grouping related fields.
+class EntitySection extends StatelessWidget {
+  const EntitySection({
+    super.key,
+    required this.title,
+    required this.icon,
+    required this.child,
+    this.trailing,
+  });
+
+  final String title;
+  final IconData icon;
+  final Widget child;
+  final Widget? trailing;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        Row(
+          children: [
+            Icon(icon, size: 20, color: colorScheme.primary),
+            const SizedBox(width: 8),
+            Expanded(
+              child: Text(
+                title,
+                style: Theme.of(context).textTheme.titleMedium?.copyWith(
+                      color: colorScheme.primary,
+                      fontWeight: FontWeight.w600,
+                    ),
+              ),
+            ),
+            if (trailing != null) trailing!,
+          ],
+        ),
+        const SizedBox(height: 8),
+        child,
+      ],
+    );
+  }
+}
+
+/// Row displaying a boolean setting with label and indicator.
+class EntitySettingRow extends StatelessWidget {
+  const EntitySettingRow({
+    super.key,
+    required this.label,
+    required this.value,
+    this.subtitle,
+  });
+
+  final String label;
+  final bool value;
+  final String? subtitle;
+
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      children: [
+        Expanded(
+          child: Column(
+            crossAxisAlignment: CrossAxisAlignment.start,
+            children: [
+              Text(label),
+              if (subtitle != null)
+                Text(
+                  subtitle!,
+                  style: TextStyle(
+                    fontSize: 12,
+                    color: Theme.of(context).colorScheme.outline,
+                  ),
+                ),
+            ],
+          ),
+        ),
+        Icon(
+          value ? Icons.check_circle : Icons.cancel,
+          color: value ? Colors.green : Colors.grey,
+          size: 20,
+        ),
+      ],
+    );
+  }
+}
+
+/// Row displaying a key-value pair.
+class EntityInfoRow extends StatelessWidget {
+  const EntityInfoRow({
+    super.key,
+    required this.label,
+    required this.value,
+    this.monospace = false,
+  });
+
+  final String label;
+  final String value;
+  final bool monospace;
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+
+    return Row(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      children: [
+        SizedBox(
+          width: 120,
+          child: Text(
+            label,
+            style: TextStyle(color: colorScheme.outline),
+          ),
+        ),
+        Expanded(
+          child: Text(
+            value,
+            style: monospace
+                ? const TextStyle(fontFamily: 'monospace')
+                : null,
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+/// Enum for entity page modes.
+enum EntityPageMode {
+  create,
+  view,
+  edit,
+}
+
+/// Mixin for pages that support view/edit mode toggle.
+///
+/// Provides standard mode management for entity detail pages.
+mixin EntityPageModeMixin<T extends StatefulWidget> on State<T> {
+  EntityPageMode _mode = EntityPageMode.view;
+
+  EntityPageMode get mode => _mode;
+  set mode(EntityPageMode value) => _mode = value;
+
+  bool get isViewing => _mode == EntityPageMode.view;
+  bool get isEditing => _mode == EntityPageMode.edit;
+  bool get isCreating => _mode == EntityPageMode.create;
+
+  void setMode(EntityPageMode newMode) {
+    setState(() => _mode = newMode);
+  }
+
+  void startEditing() => setMode(EntityPageMode.edit);
+  void stopEditing() => setMode(EntityPageMode.view);
+}

nginx.conf

@@ -0,0 +1,87 @@
+worker_processes auto;
+error_log /var/log/nginx/error.log warn;
+pid /var/run/nginx.pid;
+
+events {
+    worker_connections 1024;
+}
+
+http {
+    include /etc/nginx/mime.types;
+    default_type application/octet-stream;
+
+    log_format main '$remote_addr - $remote_user [$time_local] "$request" '
+                    '$status $body_bytes_sent "$http_referer" '
+                    '"$http_user_agent" "$http_x_forwarded_for"';
+
+    access_log /var/log/nginx/access.log main;
+
+    sendfile on;
+    tcp_nopush on;
+    tcp_nodelay on;
+    keepalive_timeout 65;
+    types_hash_max_size 2048;
+
+    # Gzip compression
+    gzip on;
+    gzip_vary on;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_min_length 1000;
+    gzip_types
+        text/plain
+        text/css
+        text/javascript
+        application/javascript
+        application/json
+        application/x-javascript
+        application/xml
+        application/xml+rss
+        image/svg+xml
+        font/woff
+        font/woff2;
+
+    server {
+        listen 80;
+        server_name _;
+        root /usr/share/nginx/html;
+        index index.html;
+
+        # Security headers
+        add_header X-Frame-Options "SAMEORIGIN" always;
+        add_header X-Content-Type-Options "nosniff" always;
+        add_header X-XSS-Protection "1; mode=block" always;
+
+        # SPA routing: all routes fall back to index.html
+        location / {
+            try_files $uri $uri/ /index.html;
+        }
+
+        # No cache for index.html (ensures updates are picked up)
+        location = /index.html {
+            add_header Cache-Control "no-cache, no-store, must-revalidate";
+            add_header Pragma "no-cache";
+            add_header Expires "0";
+        }
+
+        # Long cache for Flutter assets (content-hash naming ensures freshness)
+        location ~* \.(js|css|woff|woff2|ttf|eot|ico|png|jpg|jpeg|gif|svg|webp)$ {
+            expires 1y;
+            add_header Cache-Control "public, immutable";
+            access_log off;
+        }
+
+        # Cache manifest and version files briefly
+        location ~* \.(json|webmanifest)$ {
+            expires 1h;
+            add_header Cache-Control "public";
+        }
+
+        # Health check endpoint
+        location /health {
+            access_log off;
+            return 200 "OK";
+            add_header Content-Type text/plain;
+        }
+    }
+}

pubspec.yaml

@@ -16,7 +16,7 @@ publish_to: 'none' # Remove this line if you wish to publish to pub.dev
 # https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
 # In Windows, build-name is used as the major, minor, and patch parts
 # of the product and file versions while build-number is used as the build suffix.
-version: 0.3.0+1
+version: 0.3.2+1
 
 environment:
   sdk: ^3.10.4
@@ -32,20 +32,20 @@ dependencies:
     sdk: flutter
 
   # State Management
-  flutter_riverpod: ^2.6.1
+  flutter_riverpod: ^3.0.0
-  riverpod_annotation: ^2.6.1
+  riverpod_annotation: ^4.0.0
-  hooks_riverpod: ^2.6.1
+  hooks_riverpod: ^3.0.0
-  flutter_hooks: ^0.20.5
+  flutter_hooks: ^0.21.0
 
   # Code Generation Support
-  freezed_annotation: ^2.4.4
+  freezed_annotation: ^3.1.0
   json_annotation: ^4.9.0
 
   # Networking
   dio: ^5.7.0
 
   # Routing
-  go_router: ^14.6.2
+  go_router: ^17.0.1
 
   # Storage
   shared_preferences: ^2.3.3
@@ -54,7 +54,7 @@ dependencies:
   flex_color_scheme: ^8.1.0
   flutter_adaptive_scaffold: ^0.3.1
   flutter_markdown: ^0.7.4
-  fl_chart: ^0.69.2
+  fl_chart: ^1.1.1
 
   # Icons
   cupertino_icons: ^1.0.8
@@ -70,19 +70,19 @@ dev_dependencies:
     sdk: flutter
 
   # Linting
-  flutter_lints: ^5.0.0
+  flutter_lints: ^6.0.0
 
   # Code Generation
   build_runner: ^2.4.13
-  freezed: ^2.5.7
+  freezed: ^3.2.3
   json_serializable: ^6.8.0
-  riverpod_generator: ^2.6.3
+  riverpod_generator: ^4.0.0
 
   # Testing
   mocktail: ^1.0.4
 
   # Build tools
-  build: ^2.4.0
+  build: ^4.0.3
   yaml: ^3.1.0
 
 # For information on the generic Dart part of this file, see the

test/features/control_room/containers/data/models/container_model_test.dart

@@ -0,0 +1,458 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tatlock_ui/features/control_room/containers/data/models/container_model.dart';
+import 'package:tatlock_ui/features/control_room/containers/domain/entities/container.dart';
+
+void main() {
+  group('ContainerModel', () {
+    group('fromJson', () {
+      test('deserializes minimal container', () {
+        final json = {
+          'Id': 'abc123def456',
+          'Names': ['/my-container'],
+          'Image': 'nginx:latest',
+          'State': 'running',
+          'Status': 'Up 2 hours',
+        };
+
+        final model = ContainerModel.fromJson(json);
+
+        expect(model.id, equals('abc123def456'));
+        expect(model.names, equals(['/my-container']));
+        expect(model.image, equals('nginx:latest'));
+        expect(model.state, equals('running'));
+        expect(model.status, equals('Up 2 hours'));
+      });
+
+      test('deserializes full container with all fields', () {
+        final json = {
+          'Id': 'abc123def456789xyz',
+          'Names': ['/my-container', '/alias'],
+          'Image': 'nginx:latest',
+          'State': 'running',
+          'Status': 'Up 2 hours',
+          'Labels': {
+            'com.docker.compose.project': 'mystack',
+            'maintainer': 'test@example.com',
+          },
+          'Ports': [
+            {'PrivatePort': 80, 'PublicPort': 8080, 'Type': 'tcp'},
+          ],
+          'Mounts': [
+            {
+              'Type': 'bind',
+              'Source': '/host/path',
+              'Destination': '/container/path',
+              'Mode': 'rw',
+              'RW': true,
+            },
+          ],
+          'NetworkSettings': {
+            'Networks': {'bridge': {}, 'custom': {}},
+          },
+          'Created': 1704067200, // 2024-01-01 00:00:00 UTC
+          'SizeRw': 1024,
+          'SizeRootFs': 2048,
+        };
+
+        final model = ContainerModel.fromJson(json);
+
+        expect(model.labels['com.docker.compose.project'], equals('mystack'));
+        expect(model.ports.length, equals(1));
+        expect(model.mounts.length, equals(1));
+        expect(model.networkSettings?.networks.length, equals(2));
+        expect(model.created, equals(1704067200));
+        expect(model.sizeRw, equals(1024));
+        expect(model.sizeRootFs, equals(2048));
+      });
+
+      test('handles empty lists and maps', () {
+        final json = {
+          'Id': 'abc123',
+          'Names': ['/container'],
+          'Image': 'alpine',
+          'State': 'exited',
+          'Status': 'Exited (0)',
+          'Labels': <String, String>{},
+          'Ports': <Map<String, dynamic>>[],
+          'Mounts': <Map<String, dynamic>>[],
+        };
+
+        final model = ContainerModel.fromJson(json);
+
+        expect(model.labels, isEmpty);
+        expect(model.ports, isEmpty);
+        expect(model.mounts, isEmpty);
+      });
+    });
+
+    group('toEntity', () {
+      test('converts to entity with truncated ID', () {
+        final model = ContainerModel(
+          id: 'abc123def456789xyz',
+          names: ['/my-container'],
+          image: 'nginx:latest',
+          state: 'running',
+          status: 'Up 2 hours',
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.id, equals('abc123def456')); // Truncated to 12 chars
+        expect(entity.fullId, equals('abc123def456789xyz'));
+      });
+
+      test('strips leading slash from container name', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: ['/my-container'],
+          image: 'nginx:latest',
+          state: 'running',
+          status: 'Up 2 hours',
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.name, equals('my-container'));
+      });
+
+      test('uses ID as name when names list is empty', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: [],
+          image: 'nginx:latest',
+          state: 'running',
+          status: 'Up 2 hours',
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.name, equals('abc123def456'));
+      });
+
+      test('extracts stack name from compose labels', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: ['/container'],
+          image: 'nginx',
+          state: 'running',
+          status: 'Up',
+          labels: {'com.docker.compose.project': 'my-stack'},
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.stackName, equals('my-stack'));
+        expect(entity.stackId, equals('my-stack'));
+      });
+
+      test('handles missing stack labels', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: ['/container'],
+          image: 'nginx',
+          state: 'running',
+          status: 'Up',
+          labels: {},
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.stackName, isNull);
+        expect(entity.stackId, isNull);
+      });
+
+      test('converts created timestamp to DateTime', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: ['/container'],
+          image: 'nginx',
+          state: 'running',
+          status: 'Up',
+          created: 1704067200, // 2024-01-01 00:00:00 UTC
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.createdAt, isNotNull);
+        expect(entity.createdAt!.year, equals(2024));
+        expect(entity.createdAt!.month, equals(1));
+        expect(entity.createdAt!.day, equals(1));
+      });
+
+      test('handles null created timestamp', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: ['/container'],
+          image: 'nginx',
+          state: 'running',
+          status: 'Up',
+          created: null,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.createdAt, isNull);
+      });
+
+      test('extracts networks from network settings', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: ['/container'],
+          image: 'nginx',
+          state: 'running',
+          status: 'Up',
+          networkSettings: const NetworkSettingsModel(
+            networks: {'bridge': {}, 'custom-network': {}},
+          ),
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.networks, containsAll(['bridge', 'custom-network']));
+      });
+
+      test('handles null network settings', () {
+        final model = ContainerModel(
+          id: 'abc123def456',
+          names: ['/container'],
+          image: 'nginx',
+          state: 'running',
+          status: 'Up',
+          networkSettings: null,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.networks, isEmpty);
+      });
+    });
+
+    group('_parseState', () {
+      final testCases = {
+        'created': ContainerState.created,
+        'Created': ContainerState.created,
+        'CREATED': ContainerState.created,
+        'running': ContainerState.running,
+        'Running': ContainerState.running,
+        'RUNNING': ContainerState.running,
+        'paused': ContainerState.paused,
+        'Paused': ContainerState.paused,
+        'restarting': ContainerState.restarting,
+        'Restarting': ContainerState.restarting,
+        'removing': ContainerState.removing,
+        'Removing': ContainerState.removing,
+        'exited': ContainerState.exited,
+        'Exited': ContainerState.exited,
+        'dead': ContainerState.dead,
+        'Dead': ContainerState.dead,
+        'unknown': ContainerState.exited, // Unknown defaults to exited
+        '': ContainerState.exited, // Empty defaults to exited
+        'invalid': ContainerState.exited, // Invalid defaults to exited
+      };
+
+      testCases.forEach((input, expected) {
+        test('parses "$input" to ${expected.name}', () {
+          final model = ContainerModel(
+            id: 'abc123def456',
+            names: ['/container'],
+            image: 'nginx',
+            state: input,
+            status: 'Status',
+          );
+
+          final entity = model.toEntity();
+
+          expect(entity.state, equals(expected));
+        });
+      });
+    });
+  });
+
+  group('PortModel', () {
+    group('fromJson', () {
+      test('deserializes port with all fields', () {
+        final json = {
+          'IP': '0.0.0.0',
+          'PrivatePort': 80,
+          'PublicPort': 8080,
+          'Type': 'tcp',
+        };
+
+        final model = PortModel.fromJson(json);
+
+        expect(model.ip, equals('0.0.0.0'));
+        expect(model.privatePort, equals(80));
+        expect(model.publicPort, equals(8080));
+        expect(model.type, equals('tcp'));
+      });
+
+      test('deserializes port with minimal fields', () {
+        final json = {
+          'PrivatePort': 443,
+        };
+
+        final model = PortModel.fromJson(json);
+
+        expect(model.ip, isNull);
+        expect(model.privatePort, equals(443));
+        expect(model.publicPort, isNull);
+        expect(model.type, equals('tcp')); // Default
+      });
+
+      test('handles UDP type', () {
+        final json = {
+          'PrivatePort': 53,
+          'Type': 'udp',
+        };
+
+        final model = PortModel.fromJson(json);
+
+        expect(model.type, equals('udp'));
+      });
+    });
+
+    group('toEntity', () {
+      test('converts to PortMapping entity', () {
+        const model = PortModel(
+          ip: '127.0.0.1',
+          privatePort: 80,
+          publicPort: 8080,
+          type: 'tcp',
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.hostIp, equals('127.0.0.1'));
+        expect(entity.hostPort, equals(8080));
+        expect(entity.containerPort, equals(80));
+        expect(entity.protocol, equals('tcp'));
+      });
+
+      test('handles null public port', () {
+        const model = PortModel(
+          privatePort: 80,
+          publicPort: null,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.hostPort, isNull);
+        expect(entity.containerPort, equals(80));
+      });
+    });
+  });
+
+  group('MountModel', () {
+    group('fromJson', () {
+      test('deserializes bind mount', () {
+        final json = {
+          'Type': 'bind',
+          'Source': '/host/path',
+          'Destination': '/container/path',
+          'Mode': 'rw',
+          'RW': true,
+        };
+
+        final model = MountModel.fromJson(json);
+
+        expect(model.type, equals('bind'));
+        expect(model.source, equals('/host/path'));
+        expect(model.destination, equals('/container/path'));
+        expect(model.mode, equals('rw'));
+        expect(model.rw, isTrue);
+      });
+
+      test('deserializes volume mount', () {
+        final json = {
+          'Type': 'volume',
+          'Source': 'my-volume',
+          'Destination': '/data',
+          'Mode': 'ro',
+          'RW': false,
+        };
+
+        final model = MountModel.fromJson(json);
+
+        expect(model.type, equals('volume'));
+        expect(model.rw, isFalse);
+      });
+
+      test('uses defaults for missing fields', () {
+        final json = {
+          'Type': 'bind',
+          'Source': '/src',
+          'Destination': '/dst',
+        };
+
+        final model = MountModel.fromJson(json);
+
+        expect(model.mode, equals('rw'));
+        expect(model.rw, isTrue);
+      });
+    });
+
+    group('toEntity', () {
+      test('converts read-write mount to entity', () {
+        const model = MountModel(
+          type: 'bind',
+          source: '/host',
+          destination: '/container',
+          rw: true,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.type, equals('bind'));
+        expect(entity.source, equals('/host'));
+        expect(entity.destination, equals('/container'));
+        expect(entity.mode, equals('rw'));
+      });
+
+      test('converts read-only mount to entity', () {
+        const model = MountModel(
+          type: 'volume',
+          source: 'vol',
+          destination: '/data',
+          rw: false,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.mode, equals('ro'));
+      });
+    });
+  });
+
+  group('NetworkSettingsModel', () {
+    test('deserializes network settings', () {
+      final json = {
+        'Networks': {
+          'bridge': {'IPAddress': '172.17.0.2'},
+          'custom': {'IPAddress': '10.0.0.5'},
+        },
+      };
+
+      final model = NetworkSettingsModel.fromJson(json);
+
+      expect(model.networks.keys, containsAll(['bridge', 'custom']));
+    });
+
+    test('handles empty networks', () {
+      final json = {
+        'Networks': <String, dynamic>{},
+      };
+
+      final model = NetworkSettingsModel.fromJson(json);
+
+      expect(model.networks, isEmpty);
+    });
+
+    test('uses empty map as default', () {
+      final json = <String, dynamic>{};
+
+      final model = NetworkSettingsModel.fromJson(json);
+
+      expect(model.networks, isEmpty);
+    });
+  });
+}

test/features/control_room/npm/data/models/proxy_host_model_test.dart

@@ -0,0 +1,335 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tatlock_ui/features/control_room/npm/data/models/proxy_host_model.dart';
+
+void main() {
+  group('NullableIntOrBoolConverter', () {
+    const converter = NullableIntOrBoolConverter();
+
+    group('fromJson', () {
+      test('returns null for null input', () {
+        expect(converter.fromJson(null), isNull);
+      });
+
+      test('returns null for false input', () {
+        expect(converter.fromJson(false), isNull);
+      });
+
+      test('returns null for true input (treats as invalid)', () {
+        // true is not a valid ID, so we return null
+        expect(converter.fromJson(true), isNull);
+      });
+
+      test('returns int for int input', () {
+        expect(converter.fromJson(42), equals(42));
+      });
+
+      test('returns int for positive int', () {
+        expect(converter.fromJson(1), equals(1));
+      });
+
+      test('returns int for zero', () {
+        expect(converter.fromJson(0), equals(0));
+      });
+
+      test('converts double to int', () {
+        expect(converter.fromJson(42.0), equals(42));
+      });
+
+      test('converts double with decimals to int (truncates)', () {
+        expect(converter.fromJson(42.9), equals(42));
+      });
+
+      test('returns null for string input', () {
+        expect(converter.fromJson('42'), isNull);
+      });
+
+      test('returns null for empty string', () {
+        expect(converter.fromJson(''), isNull);
+      });
+    });
+
+    group('toJson', () {
+      test('returns null for null input', () {
+        expect(converter.toJson(null), isNull);
+      });
+
+      test('returns int for int input', () {
+        expect(converter.toJson(42), equals(42));
+      });
+
+      test('returns zero for zero input', () {
+        expect(converter.toJson(0), equals(0));
+      });
+    });
+  });
+
+  group('IntOrBoolConverter', () {
+    const converter = IntOrBoolConverter();
+
+    group('fromJson', () {
+      test('returns 0 for null input', () {
+        expect(converter.fromJson(null), equals(0));
+      });
+
+      test('returns 0 for false input', () {
+        expect(converter.fromJson(false), equals(0));
+      });
+
+      test('returns 1 for true input', () {
+        expect(converter.fromJson(true), equals(1));
+      });
+
+      test('returns int for int input', () {
+        expect(converter.fromJson(42), equals(42));
+      });
+
+      test('returns 0 for zero input', () {
+        expect(converter.fromJson(0), equals(0));
+      });
+
+      test('returns 1 for one input', () {
+        expect(converter.fromJson(1), equals(1));
+      });
+
+      test('converts double to int', () {
+        expect(converter.fromJson(42.0), equals(42));
+      });
+
+      test('converts double with decimals to int (truncates)', () {
+        expect(converter.fromJson(42.9), equals(42));
+      });
+
+      test('returns 0 for string input', () {
+        expect(converter.fromJson('42'), equals(0));
+      });
+
+      test('returns 0 for empty string', () {
+        expect(converter.fromJson(''), equals(0));
+      });
+
+      test('returns 0 for invalid types', () {
+        expect(converter.fromJson([1, 2, 3]), equals(0));
+        expect(converter.fromJson({'key': 'value'}), equals(0));
+      });
+    });
+
+    group('toJson', () {
+      test('returns int for int input', () {
+        expect(converter.toJson(42), equals(42));
+      });
+
+      test('returns 0 for zero input', () {
+        expect(converter.toJson(0), equals(0));
+      });
+
+      test('returns 1 for one input', () {
+        expect(converter.toJson(1), equals(1));
+      });
+    });
+  });
+
+  group('ProxyHostModel JSON serialization', () {
+    test('deserializes with boolean certificate_id (false)', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'http',
+        'forward_host': 'localhost',
+        'forward_port': 8080,
+        'certificate_id': false, // NPM returns false for no certificate
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.certificateId, isNull);
+    });
+
+    test('deserializes with int certificate_id', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'http',
+        'forward_host': 'localhost',
+        'forward_port': 8080,
+        'certificate_id': 42,
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.certificateId, equals(42));
+    });
+
+    test('deserializes with null certificate_id', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'http',
+        'forward_host': 'localhost',
+        'forward_port': 8080,
+        'certificate_id': null,
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.certificateId, isNull);
+    });
+
+    test('deserializes with boolean http2_support (true)', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'http',
+        'forward_host': 'localhost',
+        'forward_port': 8080,
+        'http2_support': true, // NPM can return boolean
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.http2Support, equals(1));
+    });
+
+    test('deserializes with boolean http2_support (false)', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'http',
+        'forward_host': 'localhost',
+        'forward_port': 8080,
+        'http2_support': false,
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.http2Support, equals(0));
+    });
+
+    test('deserializes with int http2_support', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'http',
+        'forward_host': 'localhost',
+        'forward_port': 8080,
+        'http2_support': 1,
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.http2Support, equals(1));
+    });
+
+    test('deserializes with all boolean flags', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'https',
+        'forward_host': 'localhost',
+        'forward_port': 443,
+        'ssl_forced': true,
+        'certificate_id': false,
+        'enabled': true,
+        'http2_support': true,
+        'hsts_enabled': false,
+        'access_list_id': false,
+        'caching_enabled': true,
+        'block_exploits': true,
+        'allow_websocket_upgrade': false,
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.sslForced, isTrue);
+      expect(model.certificateId, isNull);
+      expect(model.enabled, equals(1));
+      expect(model.http2Support, equals(1));
+      expect(model.hstsEnabled, equals(0));
+      expect(model.accessListId, isNull);
+      expect(model.cachingEnabled, equals(1));
+      expect(model.blockExploits, equals(1));
+      expect(model.allowWebsocketUpgrade, equals(0));
+    });
+
+    test('deserializes with all int flags', () {
+      final json = {
+        'id': 1,
+        'domain_names': ['example.com'],
+        'forward_scheme': 'https',
+        'forward_host': 'localhost',
+        'forward_port': 443,
+        'ssl_forced': false,
+        'certificate_id': 5,
+        'enabled': 1,
+        'http2_support': 1,
+        'hsts_enabled': 0,
+        'access_list_id': 3,
+        'caching_enabled': 1,
+        'block_exploits': 1,
+        'allow_websocket_upgrade': 0,
+      };
+
+      final model = ProxyHostModel.fromJson(json);
+
+      expect(model.sslForced, isFalse);
+      expect(model.certificateId, equals(5));
+      expect(model.enabled, equals(1));
+      expect(model.http2Support, equals(1));
+      expect(model.hstsEnabled, equals(0));
+      expect(model.accessListId, equals(3));
+      expect(model.cachingEnabled, equals(1));
+      expect(model.blockExploits, equals(1));
+      expect(model.allowWebsocketUpgrade, equals(0));
+    });
+
+    test('toEntity converts correctly', () {
+      final model = ProxyHostModel(
+        id: 1,
+        domainNames: ['example.com', 'www.example.com'],
+        forwardScheme: 'https',
+        forwardHost: 'backend',
+        forwardPort: 8080,
+        sslForced: true,
+        certificateId: 5,
+        enabled: 1,
+        http2Support: 1,
+        hstsEnabled: 1,
+        cachingEnabled: 0,
+        blockExploits: 1,
+        allowWebsocketUpgrade: 1,
+      );
+
+      final entity = model.toEntity();
+
+      expect(entity.id, equals(1));
+      expect(entity.domainNames, equals(['example.com', 'www.example.com']));
+      expect(entity.forwardScheme, equals('https'));
+      expect(entity.forwardHost, equals('backend'));
+      expect(entity.forwardPort, equals(8080));
+      expect(entity.forceSSL, isTrue);
+      expect(entity.sslEnabled, isTrue); // certificateId > 0
+      expect(entity.certificateId, equals(5));
+      expect(entity.enabled, isTrue);
+      expect(entity.http2Support, isTrue);
+      expect(entity.hstsEnabled, isTrue);
+      expect(entity.cacheAssets, isFalse);
+      expect(entity.blockExploits, isTrue);
+      expect(entity.websocketSupport, isTrue);
+    });
+
+    test('toEntity handles null certificateId correctly', () {
+      final model = ProxyHostModel(
+        id: 1,
+        domainNames: ['example.com'],
+        forwardScheme: 'http',
+        forwardHost: 'backend',
+        forwardPort: 80,
+        certificateId: null,
+      );
+
+      final entity = model.toEntity();
+
+      expect(entity.sslEnabled, isFalse);
+      expect(entity.certificateId, isNull);
+    });
+  });
+}

test/features/control_room/stacks/data/models/stack_model_test.dart

@@ -0,0 +1,395 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:tatlock_ui/features/control_room/stacks/data/models/stack_model.dart';
+import 'package:tatlock_ui/features/control_room/stacks/domain/entities/stack.dart';
+
+void main() {
+  group('StackModel', () {
+    group('fromJson', () {
+      test('deserializes minimal stack', () {
+        final json = {
+          'id': 'stack-123',
+          'name': 'my-stack',
+        };
+
+        final model = StackModel.fromJson(json);
+
+        expect(model.id, equals('stack-123'));
+        expect(model.name, equals('my-stack'));
+        expect(model.containerCount, equals(0)); // Default
+        expect(model.runningCount, equals(0)); // Default
+      });
+
+      test('deserializes full stack with all fields', () {
+        final json = {
+          'id': 'stack-456',
+          'name': 'production-stack',
+          'type': 'compose',
+          'status': 'active',
+          'container_count': 5,
+          'running_count': 5,
+          'compose_file': '/path/to/docker-compose.yml',
+          'environment': 'production',
+          'created_at': '2024-01-15T10:30:00Z',
+          'updated_at': '2024-01-20T15:45:00Z',
+        };
+
+        final model = StackModel.fromJson(json);
+
+        expect(model.id, equals('stack-456'));
+        expect(model.name, equals('production-stack'));
+        expect(model.typeString, equals('compose'));
+        expect(model.statusString, equals('active'));
+        expect(model.containerCount, equals(5));
+        expect(model.runningCount, equals(5));
+        expect(model.composeFile, equals('/path/to/docker-compose.yml'));
+        expect(model.environment, equals('production'));
+        expect(model.createdAt, equals('2024-01-15T10:30:00Z'));
+        expect(model.updatedAt, equals('2024-01-20T15:45:00Z'));
+      });
+
+      test('handles null optional fields', () {
+        final json = {
+          'id': 'stack-789',
+          'name': 'minimal-stack',
+          'type': null,
+          'status': null,
+          'compose_file': null,
+          'environment': null,
+          'created_at': null,
+          'updated_at': null,
+        };
+
+        final model = StackModel.fromJson(json);
+
+        expect(model.typeString, isNull);
+        expect(model.statusString, isNull);
+        expect(model.composeFile, isNull);
+        expect(model.environment, isNull);
+        expect(model.createdAt, isNull);
+        expect(model.updatedAt, isNull);
+      });
+
+      test('uses defaults for missing container counts', () {
+        final json = {
+          'id': 'stack-abc',
+          'name': 'test-stack',
+        };
+
+        final model = StackModel.fromJson(json);
+
+        expect(model.containerCount, equals(0));
+        expect(model.runningCount, equals(0));
+      });
+    });
+
+    group('toEntity', () {
+      test('converts to entity with all fields', () {
+        const model = StackModel(
+          id: 'stack-123',
+          name: 'my-stack',
+          typeString: 'compose',
+          statusString: 'active',
+          containerCount: 3,
+          runningCount: 2,
+          composeFile: '/compose.yml',
+          environment: 'staging',
+          createdAt: '2024-01-01T00:00:00Z',
+          updatedAt: '2024-01-02T12:00:00Z',
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.id, equals('stack-123'));
+        expect(entity.name, equals('my-stack'));
+        expect(entity.type, equals(StackType.compose));
+        expect(entity.status, equals(StackStatus.active));
+        expect(entity.containerCount, equals(3));
+        expect(entity.runningCount, equals(2));
+        expect(entity.composeFile, equals('/compose.yml'));
+        expect(entity.environment, equals('staging'));
+        expect(entity.createdAt, isNotNull);
+        expect(entity.updatedAt, isNotNull);
+      });
+
+      test('handles null timestamps', () {
+        const model = StackModel(
+          id: 'stack-123',
+          name: 'my-stack',
+          createdAt: null,
+          updatedAt: null,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.createdAt, isNull);
+        expect(entity.updatedAt, isNull);
+      });
+
+      test('handles invalid timestamp format', () {
+        const model = StackModel(
+          id: 'stack-123',
+          name: 'my-stack',
+          createdAt: 'invalid-date',
+          updatedAt: 'not-a-date',
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.createdAt, isNull);
+        expect(entity.updatedAt, isNull);
+      });
+
+      test('parses valid ISO 8601 timestamps', () {
+        const model = StackModel(
+          id: 'stack-123',
+          name: 'my-stack',
+          createdAt: '2024-06-15T14:30:00.000Z',
+          updatedAt: '2024-06-16T09:15:30.500Z',
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.createdAt?.year, equals(2024));
+        expect(entity.createdAt?.month, equals(6));
+        expect(entity.createdAt?.day, equals(15));
+        expect(entity.updatedAt?.hour, equals(9));
+        expect(entity.updatedAt?.minute, equals(15));
+      });
+    });
+
+    group('_parseStackType', () {
+      final testCases = {
+        'compose': StackType.compose,
+        'Compose': StackType.compose,
+        'COMPOSE': StackType.compose,
+        'swarm': StackType.swarm,
+        'Swarm': StackType.swarm,
+        'SWARM': StackType.swarm,
+        'kubernetes': StackType.kubernetes,
+        'Kubernetes': StackType.kubernetes,
+        'KUBERNETES': StackType.kubernetes,
+        'k8s': StackType.kubernetes,
+        'K8S': StackType.kubernetes,
+        'K8s': StackType.kubernetes,
+        'unknown': StackType.compose, // Defaults to compose
+        '': StackType.compose, // Empty defaults to compose
+        'invalid': StackType.compose, // Invalid defaults to compose
+      };
+
+      testCases.forEach((input, expected) {
+        test('parses "$input" to ${expected.name}', () {
+          final model = StackModel(
+            id: 'stack-123',
+            name: 'test',
+            typeString: input,
+          );
+
+          final entity = model.toEntity();
+
+          expect(entity.type, equals(expected));
+        });
+      });
+
+      test('handles null type', () {
+        const model = StackModel(
+          id: 'stack-123',
+          name: 'test',
+          typeString: null,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.type, equals(StackType.compose));
+      });
+    });
+
+    group('_parseStackStatus', () {
+      final testCases = {
+        'active': StackStatus.active,
+        'Active': StackStatus.active,
+        'ACTIVE': StackStatus.active,
+        'running': StackStatus.active,
+        'Running': StackStatus.active,
+        'RUNNING': StackStatus.active,
+        'inactive': StackStatus.inactive,
+        'Inactive': StackStatus.inactive,
+        'INACTIVE': StackStatus.inactive,
+        'stopped': StackStatus.inactive,
+        'Stopped': StackStatus.inactive,
+        'STOPPED': StackStatus.inactive,
+        'error': StackStatus.error,
+        'Error': StackStatus.error,
+        'ERROR': StackStatus.error,
+        'unknown': StackStatus.unknown, // Defaults to unknown
+        '': StackStatus.unknown, // Empty defaults to unknown
+        'invalid': StackStatus.unknown, // Invalid defaults to unknown
+      };
+
+      testCases.forEach((input, expected) {
+        test('parses "$input" to ${expected.name}', () {
+          final model = StackModel(
+            id: 'stack-123',
+            name: 'test',
+            statusString: input,
+          );
+
+          final entity = model.toEntity();
+
+          expect(entity.status, equals(expected));
+        });
+      });
+
+      test('handles null status', () {
+        const model = StackModel(
+          id: 'stack-123',
+          name: 'test',
+          statusString: null,
+        );
+
+        final entity = model.toEntity();
+
+        expect(entity.status, equals(StackStatus.unknown));
+      });
+    });
+  });
+
+  group('Stack entity', () {
+    group('isHealthy', () {
+      test('returns true when all containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'healthy-stack',
+          containerCount: 5,
+          runningCount: 5,
+        );
+
+        expect(stack.isHealthy, isTrue);
+      });
+
+      test('returns false when some containers are not running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'partial-stack',
+          containerCount: 5,
+          runningCount: 3,
+        );
+
+        expect(stack.isHealthy, isFalse);
+      });
+
+      test('returns false when no containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'stopped-stack',
+          containerCount: 5,
+          runningCount: 0,
+        );
+
+        expect(stack.isHealthy, isFalse);
+      });
+
+      test('returns false when containerCount is zero', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'empty-stack',
+          containerCount: 0,
+          runningCount: 0,
+        );
+
+        expect(stack.isHealthy, isFalse);
+      });
+    });
+
+    group('hasRunningContainers', () {
+      test('returns true when some containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'running-stack',
+          containerCount: 5,
+          runningCount: 2,
+        );
+
+        expect(stack.hasRunningContainers, isTrue);
+      });
+
+      test('returns false when no containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'stopped-stack',
+          containerCount: 5,
+          runningCount: 0,
+        );
+
+        expect(stack.hasRunningContainers, isFalse);
+      });
+
+      test('returns true when all containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'healthy-stack',
+          containerCount: 3,
+          runningCount: 3,
+        );
+
+        expect(stack.hasRunningContainers, isTrue);
+      });
+    });
+
+    group('isPartial', () {
+      test('returns true when some but not all containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'partial-stack',
+          containerCount: 5,
+          runningCount: 3,
+        );
+
+        expect(stack.isPartial, isTrue);
+      });
+
+      test('returns false when all containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'healthy-stack',
+          containerCount: 5,
+          runningCount: 5,
+        );
+
+        expect(stack.isPartial, isFalse);
+      });
+
+      test('returns false when no containers are running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'stopped-stack',
+          containerCount: 5,
+          runningCount: 0,
+        );
+
+        expect(stack.isPartial, isFalse);
+      });
+
+      test('returns false when containerCount is zero', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'empty-stack',
+          containerCount: 0,
+          runningCount: 0,
+        );
+
+        expect(stack.isPartial, isFalse);
+      });
+
+      test('returns true when only one of many containers is running', () {
+        const stack = Stack(
+          id: 'stack-1',
+          name: 'degraded-stack',
+          containerCount: 10,
+          runningCount: 1,
+        );
+
+        expect(stack.isPartial, isTrue);
+      });
+    });
+  });
+}