Enhance inbound management by removing MaxClients property

- Removed the MaxClients property from Inbound-related data models, including InboundDto and PublishInboundCommand.
- Updated related methods and handlers to reflect the removal of MaxClients, ensuring consistent behavior across the application.
- Adjusted API documentation and frontend components to remove references to MaxClients, streamlining the inbound publishing process.
- Enhanced logging in command handlers to handle node unavailability scenarios during user actions.
- Improved database schema and migrations to align with the updated data model.

Dockerfile

@@ -37,6 +37,10 @@ ENV ASPNETCORE_ENVIRONMENT=Production \
     ASPNETCORE_HTTP_PORTS=8080
 EXPOSE 8080
 COPY --from=backend /app/publish ./
+# Data Protection key-ring и загрузки тикетов монтируются сюда volume'ами (см. docker-compose.yml).
+# Готовим права заранее — Docker скопирует владельца/содержимое в volume при первом маунте (copy-up).
+RUN mkdir -p /app/keys /app/uploads && chown -R app:app /app/keys /app/uploads
+USER app
 HEALTHCHECK --interval=15s --timeout=5s --start-period=20s --retries=5 \
     CMD curl -f http://localhost:8080/health || exit 1
 ENTRYPOINT ["dotnet", "PnvPanel.Api.dll"]

backend/src/PnvPanel.Api/Endpoints/InboundEndpoints.cs

@@ -40,8 +40,7 @@ public static class InboundEndpoints
             id,
             body.IsPublished,
             body.DisplayName,
-            body.AllowedRoleIds ?? [],
+            body.AllowedRoleIds ?? []
-            body.MaxClients
         );
         var result = await sender.Send(command, cancellationToken);
         return result.ToHttpResult();
@@ -51,6 +50,5 @@ public static class InboundEndpoints
 public sealed record PublishInboundBody(
     bool IsPublished,
     string? DisplayName,
-    IReadOnlyList<Guid>? AllowedRoleIds,
+    IReadOnlyList<Guid>? AllowedRoleIds
-    int? MaxClients
 );

backend/src/PnvPanel.Application/Admin/Inbounds/InboundDto.cs

@@ -11,7 +11,6 @@ public sealed record InboundDto(
     int Port,
     bool IsPublished,
     string? DisplayName,
-    int? MaxClients,
     IReadOnlyList<Guid> AllowedRoleIds,
     DateTimeOffset? LastSyncAt
 )
@@ -26,7 +25,6 @@ public sealed record InboundDto(
             inbound.Port,
             inbound.IsPublished,
             inbound.DisplayName,
-            inbound.MaxClients,
             inbound.AllowedRoleIds,
             inbound.LastSyncAt
         );

backend/src/PnvPanel.Application/Admin/Inbounds/PublishInboundCommand.cs

@@ -7,6 +7,5 @@ public sealed record PublishInboundCommand(
     Guid InboundId,
     bool IsPublished,
     string? DisplayName,
-    IReadOnlyList<Guid> AllowedRoleIds,
+    IReadOnlyList<Guid> AllowedRoleIds
-    int? MaxClients
 ) : ICommand<Result<InboundDto>>;

backend/src/PnvPanel.Application/Admin/Inbounds/PublishInboundCommandHandler.cs

@@ -22,7 +22,7 @@ public sealed class PublishInboundCommandHandler(IAppDbContext dbContext, ICurre
             return Result.Failure<InboundDto>(InboundErrors.NotFound);
 
         if (command.IsPublished)
-            inbound.Publish(command.DisplayName, command.AllowedRoleIds, command.MaxClients);
+            inbound.Publish(command.DisplayName, command.AllowedRoleIds);
         else
             inbound.Unpublish();
 

backend/src/PnvPanel.Application/Admin/Inbounds/PublishInboundCommandValidator.cs

@@ -7,6 +7,5 @@ public sealed class PublishInboundCommandValidator : AbstractValidator<PublishIn
     public PublishInboundCommandValidator()
     {
         RuleFor(x => x.DisplayName).MaximumLength(100);
-        RuleFor(x => x.MaxClients).GreaterThan(0).When(x => x.MaxClients.HasValue);
     }
 }

backend/src/PnvPanel.Application/Admin/Users/DeleteUserCommandHandler.cs

@@ -1,7 +1,9 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using PnvPanel.Application.Common.Interfaces;
 using PnvPanel.Application.Common.Messaging;
 using PnvPanel.Application.Common.Models;
+using PnvPanel.Application.Configs;
 using PnvPanel.Domain.Audit;
 using PnvPanel.Domain.Configs;
 
