v1.3.2: Custom DNS subdomain, availability check, fixed address UI - Custom subdomain per server with availability validation - Fixed DNS address shown in Dashboard when tunnel active - Editable subdomain with check button - Copy button for DNS address - Worker: added 'check' action endpoint - Backend: new endpoints for subdomain CRUD and availability check

CalaKuad1 · CalaKuad1 · commit 5852b089af31 · 2026-05-28T15:32:38.000+02:00
diff --git a/backend/api_server.py b/backend/api_server.py
@@ -197,6 +197,7 @@ def __init__(self):
         # Tunnel management
         self.tunnel_process: Optional[subprocess.Popen] = None
         self.tunnel_address: Optional[str] = None
+        self.dns_address: Optional[str] = None
 
         # Install Progress Tracking
         self.install_progress: int = 0
@@ -348,6 +349,11 @@ def load_server(self, server_id):
         )
         self.active_handlers[server_id] = new_handler
 
+        # Cargar subdominio DNS personalizado si existe
+        dns_sub = server_config.get("dns_subdomain", "")
+        if dns_sub:
+            new_handler.dns_subdomain = dns_sub
+
         self.config_manager.config["last_selected_id"] = server_id
         self.config_manager.save()
         return server_config
@@ -1706,11 +1712,18 @@ def run_backup():
 
 # --- DNS Proxy Helper ---
 def _get_server_slug(state):
-    """Genera un slug a partir del nombre del servidor para usar como subdominio."""
+    """Genera un slug a partir del subdominio personalizado o nombre del servidor."""
     if not state or not state.server_handler:
         return "minecraft"
-    folder_name = os.path.basename(state.server_handler.server_path.rstrip("/\\"))
-    # Limpiar: solo letras, números, guiones
+    # Primero mirar si el servidor tiene un subdominio personalizado
+    handler = state.server_handler
+    if hasattr(handler, "dns_subdomain") and handler.dns_subdomain:
+        slug = handler.dns_subdomain.strip().lower()
+        slug = "".join(c if c.isalnum() or c in "-" else "-" for c in slug).strip("-")
+        if slug:
+            return slug
+    # Fallback: nombre de la carpeta
+    folder_name = os.path.basename(handler.server_path.rstrip("/\\"))
     slug = "".join(c if c.isalnum() or c in "-_" else "-" for c in folder_name.lower())
     slug = slug.strip("-")
     return slug if slug else "minecraft"
@@ -1750,9 +1763,15 @@ def _update_dns_record_proxy(state):
             },
             timeout=5,
         )
+        state.dns_address = f"{slug}.play.ariser.app"
         state.broadcast_log_sync(
-            f"🌐 DNS updated: {slug} → {state.tunnel_address}", "info"
+            f"🌐 DNS updated: {state.dns_address} → {state.tunnel_address}", "info"
         )
+        state.broadcast_log_sync({
+            "type": "dns_updated",
+            "address": state.dns_address,
+            "target": state.tunnel_address,
+        })
     except Exception as e:
         state.broadcast_log_sync(f"⚠️ DNS update failed: {e}", "warning")
 
@@ -1784,12 +1803,13 @@ def _delete_dns_record_proxy(state):
 @app.get("/tunnel/status")
 def get_tunnel_status():
     if not state:
-        return {"active": False, "address": None}
+        return {"active": False, "address": None, "dns_address": None}
 
     return {
         "active": state.tunnel_process is not None
         and state.tunnel_process.poll() is None,
         "address": state.tunnel_address,
+        "dns_address": state.dns_address,
     }
 
 
@@ -2233,6 +2253,7 @@ def run_tunnel():
                 state.broadcast_log_sync("🔴 Tunnel closed", "warning")
                 state.broadcast_log_sync({"type": "tunnel_disconnected"})
                 state.tunnel_address = None
+                state.dns_address = None
                 # Clean up DNS record
                 _delete_dns_record_proxy(state)
 
@@ -2294,6 +2315,78 @@ def set_tunnel_address(req: SetTunnelAddressRequest):
     return {"status": "success"}
 
 
