+
+
+
+
+
+
+
+
-
-
-
SSH Panel
-
-
-
-
-
+
+ ${r.username}
- ${r.used_users} / ${r.max_users || "∞"}
+ ${r.used_users} / ${r.max_users || "∞"}
${r.expires_at ? fmtDate(r.expires_at) : "—"}
${r.is_active && !expired ? "Active" : expired ? "Expired" : "Suspended"}
" {
+ apiInbound["port"] = float64(10085)
+ changed = true
+ }
+ settings := asObject(apiInbound["settings"])
+ if settings == nil {
+ settings = map[string]interface{}{}
+ apiInbound["settings"] = settings
+ changed = true
+ }
+ if strings.TrimSpace(fmt.Sprint(settings["address"])) == "" || strings.TrimSpace(fmt.Sprint(settings["address"])) == "" {
+ settings["address"] = "127.0.0.1"
+ changed = true
+ }
+ }
+
+ outbounds, _ := raw["outbounds"].([]interface{})
+ if findObjectByTag(outbounds, "api") == nil {
+ outbounds = append(outbounds, map[string]interface{}{"tag": "api", "protocol": "freedom", "settings": map[string]interface{}{}})
+ raw["outbounds"] = outbounds
+ changed = true
+ }
+
+ routing := asObject(raw["routing"])
+ if routing == nil {
+ routing = map[string]interface{}{}
+ raw["routing"] = routing
+ changed = true
+ }
+ rules, _ := routing["rules"].([]interface{})
+ if !hasAPIRoutingRule(rules) {
+ rules = append([]interface{}{map[string]interface{}{"type": "field", "inboundTag": []interface{}{"api"}, "outboundTag": "api"}}, rules...)
+ routing["rules"] = rules
+ changed = true
+ }
+
+ return changed, checkXrayStatsAPIConfig(raw)
+}
+
+func checkXrayStatsAPIConfig(raw map[string]interface{}) xrayStatsConfigCheck {
+ missing := []string{}
+ api := asObject(raw["api"])
+ if api == nil {
+ missing = append(missing, "api.services")
+ } else {
+ services, _ := api["services"].([]interface{})
+ if !sliceHasString(services, "StatsService") {
+ missing = append(missing, "api.services StatsService")
+ }
+ }
+ if asObject(raw["stats"]) == nil {
+ missing = append(missing, "stats")
+ }
+ policy := asObject(raw["policy"])
+ levels := asObject(nil)
+ level0 := asObject(nil)
+ if policy != nil {
+ levels = asObject(policy["levels"])
+ if levels != nil {
+ level0 = asObject(levels["0"])
+ }
+ }
+ if level0 == nil {
+ missing = append(missing, "policy.levels.0")
+ } else {
+ if v, _ := level0["statsUserUplink"].(bool); !v {
+ missing = append(missing, "policy.levels.0.statsUserUplink")
+ }
+ if v, _ := level0["statsUserDownlink"].(bool); !v {
+ missing = append(missing, "policy.levels.0.statsUserDownlink")
+ }
+ }
+
+ inbounds, _ := raw["inbounds"].([]interface{})
+ apiInbound := findObjectByTag(inbounds, "api")
+ if apiInbound == nil {
+ missing = append(missing, "api inbound")
+ }
+ outbounds, _ := raw["outbounds"].([]interface{})
+ if findObjectByTag(outbounds, "api") == nil {
+ missing = append(missing, "api outbound")
+ }
+ routing := asObject(raw["routing"])
+ if routing == nil {
+ missing = append(missing, "routing api rule")
+ } else {
+ rules, _ := routing["rules"].([]interface{})
+ if !hasAPIRoutingRule(rules) {
+ missing = append(missing, "routing api rule")
+ }
+ }
+ return xrayStatsConfigCheck{Configured: len(missing) == 0, Missing: missing, APIServer: discoverAPIServerFromRaw(raw)}
+}
+
+func (m *XrayManager) discoverAPIServerFromRaw(raw map[string]interface{}) string {
+ return discoverAPIServerFromRaw(raw)
+}
+
+func discoverAPIServerFromRaw(raw map[string]interface{}) string {
+ inbounds, _ := raw["inbounds"].([]interface{})
+ for _, item := range inbounds {
+ ib, ok := item.(map[string]interface{})
+ if !ok {
+ continue
+ }
+ tag, _ := ib["tag"].(string)
+ proto, _ := ib["protocol"].(string)
+ if tag != "api" || !strings.EqualFold(proto, "dokodemo-door") {
+ continue
+ }
+ host, _ := ib["listen"].(string)
+ host = strings.TrimSpace(host)
+ if host == "" || host == "0.0.0.0" || host == "::" {
+ host = "127.0.0.1"
+ }
+ port := strings.TrimSpace(fmt.Sprint(ib["port"]))
+ port = strings.Trim(port, `"`)
+ if port == "" || port == "" || port == "null" {
+ continue
+ }
+ return host + ":" + port
+ }
+ return ""
+}
+
+func asObject(v interface{}) map[string]interface{} {
+ m, _ := v.(map[string]interface{})
+ return m
+}
+
+func findObjectByTag(items []interface{}, tag string) map[string]interface{} {
+ for _, item := range items {
+ m, ok := item.(map[string]interface{})
+ if !ok {
+ continue
+ }
+ if t, _ := m["tag"].(string); t == tag {
+ return m
+ }
+ }
+ return nil
+}
+
+func sliceHasString(items []interface{}, want string) bool {
+ for _, item := range items {
+ if s, ok := item.(string); ok && strings.EqualFold(s, want) {
+ return true
+ }
+ }
+ return false
+}
+
+func hasAPIRoutingRule(rules []interface{}) bool {
+ for _, item := range rules {
+ rule, ok := item.(map[string]interface{})
+ if !ok {
+ continue
+ }
+ outbound, _ := rule["outboundTag"].(string)
+ if outbound != "api" {
+ continue
+ }
+ tags, ok := rule["inboundTag"].([]interface{})
+ if !ok {
+ if tag, _ := rule["inboundTag"].(string); tag == "api" {
+ return true
+ }
+ continue
+ }
+ if sliceHasString(tags, "api") {
+ return true
+ }
+ }
+ return false
}
// ---- Admin HTTP handlers ----
@@ -258,8 +903,23 @@ func handleXrayStatus(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
+ status := xrayMgr.Status()
+ if sess := sessionFromCtx(r.Context()); sess != nil && sess.Role == RoleReseller && statsStore != nil {
+ metas, err := statsStore.ListXrayClientsByOwner(r.Context(), sess.Username)
+ if err == nil {
+ status.OnlineUsers = 0
+ window := xrayMgr.onlineWindow()
+ now := time.Now()
+ for _, m := range metas {
+ st, ok := xrayMgr.RuntimeStatsForEmail(m.Email)
+ if ok && !st.LastActive.IsZero() && now.Sub(st.LastActive) <= window {
+ status.OnlineUsers++
+ }
+ }
+ }
+ }
w.Header().Set("Content-Type", "application/json")
- _ = json.NewEncoder(w).Encode(xrayMgr.Status())
+ _ = json.NewEncoder(w).Encode(status)
}
func handleXrayStart(w http.ResponseWriter, r *http.Request) {
@@ -326,6 +986,36 @@ func handleXrayConfig(w http.ResponseWriter, r *http.Request) {
}
}
+func handleXrayRepairStats(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodPost {
+ w.WriteHeader(http.StatusMethodNotAllowed)
+ return
+ }
+ wasRunning := xrayMgr.isRunningSnapshot()
+ changed, err := xrayMgr.EnsureStatsAPIConfig()
+ if err != nil {
+ http.Error(w, err.Error(), http.StatusBadRequest)
+ return
+ }
+ restarted := false
+ if wasRunning {
+ if err := xrayMgr.Restart(); err != nil {
+ http.Error(w, "config repaired but restart failed: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+ restarted = true
+ }
+ check, _ := xrayMgr.CheckStatsAPIConfig()
+ w.Header().Set("Content-Type", "application/json")
+ _ = json.NewEncoder(w).Encode(map[string]interface{}{
+ "changed": changed,
+ "restarted": restarted,
+ "stats_configured": check.Configured,
+ "stats_missing": check.Missing,
+ "api_server": check.APIServer,
+ })
+}
+
func handleXrayLogs(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
w.WriteHeader(http.StatusMethodNotAllowed)
@@ -346,11 +1036,19 @@ type XrayClientInfo struct {
UUID string `json:"id"`
Email string `json:"email"`
Level int `json:"level,omitempty"`
+ // Runtime counters from the Xray stats API. Online means this user's
+ // traffic counters changed inside the configured online window.
+ Online bool `json:"online"`
+ LastActive *time.Time `json:"last_active,omitempty"`
+ UplinkBytes int64 `json:"uplink_bytes,omitempty"`
+ DownlinkBytes int64 `json:"downlink_bytes,omitempty"`
+ TotalBytes int64 `json:"total_bytes,omitempty"`
// Metadata from PostgreSQL (enriched by handleXrayInbounds)
Name string `json:"name,omitempty"`
ExpiresAt *time.Time `json:"expires_at,omitempty"`
ExpirationDays int `json:"expiration_days"`
MaxConns int `json:"max_conns"`
+ OwnerUsername string `json:"owner_username,omitempty"`
Expired bool `json:"expired,omitempty"`
}
@@ -434,6 +1132,9 @@ func (m *XrayManager) modifyRawConfig(fn func(cfg map[string]interface{}) error)
if err := json.Unmarshal(data, &raw); err != nil {
return fmt.Errorf("parse xray config: %w", err)
}
+ if raw == nil {
+ return fmt.Errorf("xray config must be a JSON object")
+ }
if err := fn(raw); err != nil {
return err
}
@@ -449,6 +1150,7 @@ func (m *XrayManager) AddXrayClient(inboundTag, uuid, email string) error {
m.mu.Lock()
defer m.mu.Unlock()
return m.modifyRawConfig(func(raw map[string]interface{}) error {
+ _, _ = ensureXrayStatsAPIConfig(raw)
inbounds, _ := raw["inbounds"].([]interface{})
for _, ib := range inbounds {
ibMap, ok := ib.(map[string]interface{})
@@ -537,26 +1239,51 @@ func handleXrayInbounds(w http.ResponseWriter, r *http.Request) {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
- // Enrich clients with metadata from PostgreSQL when available.
+
+ sess := sessionFromCtx(r.Context())
+ isReseller := sess != nil && sess.Role == RoleReseller
+
+ // Enrich clients with metadata from PostgreSQL when available. Resellers only
+ // see their own Xray clients, but they still see all available inbounds so
+ // they know where they can create new users.
if statsStore != nil {
metas, err := statsStore.ListAllXrayClients(r.Context())
- if err == nil {
+ if err != nil {
+ if isReseller {
+ for i := range inbounds {
+ inbounds[i].Clients = []XrayClientInfo{}
+ }
+ } else {
+ for i := range inbounds {
+ for j := range inbounds[i].Clients {
+ applyXrayRuntimeStats(&inbounds[i].Clients[j])
+ }
+ }
+ }
+ } else {
metaMap := make(map[string]*XrayClientMeta, len(metas))
for _, m := range metas {
metaMap[m.UUID] = m
}
now := time.Now()
for i := range inbounds {
+ filtered := make([]XrayClientInfo, 0, len(inbounds[i].Clients))
for j := range inbounds[i].Clients {
- c := &inbounds[i].Clients[j]
+ c := inbounds[i].Clients[j]
+ applyXrayRuntimeStats(&c)
m, ok := metaMap[c.UUID]
+ if isReseller && (!ok || m.OwnerUsername != sess.Username) {
+ continue
+ }
if !ok {
c.ExpirationDays = -1
+ filtered = append(filtered, c)
continue
}
c.Name = m.Name
c.ExpiresAt = m.ExpiresAt
c.MaxConns = m.MaxConns
+ c.OwnerUsername = m.OwnerUsername
if m.ExpiresAt == nil {
c.ExpirationDays = -1
} else if m.ExpiresAt.Before(now) {
@@ -565,7 +1292,19 @@ func handleXrayInbounds(w http.ResponseWriter, r *http.Request) {
} else {
c.ExpirationDays = int(m.ExpiresAt.Sub(now).Hours() / 24)
}
+ filtered = append(filtered, c)
}
+ inbounds[i].Clients = filtered
+ }
+ }
+ } else if isReseller {
+ for i := range inbounds {
+ inbounds[i].Clients = []XrayClientInfo{}
+ }
+ } else {
+ for i := range inbounds {
+ for j := range inbounds[i].Clients {
+ applyXrayRuntimeStats(&inbounds[i].Clients[j])
}
}
}
@@ -573,6 +1312,26 @@ func handleXrayInbounds(w http.ResponseWriter, r *http.Request) {
_ = json.NewEncoder(w).Encode(inbounds)
}
+func applyXrayRuntimeStats(c *XrayClientInfo) {
+ if c == nil {
+ return
+ }
+ st, ok := xrayMgr.RuntimeStatsForEmail(c.Email)
+ if !ok {
+ return
+ }
+ window := xrayMgr.onlineWindow()
+ now := time.Now()
+ c.UplinkBytes = st.Uplink
+ c.DownlinkBytes = st.Downlink
+ c.TotalBytes = st.Uplink + st.Downlink
+ if !st.LastActive.IsZero() {
+ t := st.LastActive
+ c.LastActive = &t
+ c.Online = now.Sub(st.LastActive) <= window
+ }
+}
+
func handleXrayClientAdd(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
w.WriteHeader(http.StatusMethodNotAllowed)
@@ -594,17 +1353,45 @@ func handleXrayClientAdd(w http.ResponseWriter, r *http.Request) {
http.Error(w, "inbound_tag and uuid required", http.StatusBadRequest)
return
}
+ req.Email = strings.TrimSpace(req.Email)
+ if req.Email == "" {
+ req.Email = strings.TrimSpace(req.Name)
+ }
+ if req.Email == "" {
+ req.Email = req.UUID
+ }
+
+ sess := sessionFromCtx(r.Context())
+ ownerUsername := ""
+ if sess != nil && sess.Role == RoleReseller {
+ ownerUsername = sess.Username
+ if statsStore == nil {
+ http.Error(w, "storage not available", http.StatusInternalServerError)
+ return
+ }
+ owner, ok := adminUsers.get(sess.Username)
+ if !ok || !owner.IsActive || (owner.ExpiresAt != nil && time.Now().After(*owner.ExpiresAt)) {
+ http.Error(w, "reseller account suspended or expired", http.StatusForbidden)
+ return
+ }
+ if owner.MaxUsers > 0 && countOwnedQuota(r.Context(), statsStore, sess.Username) >= owner.MaxUsers {
+ http.Error(w, fmt.Sprintf("user limit reached (%d)", owner.MaxUsers), http.StatusForbidden)
+ return
+ }
+ }
+
if err := xrayMgr.AddXrayClient(req.InboundTag, req.UUID, req.Email); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if statsStore != nil {
meta := XrayClientMeta{
- UUID: req.UUID,
- Name: req.Name,
- Email: req.Email,
- InboundTag: req.InboundTag,
- MaxConns: req.MaxConnections,
+ UUID: req.UUID,
+ Name: req.Name,
+ Email: req.Email,
+ InboundTag: req.InboundTag,
+ OwnerUsername: ownerUsername,
+ MaxConns: req.MaxConnections,
}
if req.ExpiresAt != "" {
var t time.Time
@@ -653,11 +1440,25 @@ func handleXrayClientUpdate(w http.ResponseWriter, r *http.Request) {
http.Error(w, "storage not available", http.StatusInternalServerError)
return
}
+
+ existing, err := statsStore.GetXrayClientMeta(r.Context(), req.UUID)
+ if err != nil {
+ http.Error(w, "client metadata not found", http.StatusNotFound)
+ return
+ }
+ sess := sessionFromCtx(r.Context())
+ if sess != nil && sess.Role == RoleReseller && existing.OwnerUsername != sess.Username {
+ http.Error(w, "forbidden", http.StatusForbidden)
+ return
+ }
+
meta := XrayClientMeta{
- UUID: req.UUID,
- Name: req.Name,
- Email: req.Email,
- MaxConns: req.MaxConnections,
+ UUID: req.UUID,
+ Name: req.Name,
+ Email: req.Email,
+ InboundTag: existing.InboundTag,
+ OwnerUsername: existing.OwnerUsername,
+ MaxConns: req.MaxConnections,
}
if req.ExpiresAt != "" {
for _, layout := range []string{time.RFC3339, "2006-01-02T15:04", "2006-01-02"} {
@@ -685,6 +1486,23 @@ func handleXrayClientRemove(w http.ResponseWriter, r *http.Request) {
http.Error(w, "inbound_tag and uuid required", http.StatusBadRequest)
return
}
+
+ sess := sessionFromCtx(r.Context())
+ if sess != nil && sess.Role == RoleReseller {
+ if statsStore == nil {
+ http.Error(w, "storage not available", http.StatusInternalServerError)
+ return
+ }
+ meta, err := statsStore.GetXrayClientMeta(r.Context(), uuid)
+ if err != nil || meta.OwnerUsername != sess.Username {
+ http.Error(w, "forbidden", http.StatusForbidden)
+ return
+ }
+ if meta.InboundTag != "" {
+ inboundTag = meta.InboundTag
+ }
+ }
+
if err := xrayMgr.RemoveXrayClient(inboundTag, uuid); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
+
+
+
+
+
@@ -314,7 +303,7 @@ html,body{width:100%;max-width:100%;overflow-x:hidden;}
-
-
+
diff --git a/admin_script.js b/admin_script.js
index 64ce1ad..e595009 100644
--- a/admin_script.js
+++ b/admin_script.js
@@ -1,3 +1,4 @@
+
// ─── State ───────────────────────────────────────────────────────────────────
let sessionToken = localStorage.getItem("SESSION_TOKEN") || "";
let currentRole = "";
@@ -18,6 +19,26 @@ const mainApp = document.getElementById("mainApp");
const meUsername = document.getElementById("meUsername");
const roleChip = document.getElementById("roleChip");
const logoutBtn = document.getElementById("logoutBtn");
+const menuToggle = document.getElementById("menuToggle");
+const drawerBackdrop = document.getElementById("drawerBackdrop");
+const themeToggle = document.getElementById("themeToggle");
+const pageTitle = document.getElementById("pageTitle");
+const pageEyebrow = document.getElementById("pageEyebrow");
+const sidebarUsername = document.getElementById("sidebarUsername");
+const sidebarRole = document.getElementById("sidebarRole");
+const dashTotalUsers = document.getElementById("dashTotalUsers");
+const dashActiveUsers = document.getElementById("dashActiveUsers");
+const dashExpiredUsers = document.getElementById("dashExpiredUsers");
+const dashConnections = document.getElementById("dashConnections");
+const dashServers = document.getElementById("dashServers");
+const dashServerStatus = document.getElementById("dashServerStatus");
+const dashXrayClients = document.getElementById("dashXrayClients");
+const dashXrayStatus = document.getElementById("dashXrayStatus");
+const dashQuotaChip = document.getElementById("dashQuotaChip");
+const dashQuotaBar = document.getElementById("dashQuotaBar");
+const dashQuotaText = document.getElementById("dashQuotaText");
+const dashQuotaBreakdown = document.getElementById("dashQuotaBreakdown");
+const dashboardQuotaCard = document.getElementById("dashboardQuotaCard");
// Users
const usersBody = document.getElementById("usersBody");
@@ -153,15 +174,48 @@ function genUUID() {
(c^crypto.getRandomValues(new Uint8Array(1))[0]&15>>c/4).toString(16));
}
-// ─── Tab switching ────────────────────────────────────────────────────────────
-document.querySelectorAll(".tab-btn").forEach(btn => {
- btn.addEventListener("click", () => {
- document.querySelectorAll(".tab-btn").forEach(b => b.classList.remove("active"));
- document.querySelectorAll(".tab-pane").forEach(p => p.classList.remove("active"));
- btn.classList.add("active");
- document.getElementById("tab-" + btn.dataset.tab).classList.add("active");
- });
-});
+// ─── Navigation / shell ──────────────────────────────────────────────────────
+const tabTitles = {
+ dashboard: ["Painel", "Visão geral"],
+ ssh: ["Contas", "SSH / SlowDNS"],
+ xray: ["Contas", "Xray Users"],
+ resellers: ["Administração", "Revendedores"],
+ stats: ["Servidor", "Monitoramento"],
+ vnstat: ["Tráfego", "VnStat"],
+ logs: ["Sistema", "Logs"],
+ server: ["Sistema", "Configurações"],
+};
+
+function selectTab(tab) {
+ const pane = document.getElementById("tab-" + tab);
+ const btn = document.querySelector(`.tab-btn[data-tab="${tab}"]`);
+ if (!pane || !btn) return;
+ document.querySelectorAll(".tab-btn").forEach(b => b.classList.remove("active"));
+ document.querySelectorAll(".tab-pane").forEach(p => p.classList.remove("active"));
+ btn.classList.add("active");
+ pane.classList.add("active");
+ const [eyebrow, title] = tabTitles[tab] || ["Painel", tab];
+ if (pageEyebrow) pageEyebrow.textContent = eyebrow;
+ if (pageTitle) pageTitle.textContent = title;
+ document.body.classList.remove("sidebar-open");
+
+ if (tab === "dashboard") refreshDashboard();
+ if (tab === "xray") {
+ loadXrayStatus();
+ loadInbounds();
+ if (currentRole === "superadmin") loadWizardFromConfig();
+ }
+ if (tab === "stats" && currentRole === "superadmin") loadStats();
+ if (tab === "resellers" && currentRole === "superadmin") loadResellers();
+}
+
+document.querySelectorAll(".tab-btn").forEach(btn => btn.addEventListener("click", () => selectTab(btn.dataset.tab)));
+menuToggle?.addEventListener("click", () => document.body.classList.add("sidebar-open"));
+drawerBackdrop?.addEventListener("click", () => document.body.classList.remove("sidebar-open"));
+themeToggle?.addEventListener("click", () => document.body.classList.toggle("light-mode"));
+document.querySelectorAll(".quick-action[data-jump]").forEach(btn => btn.addEventListener("click", () => selectTab(btn.dataset.jump)));
+document.getElementById("quickCreateUserBtn")?.addEventListener("click", () => { selectTab("ssh"); setFormCollapsed(false); fUsername?.focus(); });
+document.getElementById("quickOpenXrayBtn")?.addEventListener("click", () => selectTab("xray"));
// ─── Login / Logout ───────────────────────────────────────────────────────────
loginBtn.addEventListener("click", doLogin);
@@ -215,31 +269,34 @@ function clearTimers() {
function initAfterLogin() {
meUsername.textContent = currentUser;
+ if (sidebarUsername) sidebarUsername.textContent = currentUser;
+ if (sidebarRole) sidebarRole.textContent = currentRole === "superadmin" ? "Super Admin" : "Revendedor";
roleChip.innerHTML = currentRole === "superadmin"
? `superadmin`
: `reseller`;
- // Show/hide superadmin-only elements
document.querySelectorAll(".superadmin-only").forEach(el => {
el.classList.toggle("hidden", currentRole !== "superadmin");
});
+ document.querySelectorAll(".xray-admin-only").forEach(el => {
+ el.classList.toggle("hidden", currentRole !== "superadmin");
+ });
- // Reset to SSH tab
- document.querySelectorAll(".tab-btn").forEach(b => b.classList.remove("active"));
- document.querySelectorAll(".tab-pane").forEach(p => p.classList.remove("active"));
- document.querySelector("[data-tab='ssh']").classList.add("active");
- document.getElementById("tab-ssh").classList.add("active");
+ resellerInfoCard.classList.toggle("hidden", currentRole !== "reseller");
+ dashboardQuotaCard?.classList.toggle("hidden", currentRole !== "reseller");
+
+ selectTab("dashboard");
if (currentRole === "superadmin") {
loadStats();
statsTimer = setInterval(loadStats, 2000);
- xrayTimer = setInterval(loadXrayStatus, 5000);
} else {
- resellerInfoCard.classList.remove("hidden");
loadMe();
}
+ xrayTimer = setInterval(loadXrayStatus, 7000);
loadUsers();
+ loadInbounds();
usersTimer = setInterval(() => loadUsersSilent(), 3000);
}
@@ -248,13 +305,56 @@ async function loadMe() {
try {
const res = await api("/api/auth/me");
const d = await res.json();
- rUsedMax.textContent = (d.used_users ?? "--") + " / " + (d.max_users || "∞");
+ const used = d.used_users ?? 0;
+ const max = d.max_users || 0;
+ rUsedMax.textContent = used + " / " + (max || "∞");
rExpiry.textContent = d.expires_at ? fmtDate(d.expires_at) : "No limit";
rStatus.textContent = d.is_active ? "Active" : "Suspended";
rStatus.style.color = d.is_active ? "var(--success)" : "var(--danger)";
+ updateQuotaCard(used, max, d.used_ssh_users || 0, d.used_xray_users || 0);
} catch {}
}
+function updateQuotaCard(used, max, sshUsed = 0, xrayUsed = 0) {
+ if (!dashQuotaText) return;
+ const labelMax = max || "∞";
+ dashQuotaChip.textContent = `${used} / ${labelMax}`;
+ dashQuotaText.textContent = max ? `${Math.max(0, max - used)} contas disponíveis` : "Sem limite definido pelo admin";
+ dashQuotaBreakdown.textContent = `SSH ${sshUsed} · Xray ${xrayUsed}`;
+ const pct = max ? Math.min(100, Math.round((used / max) * 100)) : 0;
+ dashQuotaBar.style.width = `${pct}%`;
+}
+
+function updateDashboardFromUsers(users = []) {
+ if (!dashTotalUsers) return;
+ const now = new Date();
+ let active = 0, expired = 0, conns = 0;
+ users.forEach(u => {
+ conns += Number(u.active_conns || 0);
+ if (u.expires_at && new Date(u.expires_at) < now) expired++;
+ else active++;
+ });
+ dashTotalUsers.textContent = users.length;
+ dashActiveUsers.textContent = active;
+ dashExpiredUsers.textContent = expired;
+ dashConnections.textContent = conns;
+}
+
+function updateDashboardXray(inbounds = []) {
+ if (!dashXrayClients) return;
+ const total = inbounds.reduce((sum, ib) => sum + ((ib.clients || []).length), 0);
+ dashXrayClients.textContent = total;
+ const running = xrayChip?.textContent || "--";
+ dashXrayStatus.textContent = `Core: ${running}`;
+}
+
+function refreshDashboard() {
+ loadUsersSilent();
+ loadInbounds();
+ loadXrayStatus();
+ if (currentRole === "reseller") loadMe();
+}
+
// ─── SSH Users ────────────────────────────────────────────────────────────────
document.getElementById("reloadUsersBtn").addEventListener("click", loadUsers);
newUserBtn.addEventListener("click", () => {
@@ -304,6 +404,7 @@ async function loadUsersSilent() {
}
function renderUsers(users) {
+ updateDashboardFromUsers(users);
const isSA = currentRole === "superadmin";
userCountChip.textContent = users.length;
if (isSA) ownerColHead.classList.remove("hidden");
@@ -418,7 +519,9 @@ document.getElementById("xSaveCfgBtn").addEventListener("click", saveXrayCfg);
document.getElementById("xLoadLogsBtn").addEventListener("click", loadXrayLogs);
document.querySelector("[data-tab='xray']")?.addEventListener("click", () => {
- loadXrayStatus(); loadInbounds(); loadWizardFromConfig();
+ loadXrayStatus();
+ loadInbounds();
+ if (currentRole === "superadmin") loadWizardFromConfig();
});
async function loadXrayStatus() {
@@ -432,6 +535,9 @@ async function loadXrayStatus() {
xRunning.style.color = run ? "var(--success)" : "var(--danger)";
xPID.textContent = s.pid || "--";
xUptime.textContent = s.uptime || "--";
+ if (dashServers) dashServers.textContent = s.enabled ? "1" : "0";
+ if (dashServerStatus) dashServerStatus.textContent = run ? "1 online" : (s.enabled ? "parado" : "desativado");
+ if (dashXrayStatus) dashXrayStatus.textContent = `Core: ${xrayChip.textContent}`;
if (s.error) xStatus.textContent = "Error: " + s.error;
} catch (e) { if (e.message==="auth") doAuthError(); }
}
@@ -463,6 +569,7 @@ async function loadInbounds() {
}
function renderInbounds(inbounds) {
+ updateDashboardXray(inbounds);
if (!inbounds.length) {
inboundsContainer.innerHTML = '
+
-
-
-
+
+ Painel operacional
+ Bem-vindo de volta 👋
+Gerencie SSH, Xray, revendedores e servidor em poucos cliques.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Total de contas
+ --
+ -- ativas · -- expiradas
+ SSH -- · Xray --
+
+
+
+
+
+ Conexões ativas
+ --
+ SSH + Xray online agora
+
+
+
+
+
+ Xray clients
+ --
+ Pronto para revendedores
+
+
+
+
+
+
+
+
+ Ações rápidas
+ simples
+
+
+
+
+
+
+
+
+
+ Minha cota
--
+
+
Xray Core --
-
+
+
Status
--
Online
--
PID
--
Uptime
--
Counters API
--
+
Xray Config
@@ -488,7 +477,7 @@ html,body{width:100%;max-width:100%;overflow-x:hidden;}
-
+
@@ -853,1564 +842,13 @@ html,body{width:100%;max-width:100%;overflow-x:hidden;}
+
+
+ Logs last 200 lines
@@ -838,7 +827,7 @@ html,body{width:100%;max-width:100%;overflow-x:hidden;}
- Binary: /opt/sshpanel/xray · Config: /opt/sshpanel/xray_config.json
+ Binary: /opt/sshpanel/xray · Config: /opt/sshpanel/xray_config.json · Online counters use Xray Stats API on 127.0.0.1:10085
No VLESS/VMess/Trojan inbounds found.
';
return;
@@ -694,7 +801,7 @@ function renderResellers(list) {
const tr = document.createElement("tr");
tr.innerHTML = `
SSH ${r.used_ssh_users || 0} · Xray ${r.used_xray_users || 0}