servctl 1.0.0__tar.gz → 1.0.2__tar.gz

{servctl-1.0.0 → servctl-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: servctl
-Version: 1.0.0
+Version: 1.0.2
 Summary: Unprivileged background server and localhost proxy CLI manager
 Author: avevall
 Keywords: cli,devops,dns,doh,ftp,localhost,proxy,server

{servctl-1.0.0 → servctl-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "servctl"
-version = "1.0.0"
+version = "1.0.2"
 description = "Unprivileged background server and localhost proxy CLI manager"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -45,4 +45,4 @@ include = [
     "/man",
     "/README.md",
     "/pyproject.toml",
-]
+]

{servctl-1.0.0 → servctl-1.0.2}/src/servctl/main.py

@@ -6,6 +6,7 @@ Zero external dependencies (Python Standard Library only).
 """
 
 import argparse
+import datetime
 import email
 from email import policy
 import http.server
@@ -14,6 +15,7 @@ import json
 import os
 from pathlib import Path
 import select
+import shutil
 import signal
 import socket
 import socketserver
@@ -37,7 +39,9 @@ KEY_FILE = APP_DIR / "key.pem"
 DEFAULT_PORTS = {
     "web": 8080,
     "websecure": 8443,
-    "ftps": 2121,
+    "webdav": 8088,
+    "ftp": 2121,
+    "ftps": 2122,
     "dns": 5353,
     "proxy": 8888
 }
@@ -50,54 +54,66 @@ def ensure_dirs():
     APP_DIR.mkdir(parents=True, exist_ok=True)
     LOGS_DIR.mkdir(parents=True, exist_ok=True)
 
+def get_local_ip() -> str:
+    """Finds the local network (LAN) IP for other devices on Wi-Fi/Ethernet."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("10.254.254.254", 1))
+        return s.getsockname()[0]
+    except Exception:
+        return "127.0.0.1"
+    finally:
+        s.close()
+
 def get_ssl_context() -> ssl.SSLContext:
-    """Ensures self-signed certificates exist and returns an SSLContext."""
+    """Generates unprivileged local self-signed TLS certificates for encryption."""
     ensure_dirs()
+    lan_ip = get_local_ip()
+
     if not (CERT_FILE.exists() and KEY_FILE.exists()):
+        san_ext = f"subjectAltName=DNS:localhost,IP:127.0.0.1,IP:{lan_ip}"
         cmd = [
             "openssl", "req", "-x509", "-newkey", "rsa:2048",
             "-keyout", str(KEY_FILE), "-out", str(CERT_FILE),
             "-days", "3650", "-nodes",
-            "-subj", "/CN=localhost"
+            "-subj", "/CN=localhost",
+            "-addext", san_ext
         ]
         try:
             subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         except Exception:
-            # Fallback self-signed cert if system openssl command is unavailable
-            fallback_cert = (
-                "-----BEGIN CERTIFICATE-----\n"
-                "MIICpDCCAYwCCQCg/y8U0O9sETANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDDAls\n"
-                "b2NhbGhvc3QwIBcNMjMwMTAxMDAwMDAwWhgPMjEyMzAxMDEMDAwMDAwWjAUMRIw\n"
-                "EAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB\n"
-                "AQDCKqO074bE/X6Ua6Pvx/68xJ3gqUuS7D8FwzTfKk7z2bJp5P+dGZ8sY0fWkP1w\n"
-                "4F9lZ+LpC2zN6L7p0l7g0aJ+ZqM6k7Y1d0r1Jk8r0vO2w3eE2lFpD6mRk+X8c2eP\n"
-                "AgMBAAEwDQYJKoZIhvcNAQELBQADggEBAJ5p5F8j8p1wF8r2t6n4m7u3p6L7k8f1\n"
-                "-----END CERTIFICATE-----\n"
-            )
-            fallback_key = (
-                "-----BEGIN PRIVATE KEY-----\n"
-                "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDCKqO074bE/X6U\n"
-                "a6Pvx/68xJ3gqUuS7D8FwzTfKk7z2bJp5P+dGZ8sY0fWkP1w4F9lZ+LpC2zN6L7p\n"
-                "-----END PRIVATE KEY-----\n"
-            )
-            CERT_FILE.write_text(fallback_cert)
-            KEY_FILE.write_text(fallback_key)
+            cmd_basic = [
+                "openssl", "req", "-x509", "-newkey", "rsa:2048",
+                "-keyout", str(KEY_FILE), "-out", str(CERT_FILE),
+                "-days", "3650", "-nodes",
+                "-subj", "/CN=localhost"
+            ]
+            try:
+                subprocess.run(cmd_basic, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            except Exception:
+                fallback_cert = (
+                    "-----BEGIN CERTIFICATE-----\n"
+                    "MIICpDCCAYwCCQCg/y8U0O9sETANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDDAls\n"
+                    "b2NhbGhvc3QwIBcNMjMwMTAxMDAwMDAwWhgPMjEyMzAxMDEMDAwMDAwWjAUMRIw\n"
+                    "EAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB\n"
+                    "AQDCKqO074bE/X6Ua6Pvx/68xJ3gqUuS7D8FwzTfKk7z2bJp5P+dGZ8sY0fWkP1w\n"
+                    "4F9lZ+LpC2zN6L7p0l7g0aJ+ZqM6k7Y1d0r1Jk8r0vO2w3eE2lFpD6mRk+X8c2eP\n"
+                    "AgMBAAEwDQYJKoZIhvcNAQELBQADggEBAJ5p5F8j8p1wF8r2t6n4m7u3p6L7k8f1\n"
+                    "-----END CERTIFICATE-----\n"
+                )
+                fallback_key = (
+                    "-----BEGIN PRIVATE KEY-----\n"
+                    "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDCKqO074bE/X6U\n"
+                    "a6Pvx/68xJ3gqUuS7D8FwzTfKk7z2bJp5P+dGZ8sY0fWkP1w4F9lZ+LpC2zN6L7p\n"
+                    "-----END PRIVATE KEY-----\n"
+                )
+                CERT_FILE.write_text(fallback_cert)
+                KEY_FILE.write_text(fallback_key)
 
     ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
     ctx.load_cert_chain(certfile=str(CERT_FILE), keyfile=str(KEY_FILE))
     return ctx
 
-def get_local_ip() -> str:
-    """Finds the local network (LAN) IP for other devices on Wi-Fi/Ethernet."""
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    try:
-        s.connect(("10.254.254.254", 1))
-        return s.getsockname()[0]
-    except Exception:
-        return "127.0.0.1"
-    finally:
-        s.close()
-
 def is_port_in_use(port: int, host: str = "127.0.0.1", udp: bool = False) -> bool:
     sock_type = socket.SOCK_DGRAM if udp else socket.SOCK_STREAM
     with socket.socket(socket.AF_INET, sock_type) as s:
@@ -154,6 +170,116 @@ def format_uptime(seconds: float) -> str:
     d, h = divmod(h, 24)
     return f"{d}d {h}h"
 
+def get_protocol(srv_type: str) -> str:
+    if srv_type in ("websecure", "https"):
+        return "https"
+    elif srv_type == "ftps":
+        return "ftps"
+    elif srv_type == "ftp":
+        return "ftp"
+    elif srv_type == "dns":
+        return "dns"
+    return "http"
+
+# ---------------------------------------------------------------------------
+# Background Process Manager (Spawn & Stop Helpers)
+# ---------------------------------------------------------------------------
+
+def spawn_server(srv_id: str, srv_type: str, port: int, host: str, root_path: str, target: str = None):
+    ensure_dirs()
+    log_path = LOGS_DIR / f"{srv_id}.log"
+    log_fd = open(log_path, "a")
+
+    main_file = str(Path(__file__).resolve())
+    pkg_root = str(Path(__file__).resolve().parent.parent)
+    env = os.environ.copy()
+    env["PYTHONPATH"] = os.pathsep.join(filter(None, [pkg_root, env.get("PYTHONPATH", "")]))
+
+    cmd = [
+        sys.executable,
+        main_file,
+        "_worker",
+        "--id", srv_id,
+        "--type", srv_type,
+        "--port", str(port),
+        "--host", host,
+        "--root", str(root_path),
+    ]
+    if target:
+        cmd.extend(["--target", target])
+
+    kwargs = {
+        "stdout": log_fd,
+        "stderr": log_fd,
+        "stdin": subprocess.DEVNULL,
+        "cwd": str(root_path),
+        "env": env
+    }
+    if os.name == "nt":
+        kwargs["creationflags"] = subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        kwargs["start_new_session"] = True
+
+    proc = subprocess.Popen(cmd, **kwargs)
+    time.sleep(0.4)
+
+    if proc.poll() is not None:
+        log_fd.close()
+        return None, log_path
+
+    return proc.pid, log_path
+
+def stop_server_by_id(srv_id: str, reg: dict) -> bool:
+    meta = reg.pop(srv_id, None)
+    if not meta:
+        return False
+    pid = meta["pid"]
+    if is_pid_running(pid):
+        try:
+            os.kill(pid, signal.SIGTERM)
+            for _ in range(15):
+                if not is_pid_running(pid):
+                    break
+                time.sleep(0.1)
+            if is_pid_running(pid):
+                os.kill(pid, signal.SIGKILL)
+        except OSError:
+            pass
+    write_registry(reg)
+    return True
+
+def print_server_status_card(meta: dict, lan_ip: str = None):
+    if not lan_ip:
+        lan_ip = get_local_ip()
+
+    canonical_type = meta["type"]
+    is_udp = (canonical_type == "dns")
+    protocol = get_protocol(canonical_type)
+    port = meta["port"]
+    local_url = f"{protocol}://127.0.0.1:{port}"
+    lan_url = f"{protocol}://{lan_ip}:{port}"
+    uptime = format_uptime(time.time() - meta["started_at"])
+
+    print("─" * 66)
+    print(f"  Server ID:      {meta['id']}")
+    print(f"  PID:            {meta['pid']}")
+    print(f"  Type:           {canonical_type}")
+    print(f"  Status:         Active (Uptime: {uptime})")
+    print(f"  Port:           {port} ({'UDP' if is_udp else 'TCP'})")
+    print(f"  Access Scope:   {meta['access']} ({'This device only' if meta['access'] == 'local' else 'LAN Sharing Enabled'})")
+    print(f"  This Device:    {local_url}")
+    if meta['access'] == "network":
+        print(f"  Other Devices:  {lan_url}  <-- Open on phone, tablet, etc.")
+    else:
+        print(f"  Other Devices:  [Localhost Only] Re-run with '-a network' to access via {lan_url}")
+    print(f"  LAN IP Address: {lan_ip}")
+    if canonical_type in ("web", "websecure", "ftp", "ftps", "webdav"):
+        print(f"  Root Dir:       {meta['root']}")
+    if meta.get("target"):
+        print(f"  Target:         {meta['target']}")
+    print(f"  Log File:       {meta['log_file']}")
+    print("─" * 66)
+
 # ---------------------------------------------------------------------------
 # 1. DNS Resolver Engine (Cloudflare DoH 1.1.1.1)
 # ---------------------------------------------------------------------------
@@ -276,15 +402,16 @@ class DNSUDPHandler(socketserver.BaseRequestHandler):
         print(f"[{time.strftime('%X')}] [DNS] Query: {domain} -> {resolved_ip}")
 
 # ---------------------------------------------------------------------------
-# 2. RFC 4217 Explicit FTPS (TLS Encrypted FTP Server)
+# 2. Unified FTP & FTPS Server (Plaintext & Explicit TLS)
 # ---------------------------------------------------------------------------
 
-class FTPSClientSession(threading.Thread):
-    def __init__(self, conn, addr, root_dir, ssl_ctx):
+class FTPClientSession(threading.Thread):
+    def __init__(self, conn, addr, root_dir, require_tls=False, ssl_ctx=None):
         super().__init__(daemon=True)
         self.conn = conn
         self.addr = addr
         self.root_dir = os.path.realpath(root_dir)
+        self.require_tls = require_tls
         self.ssl_ctx = ssl_ctx
         self.cwd = "/"
         self.pasv_sock = None
@@ -320,7 +447,7 @@ class FTPSClientSession(threading.Thread):
             self.pasv_sock.close()
             self.pasv_sock = None
 
-        if self.prot == "P" and self.is_tls:
+        if self.prot == "P" and self.is_tls and self.ssl_ctx:
             try:
                 return self.ssl_ctx.wrap_socket(raw_conn, server_side=True)
             except Exception:
@@ -340,7 +467,8 @@ class FTPSClientSession(threading.Thread):
             pass
 
     def run(self):
-        self.send_resp(220, "servctl FTPS Ready (Explicit TLS Required).")
+        mode_label = "FTPS Ready (TLS Required)" if self.require_tls else "FTP Ready (Plaintext)"
+        self.send_resp(220, f"servctl {mode_label}.")
         f = self.conn.makefile("r", encoding="latin-1", errors="replace")
         try:
             while True:
@@ -355,7 +483,10 @@ class FTPSClientSession(threading.Thread):
                 arg = parts[1].strip() if len(parts) > 1 else ""
 
                 if cmd == "AUTH" and arg.upper() in ("TLS", "SSL"):
-                    self.send_resp(234, "AUTH TLS successful. Proceed with TLS handshake.")
+                    if not self.ssl_ctx:
+                        self.send_resp(502, "TLS support not enabled on this port.")
+                        continue
+                    self.send_resp(234, "AUTH TLS successful. Negotiating TLS.")
                     try:
                         self.conn = self.ssl_ctx.wrap_socket(self.conn, server_side=True)
                         f = self.conn.makefile("r", encoding="latin-1", errors="replace")
@@ -370,25 +501,28 @@ class FTPSClientSession(threading.Thread):
                 elif cmd == "PROT":
                     if arg.upper() in ("P", "C"):
                         self.prot = arg.upper()
-                        self.send_resp(200, f"Data protection level set to {self.prot}.")
+                        self.send_resp(200, f"Data protection set to {self.prot}.")
                     else:
                         self.send_resp(504, "Unsupported protection level.")
 
-                elif cmd in ("USER", "PASS") and not self.is_tls:
+                elif cmd in ("USER", "PASS") and self.require_tls and not self.is_tls:
                     self.send_resp(530, "TLS Required. Please send AUTH TLS first.")
 
                 elif cmd == "USER":
-                    self.send_resp(331, "Any password accepted.")
+                    self.send_resp(331, "Password required.")
 
                 elif cmd == "PASS":
-                    self.send_resp(230, "Logged in securely via TLS.")
+                    self.send_resp(230, "Logged in.")
 
                 elif cmd == "SYST":
                     self.send_resp(215, "UNIX Type: L8")
 
                 elif cmd == "FEAT":
-                    feat = "211-Features:\r\n AUTH TLS\r\n PBSZ\r\n PROT\r\n PASV\r\n EPSV\r\n UTF8\r\n SIZE\r\n211 End"
-                    self.conn.sendall(feat.encode("utf-8") + b"\r\n")
+                    features = ["211-Features:"]
+                    if self.ssl_ctx:
+                        features.extend([" AUTH TLS", " PBSZ", " PROT"])
+                    features.extend([" PASV", " EPSV", " UTF8", " SIZE", "211 End"])
+                    self.conn.sendall(("\r\n".join(features) + "\r\n").encode("utf-8"))
 
                 elif cmd == "PWD":
                     self.send_resp(257, f'"{self.cwd}" is current directory.')
@@ -535,22 +669,180 @@ class FTPSClientSession(threading.Thread):
             if self.pasv_sock:
                 self.pasv_sock.close()
 
-def start_ftps_server(host, port, root_dir):
-    ssl_ctx = get_ssl_context()
+def start_ftp_server(host, port, root_dir, require_tls=False):
+    ssl_ctx = get_ssl_context() if require_tls else None
     srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     srv.bind((host, port))
     srv.listen(10)
-    print(f"[{time.strftime('%X')}] FTPS server (TLS) listening on {host}:{port} (Root: {root_dir})")
+    mode = "FTPS (TLS Required)" if require_tls else "FTP (Plaintext)"
+    print(f"[{time.strftime('%X')}] {mode} server listening on {host}:{port} (Root: {root_dir})")
     while True:
         try:
             conn, addr = srv.accept()
-            FTPSClientSession(conn, addr, root_dir, ssl_ctx).start()
+            FTPClientSession(conn, addr, root_dir, require_tls=require_tls, ssl_ctx=ssl_ctx).start()
         except Exception:
             break
 
 # ---------------------------------------------------------------------------
-# 3. Web & Proxy Server Handlers
+# 3. WebDAV Server (Native OS-Mountable Network Drive - RFC 4918)
+# ---------------------------------------------------------------------------
+
+class WebDAVHandler(http.server.SimpleHTTPRequestHandler):
+    def __init__(self, *args, directory=None, **kwargs):
+        self.root_dir = os.path.realpath(directory)
+        super().__init__(*args, directory=directory, **kwargs)
+
+    def _safe_path(self, path):
+        clean = urllib.parse.urlsplit(path).path.lstrip("/")
+        full = os.path.realpath(os.path.join(self.root_dir, clean))
+        if full == self.root_dir or full.startswith(self.root_dir + os.sep):
+            return full
+        return None
+
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self.send_header("DAV", "1, 2")
+        self.send_header("MS-Author-Via", "DAV")
+        self.send_header("Allow", "OPTIONS, GET, HEAD, PUT, DELETE, PROPFIND, MKCOL, MOVE, COPY, LOCK, UNLOCK")
+        self.end_headers()
+
+    def do_PROPFIND(self):
+        target = self._safe_path(self.path)
+        if not target or not os.path.exists(target):
+            self.send_error(404, "Not Found")
+            return
+
+        entries = []
+        is_dir = os.path.isdir(target)
+        req_clean = self.path.rstrip("/") + ("/" if is_dir else "")
+        entries.append((req_clean, is_dir, os.path.getsize(target) if not is_dir else 0, os.path.getmtime(target)))
+
+        if is_dir:
+            try:
+                for item in sorted(os.listdir(target)):
+                    full = os.path.join(target, item)
+                    item_is_dir = os.path.isdir(full)
+                    item_url = self.path.rstrip("/") + "/" + urllib.parse.quote(item) + ("/" if item_is_dir else "")
+                    sz = os.path.getsize(full) if not item_is_dir else 0
+                    mt = os.path.getmtime(full)
+                    entries.append((item_url, item_is_dir, sz, mt))
+            except Exception:
+                pass
+
+        xml = ['<?xml version="1.0" encoding="utf-8" ?>', '<D:multistatus xmlns:D="DAV:">']
+        for url, d, size, mtime in entries:
+            dt_str = datetime.datetime.fromtimestamp(mtime, tz=datetime.timezone.utc).strftime("%a, %d %b %Y %H:%M:%S GMT")
+            res_type = "<D:collection/>" if d else ""
+            xml.append(f"""  <D:response>
+    <D:href>{url}</D:href>
+    <D:propstat>
+      <D:prop>
+        <D:resourcetype>{res_type}</D:resourcetype>
+        <D:getcontentlength>{size}</D:getcontentlength>
+        <D:getlastmodified>{dt_str}</D:getlastmodified>
+      </D:prop>
+      <D:status>HTTP/1.1 200 OK</D:status>
+    </D:propstat>
+  </D:response>""")
+        xml.append('</D:multistatus>')
+        xml_data = "\n".join(xml).encode("utf-8")
+
+        self.send_response(207)
+        self.send_header("Content-Type", 'application/xml; charset="utf-8"')
+        self.send_header("Content-Length", str(len(xml_data)))
+        self.end_headers()
+        self.wfile.write(xml_data)
+
+    def do_PUT(self):
+        target = self._safe_path(self.path)
+        if not target:
+            self.send_error(403, "Forbidden")
+            return
+        length = int(self.headers.get("Content-Length", 0))
+        exists = os.path.exists(target)
+        try:
+            with open(target, "wb") as f:
+                if length > 0:
+                    f.write(self.rfile.read(length))
+            self.send_response(204 if exists else 201)
+        except Exception as e:
+            self.send_error(500, f"Write error: {e}")
+        self.end_headers()
+
+    def do_MKCOL(self):
+        target = self._safe_path(self.path)
+        if not target or os.path.exists(target):
+            self.send_error(405, "Already exists")
+            return
+        try:
+            os.makedirs(target, exist_ok=True)
+            self.send_response(201, "Created")
+        except Exception as e:
+            self.send_error(500, str(e))
+        self.end_headers()
+
+    def do_DELETE(self):
+        target = self._safe_path(self.path)
+        if not target or not os.path.exists(target):
+            self.send_error(404, "Not Found")
+            return
+        try:
+            if os.path.isdir(target):
+                shutil.rmtree(target)
+            else:
+                os.remove(target)
+            self.send_response(204)
+        except Exception as e:
+            self.send_error(500, str(e))
+        self.end_headers()
+
+    def do_MOVE(self):
+        src = self._safe_path(self.path)
+        dest_hdr = self.headers.get("Destination")
+        if not src or not dest_hdr:
+            self.send_error(400, "Bad Request")
+            return
+        dest_path = urllib.parse.urlsplit(dest_hdr).path
+        dst = self._safe_path(dest_path)
+        if not dst:
+            self.send_error(403, "Forbidden")
+            return
+        try:
+            shutil.move(src, dst)
+            self.send_response(201)
+        except Exception as e:
+            self.send_error(500, str(e))
+        self.end_headers()
+
+    def do_LOCK(self):
+        xml = f"""<?xml version="1.0" encoding="utf-8" ?>
+<D:prop xmlns:D="DAV:">
+  <D:lockdiscovery>
+    <D:activelock>
+      <D:locktype><D:write/></D:locktype>
+      <D:lockscope><D:exclusive/></D:lockscope>
+      <D:depth>0</D:depth>
+      <D:owner><D:href>servctl</D:href></D:owner>
+      <D:timeout>Second-3600</D:timeout>
+      <D:locktoken><D:href>urn:uuid:servctl-lock-token</D:href></D:locktoken>
+      <D:lockroot><D:href>{self.path}</D:href></D:lockroot>
+    </D:activelock>
+  </D:lockdiscovery>
+</D:prop>""".encode("utf-8")
+        self.send_response(200)
+        self.send_header("Content-Type", 'application/xml; charset="utf-8"')
+        self.send_header("Lock-Token", "<urn:uuid:servctl-lock-token>")
+        self.send_header("Content-Length", str(len(xml)))
+        self.end_headers()
+        self.wfile.write(xml)
+
+    def do_UNLOCK(self):
+        self.send_response(204)
+        self.end_headers()
+
+# ---------------------------------------------------------------------------
+# 4. Web & Proxy Server Handlers
 # ---------------------------------------------------------------------------
 
 class DefaultWebHandler(http.server.SimpleHTTPRequestHandler):
@@ -654,8 +946,19 @@ def run_worker(args):
     if root.is_dir():
         os.chdir(root)
 
-    if srv_type in ("ftp", "ftps", "fileshare"):
-        start_ftps_server(host, port, str(root))
+    if srv_type == "ftp":
+        start_ftp_server(host, port, str(root), require_tls=False)
+
+    elif srv_type == "ftps":
+        start_ftp_server(host, port, str(root), require_tls=True)
+
+    elif srv_type == "webdav":
+        class ThreadedHTTPServer(http.server.ThreadingHTTPServer):
+            allow_reuse_address = True
+        handler = lambda *hargs, **hkwargs: WebDAVHandler(*hargs, directory=str(root), **hkwargs)
+        server = ThreadedHTTPServer((host, port), handler)
+        print(f"[{time.strftime('%X')}] WebDAV server running on {host}:{port} (Root: {root})")
+        server.serve_forever()
 
     elif srv_type in ("websecure", "https"):
         class ThreadedHTTPServer(http.server.ThreadingHTTPServer):
@@ -667,7 +970,7 @@ def run_worker(args):
         print(f"[{time.strftime('%X')}] Secure HTTPS Web Server running on {host}:{port} (Root: {root})")
         server.serve_forever()
 
-    elif srv_type in ("web", "website"):
+    elif srv_type == "web":
         class ThreadedHTTPServer(http.server.ThreadingHTTPServer):
             allow_reuse_address = True
         handler = lambda *hargs, **hkwargs: DefaultWebHandler(*hargs, directory=str(root), **hkwargs)
@@ -698,16 +1001,7 @@ def run_worker(args):
 def cmd_start(args):
     clean_registry()
 
-    # Canonical type mapping
-    if args.type in ("websecure", "https"):
-        canonical_type = "websecure"
-    elif args.type in ("ftp", "ftps", "fileshare"):
-        canonical_type = "ftps"
-    elif args.type in ("web", "website"):
-        canonical_type = "web"
-    else:
-        canonical_type = args.type
-
+    canonical_type = "websecure" if args.type in ("websecure", "https") else args.type
     port = args.port or DEFAULT_PORTS.get(canonical_type, 8080)
     host = "0.0.0.0" if args.access == "network" else "127.0.0.1"
     is_udp = (canonical_type == "dns")
@@ -720,7 +1014,7 @@ def cmd_start(args):
     raw_root = args.root or args.path or "."
     root_path = Path(raw_root).expanduser().resolve()
 
-    if canonical_type in ("web", "websecure", "ftps") and not root_path.is_dir():
+    if canonical_type in ("web", "websecure", "ftp", "ftps", "webdav") and not root_path.is_dir():
         print(f"Error: Directory '{root_path}' does not exist.")
         sys.exit(1)
 
@@ -729,45 +1023,9 @@ def cmd_start(args):
         sys.exit(1)
 
     srv_id = args.name or f"{canonical_type}-{port}"
-    ensure_dirs()
-    log_path = LOGS_DIR / f"{srv_id}.log"
-    log_fd = open(log_path, "a")
-
-    main_file = str(Path(__file__).resolve())
-    pkg_root = str(Path(__file__).resolve().parent.parent)
-    env = os.environ.copy()
-    env["PYTHONPATH"] = os.pathsep.join(filter(None, [pkg_root, env.get("PYTHONPATH", "")]))
-
-    cmd = [
-        sys.executable,
-        main_file,
-        "_worker",
-        "--id", srv_id,
-        "--type", canonical_type,
-        "--port", str(port),
-        "--host", host,
-        "--root", str(root_path),
-    ]
-    if args.target:
-        cmd.extend(["--target", args.target])
-
-    kwargs = {
-        "stdout": log_fd,
-        "stderr": log_fd,
-        "stdin": subprocess.DEVNULL,
-        "cwd": str(root_path),
-        "env": env
-    }
-    if os.name == "nt":
-        kwargs["creationflags"] = subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
-    else:
-        kwargs["start_new_session"] = True
-
-    proc = subprocess.Popen(cmd, **kwargs)
-    time.sleep(0.4)
+    pid, log_path = spawn_server(srv_id, canonical_type, port, host, str(root_path), args.target)
 
-    if proc.poll() is not None:
-        log_fd.close()
+    if not pid:
         print(f"Error: Server failed to start. Log contents ({log_path}):")
         with open(log_path) as f:
             print(f.read())
@@ -782,56 +1040,32 @@ def cmd_start(args):
         "access": args.access,
         "root": str(root_path),
         "target": args.target,
-        "pid": proc.pid,
+        "pid": pid,
         "started_at": time.time(),
         "log_file": str(log_path)
     }
     write_registry(reg)
 
-    lan_ip = get_local_ip()
-    if canonical_type == "websecure":
-        protocol = "https"
-    elif canonical_type == "ftps":
-        protocol = "ftps"
-    elif canonical_type == "dns":
-        protocol = "dns"
-    else:
-        protocol = "http"
-
-    local_url = f"{protocol}://127.0.0.1:{port}"
-    lan_url = f"{protocol}://{lan_ip}:{port}"
-
     type_label = "SECURE HTTPS WEB" if canonical_type == "websecure" else canonical_type.upper()
     print(f"\n✔ Successfully started {type_label} server in background!")
-    print("─" * 66)
-    print(f"  Server ID:      {srv_id}")
-    print(f"  PID:            {proc.pid}")
-    print(f"  Type:           {canonical_type}")
-    print(f"  Port:           {port} ({'UDP' if is_udp else 'TCP'})")
-    print(f"  Access Scope:   {args.access} ({'This device only' if args.access == 'local' else 'LAN Sharing Enabled'})")
-    print(f"  This Device:    {local_url}")
-    if args.access == "network":
-        print(f"  Other Devices:  {lan_url}  <-- Open this on phone, tablet, etc.")
-    else:
-        print(f"  Other Devices:  [Localhost Only] Re-run with '-a network' to access via {lan_url}")
-    print(f"  LAN IP Address: {lan_ip}")
-    if canonical_type in ("web", "websecure", "ftps"):
-        print(f"  Root Dir:       {root_path}")
-    if args.target:
-        print(f"  Target:         {args.target}")
-    print(f"  Log File:       {log_path}")
-    print("─" * 66)
-    if canonical_type == "ftps":
-        connect_host = lan_ip if args.access == "network" else "127.0.0.1"
+    print_server_status_card(reg[srv_id])
+
+    connect_host = get_local_ip() if args.access == "network" else "127.0.0.1"
+    if canonical_type == "webdav":
+        print("  Mount as a Native Network Drive:")
+        print(f"    macOS Finder:     Finder -> Go -> Connect to Server -> http://{connect_host}:{port}")
+        print(f"    Windows Explorer: Map Network Drive -> http://{connect_host}:{port}")
+    elif canonical_type == "ftps":
         print("  Client Connection:")
         print(f"    curl --ssl -k ftp://{connect_host}:{port}/")
         print("    FileZilla / Cyberduck: Require explicit FTP over TLS")
-    elif canonical_type == "websecure":
-        print("  HTTPS Self-Signed Certificate:")
-        print("    Accept the certificate warning in your browser upon first visit.")
-        print(f"    curl -k {local_url}")
-    print(f"  Logs: servctl logs {srv_id}")
-    print(f"  Stop: servctl stop {srv_id}\n")
+    elif canonical_type == "ftp":
+        print("  Client Connection:")
+        print(f"    ftp {connect_host} {port}")
+        print(f"    curl ftp://{connect_host}:{port}/")
+    print(f"  Logs:   servctl logs {srv_id}")
+    print(f"  Status: servctl status show {srv_id}")
+    print(f"  Stop:   servctl stop {srv_id}\n")
 
 def cmd_stop(args):
     reg = read_registry()
@@ -861,57 +1095,24 @@ def cmd_stop(args):
         return
 
     for sid in to_stop_ids:
-        meta = reg.pop(sid, None)
-        if not meta:
-            continue
-        pid = meta["pid"]
-        if is_pid_running(pid):
-            try:
-                os.kill(pid, signal.SIGTERM)
-                for _ in range(15):
-                    if not is_pid_running(pid):
-                        break
-                    time.sleep(0.1)
-                if is_pid_running(pid):
-                    os.kill(pid, signal.SIGKILL)
-            except OSError:
-                pass
-            print(f"✔ Stopped server '{sid}' (PID: {pid}).")
+        meta = reg.get(sid)
+        if meta and stop_server_by_id(sid, reg):
+            print(f"✔ Stopped server '{sid}' (PID: {meta['pid']}).")
         else:
             print(f"Server '{sid}' was already inactive.")
 
-    write_registry(reg)
-
 def cmd_list(args):
+    """Concise process summary: port and name of the process."""
     reg = clean_registry()
     if not reg:
         print("No servers running. Start one using: servctl start")
         return
 
-    lan_ip = get_local_ip()
-    headers = ["ID", "TYPE", "PORT", "THIS DEVICE", "OTHER DEVICES (LAN IP)", "ROOT / TARGET", "PID", "UPTIME"]
+    headers = ["ID", "PORT", "TYPE", "PID", "UPTIME"]
     rows = []
     for sid, m in reg.items():
         uptime = format_uptime(time.time() - m["started_at"])
-        if m["type"] in ("websecure", "https"):
-            protocol = "https"
-        elif m["type"] in ("ftp", "ftps"):
-            protocol = "ftps"
-        elif m["type"] == "dns":
-            protocol = "dns"
-        else:
-            protocol = "http"
-
-        local_url = f"{protocol}://127.0.0.1:{m['port']}"
-        if m.get("access") == "network":
-            other_dev = f"{protocol}://{lan_ip}:{m['port']}"
-        else:
-            other_dev = f"Local only (LAN: {lan_ip})"
-
-        dest = m.get("target") or m.get("root") or "-"
-        if len(dest) > 22:
-            dest = "..." + dest[-19:]
-        rows.append([sid, m["type"], str(m["port"]), local_url, other_dev, dest, str(m["pid"]), uptime])
+        rows.append([sid, str(m["port"]), m["type"], str(m["pid"]), uptime])
 
     widths = [len(h) for h in headers]
     for row in rows:
@@ -927,7 +1128,131 @@ def cmd_list(args):
     print(sep)
     for row in rows:
         print("| " + " | ".join(row[i].ljust(widths[i]) for i in range(len(headers))) + " |")
-    print(sep + "\n")
+    print(sep)
+    print("Tip: Run 'servctl status show <ID>' to view full connection URLs and configuration.\n")
+
+def cmd_status_show(args):
+    reg = clean_registry()
+    if not reg:
+        print("No servers running. Start one using: servctl start")
+        return
+
+    lan_ip = get_local_ip()
+
+    if getattr(args, "all", False) or not getattr(args, "target", None):
+        print("\nDetailed Server Configurations & Status:")
+        for sid, meta in reg.items():
+            print_server_status_card(meta, lan_ip)
+        print()
+    else:
+        matched = False
+        for sid, meta in reg.items():
+            if sid == args.target or str(meta["port"]) == args.target:
+                print(f"\nConfiguration & Runtime for '{sid}':")
+                print_server_status_card(meta, lan_ip)
+                print()
+                matched = True
+                break
+        if not matched:
+            print(f"Error: No running server matching '{args.target}'.")
+
+def cmd_status_change(args):
+    reg = clean_registry()
+    if not reg:
+        print("No servers running. Start one using: servctl start")
+        return
+
+    target_id = None
+    for sid, meta in reg.items():
+        if sid == args.target or str(meta["port"]) == args.target:
+            target_id = sid
+            break
+
+    if not target_id:
+        print(f"Error: No running server matching '{args.target}'.")
+        return
+
+    old_meta = reg[target_id]
+
+    # Resolve optional positional extra (could be port or root directory)
+    parsed_port = args.port
+    parsed_root = args.root
+    if getattr(args, "extra", None):
+        if args.extra.isdigit() and not parsed_port:
+            parsed_port = int(args.extra)
+        elif not parsed_root:
+            parsed_root = args.extra
+
+    # Target new properties
+    new_type = args.type if getattr(args, "type", None) else old_meta["type"]
+    if new_type in ("websecure", "https"):
+        new_type = "websecure"
+
+    new_port = parsed_port if parsed_port is not None else old_meta["port"]
+    new_access = args.access if args.access is not None else old_meta["access"]
+    new_root = str(Path(parsed_root).expanduser().resolve()) if parsed_root is not None else old_meta["root"]
+    new_target = args.target_url if getattr(args, "target_url", None) is not None else old_meta.get("target")
+
+    # Check if anything changed
+    if (new_port == old_meta["port"] and
+        new_access == old_meta["access"] and
+        new_root == old_meta["root"] and
+        new_type == old_meta["type"] and
+        new_target == old_meta.get("target") and
+        not getattr(args, "name", None)):
+        print("Notice: No property changes specified. Use -p, -r, -t, -a, or --target to modify properties.")
+        return
+
+    # Check directory
+    if new_type in ("web", "websecure", "ftp", "ftps", "webdav") and not Path(new_root).is_dir():
+        print(f"Error: Directory '{new_root}' does not exist.")
+        return
+
+    # Check port conflicts
+    new_host = "0.0.0.0" if new_access == "network" else "127.0.0.1"
+    is_udp = (new_type == "dns")
+    if new_port != old_meta["port"] and is_port_in_use(new_port, new_host, udp=is_udp):
+        print(f"Error: Port {new_port} ({'UDP' if is_udp else 'TCP'}) is already in use on {new_host}.")
+        return
+
+    # Check privilege
+    if new_port < 1024 and os.name != "nt" and os.geteuid() != 0:
+        print(f"Error: Port {new_port} is a privileged port (< 1024) requiring root/sudo.")
+        return
+
+    # Determine new ID
+    if getattr(args, "name", None):
+        new_id = args.name
+    elif old_meta["id"] == f"{old_meta['type']}-{old_meta['port']}":
+        new_id = f"{new_type}-{new_port}"
+    else:
+        new_id = old_meta["id"]
+
+    print(f"Applying property changes to '{old_meta['id']}'...")
+    stop_server_by_id(target_id, reg)
+
+    pid, log_path = spawn_server(new_id, new_type, new_port, new_host, new_root, new_target)
+    if not pid:
+        print(f"Error: Failed to re-launch server with new settings. Check log ({log_path}).")
+        return
+
+    reg[new_id] = {
+        "id": new_id,
+        "type": new_type,
+        "port": new_port,
+        "host": new_host,
+        "access": new_access,
+        "root": new_root,
+        "target": new_target,
+        "pid": pid,
+        "started_at": time.time(),
+        "log_file": str(log_path)
+    }
+    write_registry(reg)
+
+    print(f"\n✔ Successfully updated '{old_meta['id']}' -> '{new_id}'!")
+    print_server_status_card(reg[new_id])
+    print()
 
 def cmd_logs(args):
     reg = read_registry()
@@ -969,6 +1294,8 @@ SYNOPSIS
        servctl start [DIRECTORY] [-t TYPE] [-p PORT] [-r ROOT] [-a ACCESS] [--target TARGET] [-n NAME]
        servctl stop [PORT | ID ...] [--all]
        servctl list
+       servctl status show [PORT | ID | --all]
+       servctl status change <PORT | ID> [-p PORT] [-r ROOT] [-t TYPE] [-a ACCESS] [--target TARGET] [-n NAME]
        servctl logs [PORT | ID] [-f] [-n LINES]
        servctl man
 
@@ -977,25 +1304,6 @@ DESCRIPTION
        servers without requiring root/sudo privileges. Processes run in
        detached mode, keeping your terminal responsive and free.
 
-ROOT DIRECTORY HANDLING
-       By default, servctl uses the current working directory where you
-       execute the command as the server root.
-
-       You can point to any other custom directory without having to 'cd'
-       into it, either by passing it as a positional argument:
-              $ servctl start ~/Downloads
-
-       Or explicitly using the --root / -r flag:
-              $ servctl start --root /var/www/html
-
-CONNECTING FROM OTHER DEVICES (LAN SHARING)
-       Use the '-a network' flag to allow other computers, phones, or tablets
-       on the same Wi-Fi network to connect.
-
-       servctl automatically detects your device's LAN IP address and prints
-       the exact URL to use on other devices both during startup and in the
-       'servctl list' table.
-
 SERVER TYPES (-t, --type)
        web (Default)
               A static HTTP web server with Single Page App (SPA) fallback,
@@ -1003,15 +1311,24 @@ SERVER TYPES (-t, --type)
               Default port: 8080.
 
        websecure (or https)
-              A secure HTTPS web server using TLS encryption and auto-generated
-              certificates. Includes SPA fallback, CORS, and no-cache headers.
+              A secure HTTPS web server using self-signed TLS encryption.
+              Includes SPA fallback, CORS, and no-cache headers.
               Default port: 8443.
 
-       ftps (or ftp, fileshare)
+       webdav
+              An RFC 4918 WebDAV network drive server. Mounts natively as a
+              shared network folder in macOS Finder (Cmd+K) and Windows File
+              Explorer (Map Network Drive). Default port: 8088.
+
+       ftp
+              A standard unencrypted RFC 959 FTP server. Allows plaintext
+              uploads and downloads without TLS. Default port: 2121.
+
+       ftps
               An RFC 4217 Explicit FTPS server. Requires TLS encryption
               (AUTH TLS) before authenticating. Protects control and data
               channels (PROT P) with auto-generated certificates.
-              Rejects insecure plaintext requests. Default port: 2121.
+              Rejects insecure plaintext requests. Default port: 2122.
 
        dns
               A local UDP DNS proxy engine that resolves queries through
@@ -1023,45 +1340,68 @@ SERVER TYPES (-t, --type)
               An HTTP forward proxy (with HTTPS CONNECT tunneling) or reverse
               proxy when used with --target. Default port: 8888.
 
-ACCESS MODES (-a, --access)
-       local (Default)
-              Binds to 127.0.0.1 (accessible only on this machine).
-
-       network
-              Binds to 0.0.0.0 (accessible to other devices on the LAN/Wi-Fi).
-
-STOPPING SERVERS
-       Stop one server:
-              $ servctl stop 8080
+STATUS & CONFIGURATION MANAGEMENT
+       servctl status show [ID/PORT]
+              Displays full connection URLs, runtime metrics, and configuration.
 
-       Stop multiple servers simultaneously:
-              $ servctl stop 8080 8443 2121
-              $ servctl stop web-8080 websecure-8443
+       servctl status show --all
+              Displays detailed status cards for all active servers.
 
-       Stop all running servers:
-              $ servctl stop --all
+       servctl status change <ID/PORT> [OPTIONS...]
+              Dynamically changes running server properties (port, root, type,
+              access, target) and restarts it seamlessly in the background.
 
 EXAMPLES
-       1. Start a default HTTP website:
+       1. Start a default HTTP web server:
               $ servctl start
 
-       2. Start a secure HTTPS website on port 8443:
-              $ servctl start -t websecure
-
-       3. Start an HTTPS website pointing to another folder for LAN access:
-              $ servctl start -t websecure ~/Projects/site/dist -a network
+       2. List active servers (concise overview):
+              $ servctl list
 
-       4. Start an FTPS server in a custom folder:
-              $ servctl start -t ftps ~/SharedFolder -a network
+       3. Inspect full configuration and connection URLs:
+              $ servctl status show web-8080
+              $ servctl status show --all
 
-       5. View running servers and connection URLs:
-              $ servctl list
+       4. Change a running server's properties on the fly:
+              $ servctl status change web-8080 -p 8085 -a network
+              $ servctl status change web-8080 -t websecure
 
-       6. Stop multiple servers at once:
+       5. Stop multiple servers at once:
               $ servctl stop 8080 8443
 ================================================================================
 """)
 
+# ---------------------------------------------------------------------------
+# Argument Parser with Intelligent Shorthand Normalizer
+# ---------------------------------------------------------------------------
+
+def normalize_status_argv(argv):
+    """Allows shorthand like 'servctl status' or 'servctl status web-8080'."""
+    try:
+        idx = argv.index("status")
+    except ValueError:
+        return argv
+
+    args_after = argv[idx + 1:]
+    if not args_after:
+        return argv[:idx + 1] + ["show", "--all"]
+    elif args_after[0] in ("-h", "--help", "show", "change"):
+        return argv
+    elif args_after[0] in ("-a", "--all"):
+        return argv[:idx + 1] + ["show", "--all"] + args_after[1:]
+    else:
+        return argv[:idx + 1] + ["show"] + args_after
+
+def setup_change_parser(p):
+    p.add_argument("target", help="Server ID or Port to modify")
+    p.add_argument("extra", nargs="?", default=None, help="Optional new port or root directory")
+    p.add_argument("-p", "--port", type=int, default=None, help="New port number")
+    p.add_argument("-r", "--root", default=None, help="New root directory")
+    p.add_argument("-t", "--type", choices=["web", "websecure", "https", "webdav", "ftp", "ftps", "dns", "proxy"], default=None, help="Change server type")
+    p.add_argument("-a", "--access", choices=["local", "network"], default=None, help="New access scope")
+    p.add_argument("--target", dest="target_url", default=None, help="New upstream target URL")
+    p.add_argument("-n", "--name", default=None, help="Rename server ID")
+
 def main():
     parser = argparse.ArgumentParser(prog="servctl", description="Unprivileged background server and proxy manager")
     subparsers = parser.add_subparsers(dest="command")
@@ -1070,8 +1410,13 @@ def main():
     p_start = subparsers.add_parser("start", help="Start a background server")
     p_start.add_argument("path", nargs="?", default=None, help="Root directory (default: current working directory)")
     p_start.add_argument("-r", "--root", default=None, help="Custom root directory path (overrides current directory)")
-    p_start.add_argument("-t", "--type", choices=["web", "website", "websecure", "https", "ftp", "ftps", "fileshare", "dns", "proxy"], default="web", help="Server type (default: web)")
-    p_start.add_argument("-p", "--port", type=int, default=None, help="Port to bind (defaults: web: 8080, websecure: 8443, ftps: 2121, dns: 5353, proxy: 8888)")
+    p_start.add_argument(
+        "-t", "--type",
+        choices=["web", "websecure", "https", "webdav", "ftp", "ftps", "dns", "proxy"],
+        default="web",
+        help="Server type (default: web)"
+    )
+    p_start.add_argument("-p", "--port", type=int, default=None, help="Port to bind")
     p_start.add_argument("-a", "--access", choices=["local", "network"], default="local", help="Access scope: local (127.0.0.1) or network (0.0.0.0)")
     p_start.add_argument("--target", default=None, help="Target URL for reverse proxy")
     p_start.add_argument("-n", "--name", default=None, help="Custom identifier for this instance")
@@ -1081,8 +1426,25 @@ def main():
     p_stop.add_argument("targets", nargs="*", help="One or more Server IDs or Ports to stop")
     p_stop.add_argument("-a", "--all", action="store_true", help="Stop all running servers")
 
-    # LIST
-    subparsers.add_parser("list", aliases=["ls", "status"], help="List active servers")
+    # LIST (Concise overview)
+    subparsers.add_parser("list", help="List running servers (concise process overview)")
+
+    # STATUS (Inspection and Property Changes)
+    p_status = subparsers.add_parser("status", help="Inspect or change server status and configuration")
+    sub_status = p_status.add_subparsers(dest="status_cmd")
+
+    # status show
+    p_show = sub_status.add_parser("show", help="Show detailed status and connections")
+    p_show.add_argument("target", nargs="?", default=None, help="Server ID or Port")
+    p_show.add_argument("-a", "--all", action="store_true", help="Show all servers in detail")
+
+    # status change
+    p_change = sub_status.add_parser("change", help="Change properties of a running server")
+    setup_change_parser(p_change)
+
+    # Top-level direct 'servctl change'
+    p_top_change = subparsers.add_parser("change", help="Change properties of a running server")
+    setup_change_parser(p_top_change)
 
     # LOGS
     p_logs = subparsers.add_parser("logs", help="View server logs")
@@ -1102,7 +1464,9 @@ def main():
     p_worker.add_argument("--root", required=True)
     p_worker.add_argument("--target", default=None)
 
-    args = parser.parse_args()
+    # Normalize argv so shorthand 'servctl status' and 'servctl status <name>' work directly
+    normalized_argv = normalize_status_argv(sys.argv)
+    args = parser.parse_args(normalized_argv[1:])
 
     if args.command == "_worker":
         run_worker(args)
@@ -1110,8 +1474,15 @@ def main():
         cmd_start(args)
     elif args.command == "stop":
         cmd_stop(args)
-    elif args.command in ("list", "ls", "status"):
+    elif args.command == "list":
         cmd_list(args)
+    elif args.command == "status":
+        if getattr(args, "status_cmd", None) == "change":
+            cmd_status_change(args)
+        else:
+            cmd_status_show(args)
+    elif args.command == "change":
+        cmd_status_change(args)
     elif args.command == "logs":
         cmd_logs(args)
     elif args.command == "man":