+# --- DNS Subdomain Endpoints ---
+
+@app.get("/server/dns-subdomain")
+def get_dns_subdomain():
+    if not state or not state.server_handler:
+        return {"subdomain": "", "address": ""}
+    slug = _get_server_slug(state)
+    settings = _get_dns_settings(state)
+    domain = ""
+    if settings["enabled"]:
+        try:
+            app = state.config_manager.config.get("app_settings", {})
+            url = settings["url"]
+            # Extraer dominio del Worker URL o usar variables
+            domain = f"{slug}.play.ariser.app"
+        except Exception:
+            pass
+    return {
+        "subdomain": slug,
+        "address": domain if settings["enabled"] else "",
+        "enabled": settings["enabled"],
+    }
+
+
+@app.post("/server/dns-subdomain")
+async def set_dns_subdomain(request: Request):
+    if not state or not state.server_handler:
+        raise HTTPException(status_code=400, detail="Server not configured")
+    body = await request.json()
+    subdomain = (body.get("subdomain") or "").strip().lower()
+    subdomain = "".join(c if c.isalnum() or c in "-" else "-" for c in subdomain).strip("-")
+
+    if not subdomain:
+        raise HTTPException(status_code=400, detail="Invalid subdomain")
+
+    # Guardar en la config del servidor
+    server_id = state.selected_server_id
+    state.config_manager.update_server(server_id, {"dns_subdomain": subdomain})
+    state.server_handler.dns_subdomain = subdomain
+
+    address = f"{subdomain}.play.ariser.app"
+    return {"subdomain": subdomain, "address": address}
+
+
+@app.post("/server/dns-check")
+async def check_dns_subdomain(request: Request):
+    if not state:
+        raise HTTPException(status_code=500, detail="App state not initialized")
+    body = await request.json()
+    subdomain = (body.get("subdomain") or "").strip().lower()
+    subdomain = "".join(c if c.isalnum() or c in "-" else "-" for c in subdomain).strip("-")
+
+    if not subdomain:
+        return {"available": False, "error": "Invalid subdomain"}
+
+    settings = _get_dns_settings(state)
+    if not settings["url"]:
+        return {"available": True, "note": "No proxy configured"}
+
+    try:
+        import requests as req
+        r = req.post(
+            settings["url"],
+            json={"subdomain": subdomain, "target": "", "action": "check"},
+            timeout=5,
+        )
+        data = r.json()
+        return data
+    except Exception as e:
+        return {"available": True, "note": f"Could not verify: {e}"}
+
+
 # --- Mods Endpoints ---
 @app.get("/mods/search")
 def search_mods(
diff --git a/electron-app/package.json b/electron-app/package.json
@@ -1,7 +1,7 @@
 {
   "name": "minecraft-server-gui",
   "private": true,
-  "version": "1.3.1",
+  "version": "1.3.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/CalaKuad1/Minecraft-Local-Server-GUI.git"
diff --git a/electron-app/src/api.js b/electron-app/src/api.js
@@ -271,6 +271,23 @@ export const api = {
             body: JSON.stringify({ address })
         });
     },
+    getDnsSubdomain: async () => {
+        return await fetchJson(`${API_URL}/server/dns-subdomain`);
+    },
+    setDnsSubdomain: async (subdomain) => {
+        return await fetchJson(`${API_URL}/server/dns-subdomain`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ subdomain })
+        });
+    },
+    checkDnsSubdomain: async (subdomain) => {
+        return await fetchJson(`${API_URL}/server/dns-check`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ subdomain })
+        });
+    },
 
     // --- Mods ---
     searchMods: async (query, loader = 'fabric', version = null, projectType = 'mod', sort = 'downloads', category = null) => {
diff --git a/electron-app/src/components/Dashboard.jsx b/electron-app/src/components/Dashboard.jsx
@@ -370,8 +370,13 @@ export default function Dashboard({ status: serverStatus, onRefresh }) {
                     setTunnelConnecting(false);
                 } else if (!tunnelConnecting && tunnelAddress) {
                     setTunnelAddress(null);
+                    setTunnelConnecting(false);
+                }
+                if (serverStatus.tunnel.dns_address) {
+                    setDnsAddress(serverStatus.tunnel.dns_address);
                 }
             }
+            }
         }
     }, [serverStatus]);
 