@@ -13,7 +15,8 @@ public sealed class DeleteUserCommandHandler(
     IIdentityService identityService,
     IXuiPanelGateway gateway,
     ITelegramNotifier telegramNotifier,
-    ICurrentUser currentUser
+    ICurrentUser currentUser,
+    ILogger<DeleteUserCommandHandler> logger
 ) : ICommandHandler<DeleteUserCommand, Result>
 {
     public async Task<Result> Handle(DeleteUserCommand command, CancellationToken cancellationToken)
@@ -37,7 +40,8 @@ public sealed class DeleteUserCommandHandler(
                     .FirstOrDefaultAsync(n => n.Id == inbound.NodeId, cancellationToken);
 
             if (inbound is not null && node is not null)
-                await gateway.RemoveClientAsync(
+            {
+                var removeResult = await gateway.RemoveClientAsync(
                     node,
                     inbound.RemoteInboundId,
                     config.ClientExternalId,
@@ -45,6 +49,23 @@ public sealed class DeleteUserCommandHandler(
                     cancellationToken
                 );
 
+                if (!removeResult.IsSuccess)
+                {
+                    // Нода недоступна — прерываем удаление целиком, не трогая учётку/уже
+                    // просмотренные конфиги: иначе после удаления AppUser отозвать оставшиеся
+                    // клиенты в 3x-ui будет уже не от чего (некому будет принадлежать конфиг).
+                    // Админ может повторить DeleteUser позже, когда нода отойдёт.
+                    logger.LogWarning(
+                        "Failed to remove client for config {ConfigId} on node {NodeId} while deleting user {UserId}: {Error}",
+                        config.Id,
+                        node.Id,
+                        command.UserId,
+                        removeResult.Error
+                    );
+                    return Result.Failure(ConfigErrors.NodeUnavailable);
+                }
+            }
+
             config.Revoke();
         }
 

backend/src/PnvPanel.Application/Admin/Users/ForceRevokeConfigCommandHandler.cs

@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using PnvPanel.Application.Common.Interfaces;
 using PnvPanel.Application.Common.Messaging;
 using PnvPanel.Application.Common.Models;
@@ -13,7 +14,8 @@ public sealed class ForceRevokeConfigCommandHandler(
     IXuiPanelGateway gateway,
     IRealtimeNotifier notifier,
     ITelegramNotifier telegramNotifier,
-    ICurrentUser currentUser
+    ICurrentUser currentUser,
+    ILogger<ForceRevokeConfigCommandHandler> logger
 ) : ICommandHandler<ForceRevokeConfigCommand, Result>
 {
     public async Task<Result> Handle(
@@ -41,7 +43,8 @@ public sealed class ForceRevokeConfigCommandHandler(
                 .FirstOrDefaultAsync(n => n.Id == inbound.NodeId, cancellationToken);
 
         if (inbound is not null && node is not null)
-            await gateway.RemoveClientAsync(
+        {
+            var removeResult = await gateway.RemoveClientAsync(
                 node,
                 inbound.RemoteInboundId,
                 config.ClientExternalId,
@@ -49,6 +52,18 @@ public sealed class ForceRevokeConfigCommandHandler(
                 cancellationToken
             );
 
+            if (!removeResult.IsSuccess)
+            {
+                logger.LogWarning(
+                    "Failed to remove client for config {ConfigId} on node {NodeId} during force-revoke: {Error}",
+                    config.Id,
+                    node.Id,
+                    removeResult.Error
+                );
+                return Result.Failure(ConfigErrors.NodeUnavailable);
+            }
+        }
+
         config.Revoke();
         await notifier.NotifyConfigStatusChangedAsync(
             config.UserId,

backend/src/PnvPanel.Application/Auth/DeleteMyAccount/DeleteMyAccountCommandHandler.cs

@@ -1,7 +1,9 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using PnvPanel.Application.Common.Interfaces;
 using PnvPanel.Application.Common.Messaging;
 using PnvPanel.Application.Common.Models;
+using PnvPanel.Application.Configs;
 using PnvPanel.Domain.Configs;
 
 namespace PnvPanel.Application.Auth.DeleteMyAccount;
@@ -10,7 +12,8 @@ public sealed class DeleteMyAccountCommandHandler(
     IAppDbContext dbContext,
     IIdentityService identityService,
     IXuiPanelGateway gateway,
-    ICurrentUser currentUser
+    ICurrentUser currentUser,
+    ILogger<DeleteMyAccountCommandHandler> logger
 ) : ICommandHandler<DeleteMyAccountCommand, Result>
 {
     public async Task<Result> Handle(
@@ -37,7 +40,8 @@ public sealed class DeleteMyAccountCommandHandler(
                     .FirstOrDefaultAsync(n => n.Id == inbound.NodeId, cancellationToken);
 
             if (inbound is not null && node is not null)
-                await gateway.RemoveClientAsync(
+            {
+                var removeResult = await gateway.RemoveClientAsync(
                     node,
                     inbound.RemoteInboundId,
                     config.ClientExternalId,
@@ -45,6 +49,21 @@ public sealed class DeleteMyAccountCommandHandler(
                     cancellationToken
                 );
 
+                if (!removeResult.IsSuccess)
+                {
+                    // Прерываем самоудаление целиком — иначе после удаления учётки отозвать
+                    // оставшиеся клиенты в 3x-ui будет уже не от чего. Пользователь может повторить.
+                    logger.LogWarning(
+                        "Failed to remove client for config {ConfigId} on node {NodeId} while user {UserId} deletes own account: {Error}",
+                        config.Id,
+                        node.Id,
+                        userId,
+                        removeResult.Error
+                    );
+                    return Result.Failure(ConfigErrors.NodeUnavailable);
+                }
+            }
+
             config.Revoke();
         }
 

backend/src/PnvPanel.Application/Common/Behaviors/UnitOfWorkBehavior.cs

@@ -1,5 +1,6 @@
 using PnvPanel.Application.Common.Interfaces;
 using PnvPanel.Application.Common.Messaging;
+using PnvPanel.Application.Common.Models;
 
 namespace PnvPanel.Application.Common.Behaviors;
 
@@ -19,7 +20,12 @@ public sealed class UnitOfWorkBehavior<TRequest, TResponse>(IAppDbContext dbCont
     )
     {
         var response = await next();
+
+        // Не коммитим мутации, сделанные до отказа хендлера (например Approve() до фейла
+        // последующего шага) — иначе в БД закрепляется частичное/противоречивое состояние.
+        if (response is not Result { IsSuccess: false })
             await dbContext.SaveChangesAsync(cancellationToken);
+
         return response;
     }
 }

backend/src/PnvPanel.Application/Configs/ConfigErrors.cs

@@ -25,4 +25,9 @@ public static class ConfigErrors
     );
 
     public static readonly Error NotFound = Error.NotFound("Configs.NotFound", "Конфиг не найден.");
+
+    public static readonly Error NodeUnavailable = Error.Failure(
+        "Configs.NodeUnavailable",
+        "Сервер временно недоступен. Попробуйте повторить операцию позже."
+    );
 }

backend/src/PnvPanel.Application/Configs/Create/CreateVpnConfigCommandHandler.cs

@@ -4,6 +4,7 @@ using PnvPanel.Application.Common.Interfaces;
 using PnvPanel.Application.Common.Messaging;
 using PnvPanel.Application.Common.Models;
 using PnvPanel.Domain.Configs;
+using PnvPanel.Domain.Nodes;
 
 namespace PnvPanel.Application.Configs.Create;
 
@@ -39,7 +40,7 @@ public sealed class CreateVpnConfigCommandHandler(
         var node = await dbContext
             .Nodes.AsNoTracking()
             .FirstOrDefaultAsync(n => n.Id == inbound.NodeId, cancellationToken);
-        if (node is null || !node.IsEnabled)
+        if (node is null || !node.IsEnabled || node.Status == NodeStatus.Offline)
             return Result.Failure<VpnConfigDto>(ConfigErrors.NodeDisabled);
 
         var config = VpnConfig.Create(userId, inbound.Id, inbound.Protocol, command.Label);

backend/src/PnvPanel.Application/Configs/Edit/EditVpnConfigCommandHandler.cs

@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using PnvPanel.Application.Auth;
 using PnvPanel.Application.Common.Interfaces;
 using PnvPanel.Application.Common.Messaging;
@@ -9,7 +10,8 @@ namespace PnvPanel.Application.Configs.Edit;
 public sealed class EditVpnConfigCommandHandler(
     IAppDbContext dbContext,
     IXuiPanelGateway gateway,
-    ICurrentUser currentUser
+    ICurrentUser currentUser,
+    ILogger<EditVpnConfigCommandHandler> logger
 ) : ICommandHandler<EditVpnConfigCommand, Result<VpnConfigDto>>
 {
     public async Task<Result<VpnConfigDto>> Handle(
@@ -35,25 +37,38 @@ public sealed class EditVpnConfigCommandHandler(
 
         if (command.Label is not null)
         {
-            config.Rename(command.Label);
-
             var node = await dbContext
                 .Nodes.AsNoTracking()
                 .FirstOrDefaultAsync(n => n.Id == inbound.NodeId, cancellationToken);
             if (node is not null)
             {
-                await gateway.UpdateClientAsync(
+                var updateResult = await gateway.UpdateClientAsync(
                     node,
                     inbound.RemoteInboundId,
                     config.ClientExternalId,
                     config.Protocol,
-                    config.Label ?? config.ClientEmail,
+                    command.Label,
                     enable: true,
                     cancellationToken
                 );
+
+                if (!updateResult.IsSuccess)
+                {
+                    // Нода недоступна — не переименовываем локально, иначе метка разойдётся
+                    // с тем, что реально хранится в 3x-ui. Пользователь может повторить.
+                    logger.LogWarning(
+                        "Failed to rename client for config {ConfigId} on node {NodeId}: {Error}",
+                        config.Id,
+                        node.Id,
+                        updateResult.Error
+                    );
+                    return Result.Failure<VpnConfigDto>(ConfigErrors.NodeUnavailable);
                 }
             }
 
+            config.Rename(command.Label);
+        }
+
         return Result.Success(VpnConfigDto.FromDomain(config, inbound));
     }
 }

backend/src/PnvPanel.Application/Configs/Revoke/RevokeVpnConfigCommandHandler.cs

@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using PnvPanel.Application.Auth;
 using PnvPanel.Application.Common.Interfaces;
 using PnvPanel.Application.Common.Messaging;
@@ -11,7 +12,8 @@ public sealed class RevokeVpnConfigCommandHandler(
     IAppDbContext dbContext,
     IXuiPanelGateway gateway,
     IRealtimeNotifier notifier,
-    ICurrentUser currentUser
+    ICurrentUser currentUser,
+    ILogger<RevokeVpnConfigCommandHandler> logger
 ) : ICommandHandler<RevokeVpnConfigCommand, Result>
 {
     public async Task<Result> Handle(
@@ -42,7 +44,8 @@ public sealed class RevokeVpnConfigCommandHandler(
                 .FirstOrDefaultAsync(n => n.Id == inbound.NodeId, cancellationToken);
 
         if (inbound is not null && node is not null)
-            await gateway.RemoveClientAsync(
+        {
+            var removeResult = await gateway.RemoveClientAsync(
                 node,
                 inbound.RemoteInboundId,
                 config.ClientExternalId,
@@ -50,6 +53,20 @@ public sealed class RevokeVpnConfigCommandHandler(
                 cancellationToken
             );
 
+            if (!removeResult.IsSuccess)
+            {
+                // Нода недоступна/сбой панели — не помечаем конфиг Revoked локально, иначе БД
+                // разойдётся с реальным состоянием клиента в 3x-ui. Пользователь может повторить.
+                logger.LogWarning(
+                    "Failed to remove client for config {ConfigId} on node {NodeId}: {Error}",
+                    config.Id,
+                    node.Id,
+                    removeResult.Error
+                );
+                return Result.Failure(ConfigErrors.NodeUnavailable);
+            }
+        }
+
         config.Revoke();
         await notifier.NotifyConfigStatusChangedAsync(
             userId,

backend/src/PnvPanel.Domain/Inbounds/Inbound.cs

@@ -17,7 +17,6 @@ public sealed class Inbound : Entity
     public int Port { get; private set; }
     public bool IsPublished { get; private set; }
     public string? DisplayName { get; private set; }
-    public int? MaxClients { get; private set; }
     public IReadOnlyList<Guid> AllowedRoleIds { get; private set; } = [];
     public DateTimeOffset? LastSyncAt { get; private set; }
 
@@ -52,16 +51,11 @@ public sealed class Inbound : Entity
         LastSyncAt = DateTimeOffset.UtcNow;
     }
 
-    public void Publish(
+    public void Publish(string? displayName, IReadOnlyCollection<Guid> allowedRoleIds)
-        string? displayName,
-        IReadOnlyCollection<Guid> allowedRoleIds,
-        int? maxClients
-    )
     {
         IsPublished = true;
         DisplayName = displayName;
         AllowedRoleIds = allowedRoleIds.Distinct().ToList();
-        MaxClients = maxClients;
     }
 
     public void Unpublish() => IsPublished = false;

backend/src/PnvPanel.Infrastructure/Persistence/Migrations/20260714200833_RemoveInboundMaxClients.Designer.cs

@@ -0,0 +1,938 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using PnvPanel.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace PnvPanel.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260714200833_RemoveInboundMaxClients")]
+    partial class RemoveInboundMaxClients
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.9")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Activation.ActivationRequest", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("DecidedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("DecidedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RejectionReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Status");
+
+                    b.ToTable("ActivationRequests", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Apps.ClientApp", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("DownloadUrl")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("IconUrl")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsRecommended")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("OperatingSystem")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ClientApps", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Audit.AuditLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<Guid?>("ActorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Metadata")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("TargetId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("TargetType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("AuditLogs", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Configs.TrafficSample", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Guid>("ConfigId")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("DownBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("UpBytes")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ConfigId", "Timestamp");
+
+                    b.ToTable("TrafficSamples", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Configs.VpnConfig", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ClientEmail")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ClientExternalId")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("InboundId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Label")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTimeOffset?>("LastSyncAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Protocol")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("SubscriptionToken")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<long>("UsedDownBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("UsedUpBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InboundId");
+
+                    b.HasIndex("SubscriptionToken")
+                        .IsUnique();
+
+                    b.HasIndex("UserId", "Status");
+
+                    b.ToTable("VpnConfigs", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Inbounds.Inbound", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.PrimitiveCollection<Guid[]>("AllowedRoleIds")
+                        .IsRequired()
+                        .HasColumnType("uuid[]");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<bool>("IsPublished")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LastSyncAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("NodeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Port")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Protocol")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Remark")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RemoteInboundId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NodeId", "RemoteInboundId")
+                        .IsUnique();
+
+                    b.ToTable("Inbounds", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Instructions.InstructionIntro", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(20000)
+                        .HasColumnType("character varying(20000)");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("InstructionIntros", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Instructions.InstructionTab", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(20000)
+                        .HasColumnType("character varying(20000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTimeOffset?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder");
+
+                    b.ToTable("InstructionTabs", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.News.NewsPost", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(20000)
+                        .HasColumnType("character varying(20000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTimeOffset?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CreatedAt");
+
+                    b.ToTable("NewsPosts", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Nodes.Node", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BaseAddress")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LastSyncAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Location")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Nodes", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Support.SupportTicket", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int?>("ProposedMaxConfigs")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ProposedMaxIpLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ProposedRoleName")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<Guid?>("RequestedRoleId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Type", "Status");
+
+                    b.HasIndex("UserId", "Status");
+
+                    b.ToTable("SupportTickets", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Support.TicketAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CommentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("FileName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<long>("SizeBytes")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("StoredFileName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CommentId");
+
+                    b.HasIndex("StoredFileName")
+                        .IsUnique();
+
+                    b.ToTable("TicketAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Support.TicketComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AuthorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .HasColumnType("character varying(4000)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("TicketId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TicketId", "CreatedAt");
+
+                    b.ToTable("TicketComments", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Telegram.TelegramLinkToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset?>("ConsumedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.ToTable("TelegramLinkTokens", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Telegram.TelegramLoginRequest", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Context")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TelegramLoginRequests", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Infrastructure.Identity.AppRole", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("MaxConfigs")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MaxIpLimit")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Infrastructure.Identity.AppUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTimeOffset?>("ActivatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("ActivatedBy")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsActivated")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsBlocked")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubscriptionToken")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("TelegramLinkedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("TelegramUserId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("TelegramUsername")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("SubscriptionToken")
+                        .IsUnique();
+
+                    b.HasIndex("TelegramUserId")
+                        .IsUnique();
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("PnvPanel.Infrastructure.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReplacedByTokenHash")
+                        .HasColumnType("text");
+
+                    b.Property<DateTimeOffset?>("RevokedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
+                {
+                    b.HasOne("PnvPanel.Infrastructure.Identity.AppRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
+                {
+                    b.HasOne("PnvPanel.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
+                {
+                    b.HasOne("PnvPanel.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
+                {
+                    b.HasOne("PnvPanel.Infrastructure.Identity.AppRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PnvPanel.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
+                {
+                    b.HasOne("PnvPanel.Infrastructure.Identity.AppUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PnvPanel.Domain.Nodes.Node", b =>
+                {
+                    b.OwnsOne("PnvPanel.Domain.Nodes.NodeCredentials", "Credentials", b1 =>
+                        {
+                            b1.Property<Guid>("NodeId")
+                                .HasColumnType("uuid");
+
+                            b1.Property<string>("ProtectedPassword")
+                                .IsRequired()
+                                .HasColumnType("text")
+                                .HasColumnName("CredentialsProtectedPassword");
+
+                            b1.Property<string>("Username")
+                                .IsRequired()
+                                .HasMaxLength(200)
+                                .HasColumnType("character varying(200)")
+                                .HasColumnName("CredentialsUsername");
+
+                            b1.HasKey("NodeId");
+
+                            b1.ToTable("Nodes");
+
+                            b1.WithOwner()
+                                .HasForeignKey("NodeId");
+                        });
+
+                    b.Navigation("Credentials")
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

backend/src/PnvPanel.Infrastructure/Persistence/Migrations/20260714200833_RemoveInboundMaxClients.cs

@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PnvPanel.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class RemoveInboundMaxClients : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "MaxClients",
+                table: "Inbounds");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "MaxClients",
+                table: "Inbounds",
+                type: "integer",
+                nullable: true);
+        }
+    }
+}

backend/src/PnvPanel.Infrastructure/Persistence/Migrations/AppDbContextModelSnapshot.cs

@@ -365,9 +365,6 @@ namespace PnvPanel.Infrastructure.Persistence.Migrations
                     b.Property<DateTimeOffset?>("LastSyncAt")
                         .HasColumnType("timestamp with time zone");
 
-                    b.Property<int?>("MaxClients")
-                        .HasColumnType("integer");
-
                     b.Property<Guid>("NodeId")
                         .HasColumnType("uuid");
 

backend/tests/PnvPanel.Application.Tests/Admin/Configs/ListAllConfigsQueryHandlerTests.cs

@@ -26,7 +26,7 @@ public class ListAllConfigsQueryHandlerTests
             null
         );
         var inbound = Inbound.FromRemote(node.Id, "1", VpnProtocol.Vless, "remark", 443);
-        inbound.Publish("Germany", [], null);
+        inbound.Publish("Germany", []);
         var config = VpnConfig.Create(userId, inbound.Id, VpnProtocol.Vless, "my-config");
 
         dbContext.Nodes.Add(node);

backend/tests/PnvPanel.Application.Tests/Admin/Inbounds/PublishInboundCommandHandlerTests.cs

@@ -22,14 +22,13 @@ public class PublishInboundCommandHandlerTests
         var roleId = Guid.NewGuid();
         var handler = new PublishInboundCommandHandler(dbContext, _currentUser);
 
-        var command = new PublishInboundCommand(inbound.Id, true, "EU Fast", [roleId], 100);
+        var command = new PublishInboundCommand(inbound.Id, true, "EU Fast", [roleId]);
 
         var result = await handler.Handle(command, CancellationToken.None);
 
         Assert.True(result.IsSuccess);
         Assert.True(inbound.IsPublished);
         Assert.Equal("EU Fast", inbound.DisplayName);
-        Assert.Equal(100, inbound.MaxClients);
         Assert.Contains(roleId, inbound.AllowedRoleIds);
         Assert.Equal("EU Fast", result.Value.DisplayName);
     }
@@ -39,13 +38,13 @@ public class PublishInboundCommandHandlerTests
     {
         using var dbContext = InMemoryDbContextFactory.Create();
         var inbound = Inbound.FromRemote(Guid.NewGuid(), "1", VpnProtocol.Vless, "remark", 443);
-        inbound.Publish("EU Fast", [Guid.NewGuid()], 100);
+        inbound.Publish("EU Fast", [Guid.NewGuid()]);
         dbContext.Inbounds.Add(inbound);
         await dbContext.SaveChangesAsync(CancellationToken.None);
 
         var handler = new PublishInboundCommandHandler(dbContext, _currentUser);
 
-        var command = new PublishInboundCommand(inbound.Id, false, null, [], null);
+        var command = new PublishInboundCommand(inbound.Id, false, null, []);
 
         var result = await handler.Handle(command, CancellationToken.None);
 
@@ -60,7 +59,7 @@ public class PublishInboundCommandHandlerTests
 
         var handler = new PublishInboundCommandHandler(dbContext, _currentUser);
 
-        var command = new PublishInboundCommand(Guid.NewGuid(), true, "EU Fast", [], null);
+        var command = new PublishInboundCommand(Guid.NewGuid(), true, "EU Fast", []);
 
         var result = await handler.Handle(command, CancellationToken.None);
 

backend/tests/PnvPanel.Application.Tests/Admin/Users/DeleteUserCommandHandlerTests.cs

@@ -1,3 +1,4 @@
+using Microsoft.Extensions.Logging;
 using NSubstitute;
 using PnvPanel.Application.Admin.Users;
 using PnvPanel.Application.Common.Interfaces;
@@ -16,6 +17,9 @@ public class DeleteUserCommandHandlerTests
     private readonly IXuiPanelGateway _gateway = Substitute.For<IXuiPanelGateway>();
     private readonly ITelegramNotifier _telegramNotifier = Substitute.For<ITelegramNotifier>();
     private readonly ICurrentUser _currentUser = Substitute.For<ICurrentUser>();
+    private readonly ILogger<DeleteUserCommandHandler> _logger = Substitute.For<
+        ILogger<DeleteUserCommandHandler>
+    >();
 
     [Fact]
     public async Task Handle_WhenAdminTargetsSelf_ReturnsCannotDeleteSelfWithoutTouchingConfigs()
@@ -29,7 +33,8 @@ public class DeleteUserCommandHandlerTests
             _identityService,
             _gateway,
             _telegramNotifier,
-            _currentUser
+            _currentUser,
+            _logger
         );
 
         var result = await handler.Handle(new DeleteUserCommand(adminId), CancellationToken.None);
@@ -82,7 +87,8 @@ public class DeleteUserCommandHandlerTests
             _identityService,
             _gateway,
             _telegramNotifier,
-            _currentUser
+            _currentUser,
+            _logger
         );
 
         var result = await handler.Handle(new DeleteUserCommand(userId), CancellationToken.None);
@@ -125,7 +131,8 @@ public class DeleteUserCommandHandlerTests
             _identityService,
             _gateway,
             _telegramNotifier,
-            _currentUser
+            _currentUser,
+            _logger
         );
 
         var result = await handler.Handle(new DeleteUserCommand(userId), CancellationToken.None);
@@ -157,7 +164,8 @@ public class DeleteUserCommandHandlerTests
             _identityService,
             _gateway,
             _telegramNotifier,
-            _currentUser
+            _currentUser,
+            _logger
         );
 
         var result = await handler.Handle(new DeleteUserCommand(userId), CancellationToken.None);

backend/tests/PnvPanel.Application.Tests/Configs/GetMyConfigs/GetMyConfigsQueryHandlerTests.cs

@@ -22,7 +22,7 @@ public class GetMyConfigsQueryHandlerTests
         var otherUserId = Guid.NewGuid();
 
         var inbound = Inbound.FromRemote(Guid.NewGuid(), "1", VpnProtocol.Vless, "remark", 443);
-        inbound.Publish("My inbound", [], null);
+        inbound.Publish("My inbound", []);
 
         var activeConfig = VpnConfig.Create(userId, inbound.Id, VpnProtocol.Vless, "Active");
         var revokedConfig = VpnConfig.Create(userId, inbound.Id, VpnProtocol.Vless, "Revoked");

backend/tests/PnvPanel.Application.Tests/Configs/Revoke/RevokeVpnConfigCommandHandlerTests.cs

@@ -1,5 +1,7 @@
+using Microsoft.Extensions.Logging;
 using NSubstitute;
 using PnvPanel.Application.Common.Interfaces;
+using PnvPanel.Application.Common.Models;
 using PnvPanel.Application.Configs;
 using PnvPanel.Application.Configs.Revoke;
 using PnvPanel.Application.Tests.TestSupport;
@@ -14,6 +16,9 @@ public class RevokeVpnConfigCommandHandlerTests
 {
     private readonly IXuiPanelGateway _gateway = Substitute.For<IXuiPanelGateway>();
     private readonly IRealtimeNotifier _notifier = Substitute.For<IRealtimeNotifier>();
+    private readonly ILogger<RevokeVpnConfigCommandHandler> _logger = Substitute.For<
+        ILogger<RevokeVpnConfigCommandHandler>
+    >();
 
     [Fact]
     public async Task Handle_WhenActiveConfigOwnedByUser_RevokesRemovesRemoteClientAndNotifies()
@@ -36,11 +41,22 @@ public class RevokeVpnConfigCommandHandlerTests
         dbContext.VpnConfigs.Add(config);
         await dbContext.SaveChangesAsync(CancellationToken.None);
 
+        _gateway
+            .RemoveClientAsync(
+                Arg.Any<PnvPanel.Domain.Nodes.Node>(),
+                Arg.Any<string>(),
+                Arg.Any<string>(),
+                Arg.Any<VpnProtocol>(),
+                Arg.Any<CancellationToken>()
+            )
+            .Returns(Result.Success());
+
         var handler = new RevokeVpnConfigCommandHandler(
             dbContext,
             _gateway,
             _notifier,
-            FakeCurrentUser.Authenticated(userId)
+            FakeCurrentUser.Authenticated(userId),
+            _logger
         );
 
         var result = await handler.Handle(
@@ -87,7 +103,8 @@ public class RevokeVpnConfigCommandHandlerTests
             dbContext,
             _gateway,
             _notifier,
-            FakeCurrentUser.Authenticated(userId)
+            FakeCurrentUser.Authenticated(userId),
+            _logger
         );
 
         var result = await handler.Handle(
@@ -117,7 +134,8 @@ public class RevokeVpnConfigCommandHandlerTests
             dbContext,
             _gateway,
             _notifier,
-            FakeCurrentUser.Authenticated(userId)
+            FakeCurrentUser.Authenticated(userId),
+            _logger
         );
 
         var result = await handler.Handle(
@@ -138,7 +156,8 @@ public class RevokeVpnConfigCommandHandlerTests
             dbContext,
             _gateway,
             _notifier,
-            FakeCurrentUser.Anonymous()
+            FakeCurrentUser.Anonymous(),
+            _logger
         );
 
         var result = await handler.Handle(

backend/tests/PnvPanel.Domain.Tests/Inbounds/InboundTests.cs

@@ -35,16 +35,15 @@ public class InboundTests
     }
 
     [Fact]
-    public void Publish_SetsDisplayNameRolesAndMaxClients()
+    public void Publish_SetsDisplayNameAndRoles()
     {
         var inbound = Inbound.FromRemote(Guid.NewGuid(), "12", VpnProtocol.Vless, "Germany", 443);
         var roleId = Guid.NewGuid();
 
-        inbound.Publish("Germany (VLESS)", [roleId, roleId], 100);
+        inbound.Publish("Germany (VLESS)", [roleId, roleId]);
 
         Assert.True(inbound.IsPublished);
         Assert.Equal("Germany (VLESS)", inbound.DisplayName);
-        Assert.Equal(100, inbound.MaxClients);
         Assert.Single(inbound.AllowedRoleIds);
         Assert.Contains(roleId, inbound.AllowedRoleIds);
     }
@@ -54,7 +53,7 @@ public class InboundTests
     {
         var inbound = Inbound.FromRemote(Guid.NewGuid(), "12", VpnProtocol.Vless, "Germany", 443);
         var roleId = Guid.NewGuid();
-        inbound.Publish("Germany", [roleId], null);
+        inbound.Publish("Germany", [roleId]);
 
         inbound.Unpublish();
 

backend/tests/PnvPanel.IntegrationTests/Admin/NodeInboundCrudTests.cs

@@ -27,7 +27,6 @@ public class NodeInboundCrudTests(PnvPanelWebApplicationFactory factory)
         int Port,
         bool IsPublished,
         string? DisplayName,
-        int? MaxClients,
         IReadOnlyList<Guid> AllowedRoleIds
     );
 
@@ -83,7 +82,6 @@ public class NodeInboundCrudTests(PnvPanelWebApplicationFactory factory)
                 isPublished = true,
                 displayName = "Germany (VLESS)",
                 allowedRoleIds = Array.Empty<Guid>(),
-                maxClients = (int?)null,
             }
         );
         Assert.Equal(HttpStatusCode.OK, publishResponse.StatusCode);

backend/tests/PnvPanel.IntegrationTests/Configs/ConfigQuotaTests.cs

@@ -88,7 +88,6 @@ public class ConfigQuotaTests(PnvPanelWebApplicationFactory factory)
                 isPublished = true,
                 displayName = "Quota inbound",
                 allowedRoleIds = new[] { userRole.Id },
-                maxClients = (int?)null,
             }
         );
         Assert.Equal(HttpStatusCode.OK, publishResponse.StatusCode);

docker-compose.yml

@@ -13,6 +13,11 @@ services:
       timeout: 5s
       retries: 10
     restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: '10m'
+        max-file: '3'
 
   app:
     build:
@@ -46,6 +51,11 @@ services:
     ports:
       - '8085:8085'
     restart: unless-stopped
+    logging:
+      driver: json-file
+      options:
+        max-size: '10m'
+        max-file: '3'
 
 volumes:
   pgdata:

docs/api-design.md

@@ -267,7 +267,7 @@ approve/reject над `ActivationRequest`.
 | Метод | Путь                                   | Роль  | Тело запроса                                                              | Тело ответа |
 | ----- | -------------------------------------- | ----- | ---------------------------------------------------------------------------- | ------------- |
 | GET   | `/api/admin/inbounds`                  | admin | query: `nodeId?`                                                             | `InboundDto[]` |
-| PUT   | `/api/admin/inbounds/{id}/publish`     | admin | `{ isPublished, displayName?, allowedRoleIds?, maxClients? }`               | `InboundDto` |
+| PUT   | `/api/admin/inbounds/{id}/publish`     | admin | `{ isPublished, displayName?, allowedRoleIds? }`               | `InboundDto` |
 
 ## Admin — Users & Stats
 

docs/domain-model.md

@@ -63,12 +63,12 @@ AppUser
 | `IsPublished`     | `bool`        | Доступен ли для самообслуживания пользователями            |
 | `AllowedRoleIds`  | `Guid[]`      | Id ролей, которым разрешено создавать конфиги (native PostgreSQL `uuid[]`; не навигация на `AppRole` — тот в Infrastructure/Identity, Domain на него не ссылается) |
 | `DisplayName`     | `string?`     | Витринное имя для пользователя, напр. «Германия (Trojan)»  |
-| `MaxClients`      | `int?`        | Лимит клиентов (null = без лимита)                         |
 | `LastSyncAt`      | `DateTimeOffset?` |                                                        |
 
-Инварианты: конфиг можно создать только если `IsPublished && Node.IsEnabled`, **роль пользователя
+Инварианты: конфиг можно создать только если `IsPublished && Node.IsEnabled && Node.Status !=
-входит в `AllowedRoles`**, и при заданном `MaxClients` он не достигнут. Публикация инбаунда админом
+Offline`, и **роль пользователя входит в `AllowedRoles`**. Публикация инбаунда админом включает
-включает выбор `AllowedRoles` (напр. «Германия (Trojan)» → роли `user`, `vip`).
+выбор `AllowedRoles` (напр. «Германия (Trojan)» → роли `user`, `vip`). Лимита числа клиентов на
+инбаунд нет — квота ограничивается только на уровне пользователя (`AppRole.MaxConfigs`).
 
 > **Пользователю показываем только `DisplayName` + протокол.** Адрес/хост ноды, `RemoteInboundId`,
 > `Port` и прочие детали 3x-ui в пользовательские DTO не попадают (только в админские).

frontend/src/features/admin/inbounds/PublishInboundDialog.tsx

@@ -24,14 +24,13 @@ export function PublishInboundDialog({
   const queryClient = useQueryClient()
   const [isPublished, setIsPublished] = useState(inbound.isPublished)
   const [displayName, setDisplayName] = useState(inbound.displayName ?? inbound.remark)
-  const [maxClients, setMaxClients] = useState(inbound.maxClients?.toString() ?? '')
   const [selectedRoles, setSelectedRoles] = useState<Set<string>>(new Set(inbound.allowedRoleIds))
 
   const rolesQuery = useQuery({ queryKey: ['admin-roles'], queryFn: listRoles, enabled: open })
 
   const mutation = useMutation({
     mutationFn: () =>
-      publishInbound(inbound.id, isPublished, displayName.trim() || undefined, Array.from(selectedRoles), maxClients ? Number(maxClients) : undefined),
+      publishInbound(inbound.id, isPublished, displayName.trim() || undefined, Array.from(selectedRoles)),
     onSuccess: async () => {
       toast.success(t('admin.nodes.publishSaved'))
       await queryClient.invalidateQueries({ queryKey: ['admin-inbounds', inbound.nodeId] })
@@ -74,10 +73,6 @@ export function PublishInboundDialog({
             <Label htmlFor="displayName">{t('admin.nodes.displayName')}</Label>
             <Input id="displayName" value={displayName} onChange={(e) => setDisplayName(e.target.value)} />
           </div>
-          <div className="flex flex-col gap-1.5">
-            <Label htmlFor="maxClients">{t('admin.nodes.maxClients')}</Label>
-            <Input id="maxClients" type="number" min={0} value={maxClients} onChange={(e) => setMaxClients(e.target.value)} />
-          </div>
           <div className="flex flex-col gap-1.5">
             <Label>{t('admin.nodes.allowedRoles')}</Label>
             <div className="flex flex-col gap-1">

frontend/src/features/admin/inbounds/api.ts

@@ -10,10 +10,9 @@ export function publishInbound(
   isPublished: boolean,
   displayName: string | undefined,
   allowedRoleIds: string[],
-  maxClients: number | undefined,
 ) {
   return apiRequest<InboundDto>(`/admin/inbounds/${id}/publish`, {
     method: 'PUT',
-    body: { isPublished, displayName: displayName ?? null, allowedRoleIds, maxClients: maxClients ?? null },
+    body: { isPublished, displayName: displayName ?? null, allowedRoleIds },
   })
 }

frontend/src/shared/api/schema.gen.ts

@@ -1885,8 +1885,6 @@ export interface components {
             port: number | string;
             isPublished: boolean;
             displayName: null | string;
-            /** Format: int32 */
-            maxClients: null | number | string;
             allowedRoleIds: string[];
             /** Format: date-time */
             lastSyncAt: null | string;
@@ -1955,8 +1953,6 @@ export interface components {
             isPublished: boolean;
             displayName: null | string;
             allowedRoleIds: null | string[];
-            /** Format: int32 */
-            maxClients: null | number | string;
         };
         RegisterCommand: {
             userName: string;

frontend/src/shared/api/types.ts

@@ -215,7 +215,6 @@ export type InboundDto = {
   port: number
   isPublished: boolean
   displayName: string | null
-  maxClients: number | null
   allowedRoleIds: string[]
   lastSyncAt: string | null
 }

frontend/src/shared/lib/i18n.ts

@@ -294,7 +294,6 @@ const resources = {
           unpublished: 'Не опубликован',
           publishSaved: 'Настройки публикации сохранены.',
           displayName: 'Отображаемое имя',
-          maxClients: 'Лимит клиентов (необязательно)',
           allowedRoles: 'Доступно ролям',
           isPublishedLabel: 'Опубликовать инбаунд',
           optional: 'необязательно',
@@ -712,7 +711,6 @@ const resources = {
           unpublished: 'Not published',
           publishSaved: 'Publishing settings saved.',
           displayName: 'Display name',
-          maxClients: 'Client limit (optional)',
           allowedRoles: 'Allowed for roles',
           isPublishedLabel: 'Publish inbound',
           optional: 'optional',