@@ -404,6 +409,11 @@ export default function Dashboard({ status: serverStatus, onRefresh }) {
     const [playitClaimLink, setPlayitClaimLink] = useState(null);
     const [history, setHistory] = useState({ cpu: [], ram: [] });
     const [autoRestart, setAutoRestart] = useState(false);
+    const [dnsAddress, setDnsAddress] = useState(null);
+    const [dnsSubdomain, setDnsSubdomain] = useState('');
+    const [dnsEditing, setDnsEditing] = useState(false);
+    const [dnsAvailable, setDnsAvailable] = useState(null);
+    const [dnsChecking, setDnsChecking] = useState(false);
 
     const { isConnected, subscribe, send } = useWebSocket();
     const logsEndRef = useRef(null);
@@ -451,6 +461,11 @@ export default function Dashboard({ status: serverStatus, onRefresh }) {
             return;
         }
 
+        if (item.type === 'dns_updated') {
+            setDnsAddress(item.address);
+            return;
+        }
+
         if (item.message !== undefined || item.level) {
             const msgText = typeof item.message === 'string' ? item.message : JSON.stringify(item.message || '');
 
@@ -477,6 +492,18 @@ export default function Dashboard({ status: serverStatus, onRefresh }) {
         return subscribe('dashboard', handleWsMessage);
     }, [subscribe, handleWsMessage]);
 
+    // Cargar subdominio DNS al montar
+    useEffect(() => {
+        const load = async () => {
+            try {
+                const data = await api.getDnsSubdomain();
+                if (data?.subdomain) setDnsSubdomain(data.subdomain);
+                if (data?.address) setDnsAddress(data.address);
+            } catch (e) {}
+        };
+        load();
+    }, [serverStatus?.server_id]);
+
     // Robust Auto-scroll logs
     useEffect(() => {
         if (logsEndRef.current && !userScrolledUpRef.current) {
@@ -781,6 +808,84 @@ export default function Dashboard({ status: serverStatus, onRefresh }) {
                 </div>
             </div>
 
+            {/* Fixed DNS Address - appears when tunnel is active */}
+            {tunnelAddress && (
+                <div className="flex items-center gap-4 p-4 bg-emerald-500/[0.03] border border-emerald-500/10 rounded-sm relative z-50 backdrop-blur-2xl">
+                    <div className="p-2 rounded-sm border border-emerald-500/20 bg-emerald-500/5 text-emerald-400">
+                        <Globe size={16} />
+                    </div>
+                    <div className="flex-1 min-w-0">
+                        <div className="text-[10px] font-bold text-zinc-500 uppercase tracking-widest leading-none mb-1">
+                            Fixed Address
+                        </div>
+                        {dnsAddress ? (
+                            <div className="flex items-center gap-2">
+                                <span className="text-sm font-mono text-emerald-400 font-bold select-all">{dnsAddress}</span>
+                                <button
+                                    onClick={() => { navigator.clipboard.writeText(dnsAddress); }}
+                                    className="text-[10px] text-zinc-500 hover:text-white px-2 py-0.5 rounded-sm border border-white/5 hover:border-white/20 transition-colors uppercase tracking-wider"
+                                >
+                                    Copy
+                                </button>
+                            </div>
+                        ) : (
+                            <div className="text-sm font-mono text-zinc-500">
+                                Enable "Fixed Address" in Settings to get a permanent domain
+                            </div>
+                        )}
+                    </div>
+                    <div className="flex items-center gap-2 shrink-0">
+                        {dnsEditing ? (
+                            <form onSubmit={async (e) => {
+                                e.preventDefault();
+                                const val = e.target.elements.subdomain.value.trim();
+                                if (!val) return;
+                                setDnsChecking(true);
+                                try {
+                                    const check = await api.checkDnsSubdomain(val);
+                                    if (!check.available) {
+                                        setDnsAvailable(false);
+                                        setDnsChecking(false);
+                                        return;
+                                    }
+                                    const result = await api.setDnsSubdomain(val);
+                                    setDnsSubdomain(result.subdomain);
+                                    setDnsAddress(result.address);
+                                    setDnsEditing(false);
+                                    setDnsAvailable(null);
+                                } catch (err) {
+                                    console.error(err);
+                                }
+                                setDnsChecking(false);
+                            }} className="flex items-center gap-1">
+                                <span className="text-xs text-zinc-500">.play.ariser.app</span>
+                                <input
+                                    name="subdomain"
+                                    defaultValue={dnsSubdomain}
+                                    placeholder="survival"
+                                    className="w-24 bg-black/40 border border-white/10 rounded-sm px-2 py-1 text-xs text-white placeholder-zinc-700 font-mono outline-none focus:border-emerald-500/40"
+                                    autoFocus
+                                />
+                                <button type="submit" disabled={dnsChecking} className="text-[10px] px-2 py-1 bg-emerald-500/10 border border-emerald-500/20 text-emerald-400 rounded-sm hover:bg-emerald-500/20 disabled:opacity-50 uppercase tracking-wider">
+                                    {dnsChecking ? '...' : 'Set'}
+                                </button>
+                                <button type="button" onClick={() => { setDnsEditing(false); setDnsAvailable(null); }} className="text-[10px] px-1 py-1 text-zinc-500 hover:text-white">✕</button>
+                            </form>
+                        ) : (
+                            <button
+                                onClick={() => setDnsEditing(true)}
+                                className="text-[10px] px-2 py-1 text-zinc-500 hover:text-white rounded-sm border border-white/5 hover:border-white/20 transition-colors uppercase tracking-wider"
+                            >
+                                {dnsSubdomain ? dnsSubdomain : 'Customize'}
+                            </button>
+                        )}
+                    </div>
+                    {dnsAvailable === false && (
+                        <div className="text-[10px] text-red-400 absolute -bottom-5 left-0">That name is already taken</div>
+                    )}
+                </div>
+            )}
+
             {/* Stats Grid */}
             <div className="grid grid-cols-1 md:grid-cols-4 gap-5 relative z-10">
                 <StatCard icon={Users} label={t('dashboard.players_online')} value={onlineCount !== undefined ? `${onlineCount}` : '-'} sublabel={`/ ${status.max_players || 20} ${t('status.online')}`} />

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "minecraft-server-gui",`
`3`	`3`	`"private": true,`
`4`		`- "version": "1.3.1",`
	`4`	`+ "version": "1.3.2",`
`5`	`5`	`"repository": {`
`6`	`6`	`"type": "git",`
`7`	`7`	`"url": "https://github.com/CalaKuad1/Minecraft-Local-Server-GUI.git"`