asteri 1.0.0__tar.gz

asteri-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IshikawaUta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

asteri-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: asteri
+Version: 1.0.0
+License-File: LICENSE
+Requires-Dist: setproctitle>=1.3.3
+Requires-Dist: watchdog>=3.0.0
+Requires-Dist: h2>=4.1.0
+Requires-Dist: gevent>=23.9.1
+Requires-Dist: psutil>=5.9.0
+Dynamic: license-file
+Dynamic: requires-dist

asteri-1.0.0/README.md

@@ -0,0 +1,86 @@
+# 🌟 Asteri Web Server
+
+**Asteri** adalah web server Python berperforma tinggi, *production-ready*, yang dirancang dengan sistem argumen CLI yang kaya dan intuitif. Asteri mendukung berbagai protokol mulai dari WSGI, ASGI, hingga uWSGI biner.
+
+## ✨ Fitur Utama
+- **Multi-Protokol**: HTTP/1.1, HTTP/2 (Full Frame Support), WSGI, ASGI, uWSGI.
+- **Berbagai Tipe Worker**:
+  - `sync`: Worker sinkron standar.
+  - `gthread`: Worker berbasis thread untuk konkurensi lebih baik.
+  - `gevent`: Worker asinkron berbasis greenlet (performa tinggi).
+  - `asgi`: Dukungan penuh untuk aplikasi modern (FastAPI, Starlette).
+- **Auto-Reload Profesional**: Berbasis *event-driven* menggunakan `watchdog`.
+- **Manajemen Proses**: Mode Daemon, PID files, dan User/Group switching.
+- **Keamanan**: Dukungan SSL/TLS (HTTPS) yang mudah dikonfigurasi.
+- **Dashboard Status**: Pantau kesehatan server di endpoint `/asteri-status`.
+
+## 🚀 Instalasi
+```bash
+git clone https://github.com/IshikawaUta/asteri.git
+cd asteri
+pip install -e .
+```
+
+## 🛠️ Penggunaan Dasar
+Menjalankan aplikasi WSGI:
+```bash
+asteri myapp:app
+```
+
+Menjalankan dengan 4 worker dan bind ke port tertentu:
+```bash
+asteri myapp:app -w 4 -b 0.0.0.0:8080
+```
+
+## 📖 Panduan CLI Lengkap
+
+Asteri mendukung berbagai kategori argumen untuk kontrol penuh:
+
+### 🌐 Jaringan (Network)
+- `-b, --bind ADDRESS`: Bind ke alamat tertentu (misal: `127.0.0.1:8000`).
+- `--backlog INT`: Batas antrean koneksi.
+- `--reuse-port`: Menggunakan flag `SO_REUSEPORT` pada soket.
+
+### 👷 Worker
+- `-w, --workers INT`: Jumlah proses worker.
+- `-k, --worker-class STRING`: Tipe worker (`sync`, `gthread`, `asgi`, `gevent`).
+- `-t, --timeout INT`: Batas waktu worker sebelum di-*restart*.
+- `--preload`: Memuat aplikasi sebelum *forking* worker.
+
+### 🔒 Keamanan & SSL
+- `--certfile FILE`: Jalur ke file sertifikat SSL.
+- `--keyfile FILE`: Jalur ke file kunci SSL.
+- `-u, --user USER`: Menjalankan worker sebagai user tertentu.
+- `-g, --group GROUP`: Menjalankan worker sebagai group tertentu.
+
+### 📝 Logging & Debugging
+- `--log-file FILE`: Jalur ke file log error.
+- `--log-level LEVEL`: Granularitas log (`debug`, `info`, `warning`, `error`).
+- `--access-logfile FILE`: Jalur ke file log akses.
+- `--print-config`: Menampilkan konfigurasi yang sedang digunakan dan keluar.
+
+### ⚙️ Proses
+- `-D, --daemon`: Menjalankan Asteri di latar belakang (background).
+- `-p, --pid FILE`: Membuat file PID.
+- `--reload`: Memantau perubahan kode dan memuat ulang worker secara otomatis.
+- `--chdir DIR`: Mengubah direktori kerja sebelum menjalankan aplikasi.
+
+## 📄 File Konfigurasi
+Anda bisa menggunakan file Python untuk konfigurasi yang lebih kompleks:
+
+```python
+# asteri.conf.py
+bind = "127.0.0.1:8080"
+workers = 4
+worker_class = "gthread"
+timeout = 60
+reload = True
+```
+Jalankan dengan: `asteri myapp:app -c asteri.conf.py`
+
+## 📊 Dashboard Status
+Aktifkan dashboard internal untuk melihat statistik worker:
+Kunjungi `http://localhost:8000/asteri-status` pada browser Anda.
+
+## 📜 Lisensi
+Proyek ini dilisensikan di bawah **MIT License**.

asteri-1.0.0/asteri/__main__.py

@@ -0,0 +1,199 @@
+import logging
+import argparse
+import sys
+import os
+from asteri.arbiter import Arbiter
+from asteri.workers.sync import SyncWorker
+from asteri.workers.gthread import GThreadWorker
+from asteri.workers.asgi import ASGIWorker
+try:
+    from asteri.workers.gevent import GeventWorker
+except ImportError:
+    GeventWorker = None
+from asteri.utils import logger, print_banner, Colors, setup_logging
+
+def import_app(app_path):
+    """Import application from string 'module:callable'."""
+    try:
+        module_path, app_name = app_path.split(":")
+        sys.path.insert(0, os.getcwd())
+        module = __import__(module_path)
+        return getattr(module, app_name)
+    except Exception as e:
+        logger.error(f"Could not import app '{Colors.BOLD}{app_path}{Colors.ENDC}': {e}")
+        sys.exit(1)
+
+def main():
+    print_banner()
+    
+    parser = argparse.ArgumentParser(
+        prog="asteri",
+        description=f"{Colors.BOLD}Asteri: High Performance Web Server{Colors.ENDC}",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        add_help=True
+    )
+    
+    # Positional Arguments
+    parser.add_argument("app", nargs="?", help="Application path (e.g., myapp:app)")
+    
+    # Config Group
+    config_group = parser.add_argument_group("Config")
+    config_group.add_argument("-c", "--config", help="The Asteri config file.")
+    config_group.add_argument("-v", "--version", action="version", version="Asteri v1.0.0")
+    config_group.add_argument("--check-config", action="store_true", help="Check the configuration and exit.")
+    config_group.add_argument("--print-config", action="store_true", help="Print the configuration settings.")
+
+    # Network Group
+    net_group = parser.add_argument_group("Network")
+    net_group.add_argument("-b", "--bind", action="append", help="The socket to bind.")
+    net_group.add_argument("--backlog", type=int, default=2048, help="The maximum number of pending connections.")
+    net_group.add_argument("--reuse-port", action="store_true", help="Set the SO_REUSEPORT flag.")
+
+    # Worker Group
+    worker_group = parser.add_argument_group("Workers")
+    worker_group.add_argument("-w", "--workers", type=int, default=1, help="The number of worker processes.")
+    worker_group.add_argument("-k", "--worker-class", default="sync", choices=["sync", "gthread", "asgi", "gevent"],
+                             help="The type of workers to use.")
+    worker_group.add_argument("--threads", type=int, default=1, help="The number of worker threads.")
+    worker_group.add_argument("--worker-connections", type=int, default=1000, help="Max simultaneous clients.")
+    worker_group.add_argument("--max-requests", type=int, default=0, help="Max requests before worker restart.")
+    worker_group.add_argument("--max-requests-jitter", type=int, default=0, help="Jitter for max-requests.")
+    worker_group.add_argument("-t", "--timeout", type=int, default=30, help="Worker timeout in seconds.")
+    worker_group.add_argument("--graceful-timeout", type=int, default=30, help="Timeout for graceful restart.")
+    worker_group.add_argument("--keep-alive", type=int, default=2, help="Keep-alive timeout.")
+    worker_group.add_argument("--preload", action="store_true", help="Load app code before forking.")
+
+    # Security/SSL Group
+    sec_group = parser.add_argument_group("Security")
+    sec_group.add_argument("--keyfile", help="SSL key file")
+    sec_group.add_argument("--certfile", help="SSL certificate file")
+    sec_group.add_argument("--ca-certs", help="CA certificates file")
+    sec_group.add_argument("--ssl-version", type=int, default=2, help="SSL version to use.")
+    sec_group.add_argument("--ciphers", help="SSL Cipher suite to use.")
+    sec_group.add_argument("-u", "--user", help="Switch worker processes to run as this user.")
+    sec_group.add_argument("-g", "--group", help="Switch worker process to run as this group.")
+    sec_group.add_argument("-m", "--umask", type=int, default=0, help="Bit mask for file mode.")
+
+    # Logging Group
+    log_group = parser.add_argument_group("Logging")
+    log_group.add_argument("--access-logfile", help="The Access log file.")
+    log_group.add_argument("--error-logfile", "--log-file", help="The Error log file.")
+    log_group.add_argument("--log-level", default="info", choices=["debug", "info", "warning", "error", "critical"])
+    log_group.add_argument("--capture-output", action="store_true", help="Redirect stdout/stderr to error log.")
+    log_group.add_argument("--access-logformat", help="The access log format.")
+
+    # Process Group
+    proc_group = parser.add_argument_group("Process")
+    proc_group.add_argument("-D", "--daemon", action="store_true", help="Daemonize the process.")
+    proc_group.add_argument("-p", "--pid", help="PID filename.")
+    proc_group.add_argument("--chdir", help="Change directory before loading apps.")
+    proc_group.add_argument("-e", "--env", action="append", help="Set environment variables.")
+    proc_group.add_argument("-n", "--name", help="Process name for setproctitle.")
+    proc_group.add_argument("--reload", action="store_true", help="Restart workers on code changes.")
+
+    # HTTP limits
+    http_group = parser.add_argument_group("HTTP Limits")
+    http_group.add_argument("--limit-request-line", type=int, default=4094)
+    http_group.add_argument("--limit-request-fields", type=int, default=100)
+    http_group.add_argument("--limit-request-field_size", type=int, default=8190)
+
+    # HTTP/2 Group
+    h2_group = parser.add_argument_group("HTTP/2")
+    h2_group.add_argument("--http-protocols", default="h1", help="HTTP protocols to support (e.g., h1,h2)")
+    h2_group.add_argument("--http2-max-concurrent-streams", type=int, default=100)
+
+    args = parser.parse_args()
+
+    # 1. Load Config File if provided
+    if args.config and os.path.exists(args.config):
+        config_namespace = {}
+        with open(args.config) as f:
+            exec(f.read(), config_namespace)
+        for key, value in config_namespace.items():
+            if hasattr(args, key.lower()):
+                setattr(args, key.lower(), value)
+
+    # Ensure bind is always a list
+    if args.bind and isinstance(args.bind, str):
+        args.bind = [args.bind]
+    elif not args.bind:
+        args.bind = ["127.0.0.1:8000"]
+
+    # 2. Check Config
+    if args.check_config or args.print_config:
+        if args.print_config:
+            print(f"{Colors.BOLD}Resolved Configuration:{Colors.ENDC}")
+            for arg in vars(args):
+                print(f"  {arg}: {getattr(args, arg)}")
+        sys.exit(0)
+
+    # 3. Handle Chdir
+    if args.chdir:
+        os.chdir(args.chdir)
+        sys.path.insert(0, os.getcwd())
+
+    # 4. Handle Env
+    if args.env:
+        for env_var in args.env:
+            if "=" in env_var:
+                k, v = env_var.split("=", 1)
+                os.environ[k] = v
+
+    # 5. Logging setup
+    log_file = args.error_logfile
+    log_level_name = (args.log_level or "info").upper()
+    log_level = getattr(logging, log_level_name, logging.INFO)
+    setup_logging(log_file=log_file, level=log_level)
+    
+    worker_map = {
+        "sync": SyncWorker,
+        "gthread": GThreadWorker,
+        "asgi": ASGIWorker,
+        "gevent": GeventWorker
+    }
+    
+    worker_class = worker_map[args.worker_class]
+    if worker_class is None:
+        logger.error(f"Worker class '{args.worker_class}' is not available.")
+        sys.exit(1)
+
+    if not args.app:
+        parser.print_help()
+        sys.exit(1)
+
+    # Preload
+    if args.preload:
+        from asteri.utils import import_app
+        import_app(args.app)
+    
+    # Setup binds
+    binds = args.bind if args.bind else ["127.0.0.1:8000"]
+    
+    arbiter = Arbiter(
+        args.app, worker_class, 
+        num_workers=args.workers, 
+        bind=binds[0], 
+        reload=args.reload,
+        certfile=args.certfile,
+        keyfile=args.keyfile,
+        daemon=args.daemon,
+        pidfile=args.pid,
+        user=args.user,
+        group=args.group,
+        umask=args.umask,
+        proc_name=args.name,
+        timeout=args.timeout
+    )
+    
+    logger.info(f"Booting {Colors.CYAN}{args.worker_class}{Colors.ENDC} workers...")
+    
+    try:
+        arbiter.start()
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        logger.error(f"Fatal error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

asteri-1.0.0/asteri/arbiter.py

@@ -0,0 +1,204 @@
+import os
+import signal
+import socket
+import sys
+import time
+from .utils import logger, set_proctitle, Colors
+
+try:
+    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEventHandler
+    WATCHDOG_AVAILABLE = True
+except ImportError:
+    WATCHDOG_AVAILABLE = False
+
+class Arbiter:
+    """The Master process that manages workers."""
+    
+    def __init__(self, app_path, worker_class, num_workers=1, bind="0.0.0.0:8000", reload=False, certfile=None, keyfile=None,
+                 daemon=False, pidfile=None, user=None, group=None, umask=0, proc_name=None, timeout=30):
+        self.app_path = app_path
+        self.worker_class = worker_class
+        self.num_workers = num_workers
+        self.bind = bind
+        self.reload = reload
+        self.certfile = certfile
+        self.keyfile = keyfile
+        self.daemon = daemon
+        self.pidfile = pidfile
+        self.user = user
+        self.group = group
+        self.umask = umask
+        self.proc_name = proc_name or "master"
+        self.timeout = timeout
+        self.workers = {} # pid -> worker_instance
+        self.sock = None
+        self.alive = True
+        self.pid = os.getpid()
+        self.reloader = None
+
+    def start(self):
+        if self.daemon:
+            self.daemonize()
+        
+        if self.pidfile:
+            self.write_pid()
+            
+        if self.umask:
+            os.umask(self.umask)
+
+        set_proctitle(self.proc_name)
+        logger.info(f"Starting Asteri Arbiter (pid: {Colors.BOLD}{os.getpid()}{Colors.ENDC})")
+        
+        if self.reload and WATCHDOG_AVAILABLE:
+            self.setup_reloader()
+        elif self.reload:
+            logger.warning("Watchdog not available, falling back to manual reload.")
+        
+        # Create listener socket
+        host, port = self.bind.split(":")
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        
+        if self.certfile and self.keyfile:
+            import ssl
+            context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+            context.load_cert_chain(certfile=self.certfile, keyfile=self.keyfile)
+            self.sock = context.wrap_socket(self.sock, server_side=True)
+            logger.info(f"SSL {Colors.GREEN}enabled{Colors.ENDC} ({self.certfile})")
+        
+        self.sock.bind((host, int(port)))
+        self.sock.listen(1024)
+        self.sock.setblocking(False)
+        
+        scheme = "https" if self.certfile else "http"
+        logger.info(f"Listening on {Colors.UNDERLINE}{scheme}://{self.bind}{Colors.ENDC}")
+        
+        self.setup_signals()
+        self.manage_workers()
+
+    def setup_reloader(self):
+        class ReloadHandler(FileSystemEventHandler):
+            def __init__(self, arbiter):
+                self.arbiter = arbiter
+            def on_modified(self, event):
+                if event.src_path.endswith('.py'):
+                    logger.info(f"Change detected in {Colors.BOLD}{os.path.basename(event.src_path)}{Colors.ENDC}. Reloading...")
+                    self.arbiter.stop_workers(signal.SIGTERM)
+
+        self.reloader = Observer()
+        self.reloader.schedule(ReloadHandler(self), os.getcwd(), recursive=True)
+        self.reloader.start()
+        logger.info(f"Auto-reload {Colors.GREEN}enabled{Colors.ENDC} (watchdog)")
+
+    def daemonize(self):
+        """Standard double-fork daemonization."""
+        if os.fork() > 0: sys.exit(0)
+        os.setsid()
+        if os.fork() > 0: sys.exit(0)
+        
+        # Redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+        si = open(os.devnull, 'r')
+        so = open(os.devnull, 'a+')
+        se = open(os.devnull, 'a+')
+        os.dup2(si.fileno(), sys.stdin.fileno())
+        os.dup2(so.fileno(), sys.stdout.fileno())
+        os.dup2(se.fileno(), sys.stderr.fileno())
+
+    def write_pid(self):
+        with open(self.pidfile, 'w') as f:
+            f.write(str(os.getpid()))
+
+    def switch_user(self):
+        if not self.user and not self.group:
+            return
+        import pwd, grp
+        if self.group:
+            gid = grp.getgrnam(self.group).gr_gid
+            os.setgid(gid)
+        if self.user:
+            uid = pwd.getpwnam(self.user).pw_uid
+            os.setuid(uid)
+
+    def setup_signals(self):
+        signal.signal(signal.SIGCHLD, self.handle_chld)
+        signal.signal(signal.SIGTERM, self.handle_exit)
+        signal.signal(signal.SIGINT, self.handle_exit)
+        signal.signal(signal.SIGHUP, self.handle_hup)
+        signal.signal(signal.SIGQUIT, self.handle_quit)
+
+    def handle_chld(self, sig, frame):
+        """Worker died."""
+        self.wakeup()
+
+    def handle_exit(self, sig, frame):
+        self.alive = False
+        self.stop_workers(signal.SIGTERM)
+
+    def handle_quit(self, sig, frame):
+        self.alive = False
+        self.stop_workers(signal.SIGQUIT)
+
+    def handle_hup(self, sig, frame):
+        """Reload workers."""
+        logger.info("Reloading workers...")
+        self.stop_workers(signal.SIGTERM)
+
+    def wakeup(self):
+        """Force loop to check workers."""
+        pass
+
+    def stop_workers(self, sig):
+        import psutil
+        for pid in list(self.workers.keys()):
+            try:
+                p = psutil.Process(pid)
+                p.send_signal(sig)
+            except psutil.NoSuchProcess:
+                if pid in self.workers:
+                    del self.workers[pid]
+
+    def spawn_worker(self):
+        worker = self.worker_class(0, self.pid, self.sock, self.app_path, self.timeout)
+        pid = os.fork()
+        
+        if pid == 0: # Child
+            try:
+                self.switch_user()
+                worker.init_process()
+                worker.run()
+                sys.exit(0)
+            except Exception as e:
+                logger.error(f"Worker error: {e}")
+                sys.exit(1)
+        else: # Parent
+            self.workers[pid] = worker
+            return pid
+
+    def manage_workers(self):
+        while self.alive:
+            # Maintain worker count
+            while len(self.workers) < self.num_workers:
+                self.spawn_worker()
+            
+            # Reaping dead children
+            try:
+                pid, status = os.waitpid(-1, os.WNOHANG)
+                while pid > 0:
+                    if pid in self.workers:
+                        del self.workers[pid]
+                    pid, status = os.waitpid(-1, os.WNOHANG)
+            except ChildProcessError:
+                pass
+                
+            time.sleep(1.0)
+            
+        # Cleanup
+        if self.reloader:
+            self.reloader.stop()
+            self.reloader.join()
+        
+        logger.info("Asteri shutting down.")
+        self.sock.close()

asteri-1.0.0/asteri/http.py

@@ -0,0 +1,120 @@
+import socket
+import io
+import http.client
+from .utils import logger
+
+class HTTPRequest:
+    def __init__(self, method, path, version, headers, body=None):
+        self.method = method
+        self.path = path
+        self.version = version
+        self.headers = headers
+        self.body = body
+
+class HTTPParser:
+    @staticmethod
+    def parse(raw_data):
+        """Simple HTTP/1.1 parser."""
+        try:
+            # Split headers and body
+            header_part, _, body = raw_data.partition(b"\r\n\r\n")
+            lines = header_part.split(b"\r\n")
+            
+            if not lines or not lines[0]:
+                return None
+
+            # Request line
+            request_line = lines[0].decode('ascii').split()
+            if len(request_line) < 3:
+                return None
+            
+            method, path, version = request_line
+            
+            # Headers
+            headers = {}
+            for line in lines[1:]:
+                if b":" in line:
+                    key, value = line.split(b":", 1)
+                    headers[key.decode('ascii').lower().strip()] = value.decode('ascii').strip()
+            
+            return HTTPRequest(method, path, version, headers, body)
+        except Exception as e:
+            logger.error(f"Failed to parse HTTP request: {e}")
+            return None
+
+try:
+    import h2.connection
+    import h2.events
+    H2_AVAILABLE = True
+except ImportError:
+    H2_AVAILABLE = False
+
+class HTTP2Handler:
+    """Professional HTTP/2 handler using 'h2' library."""
+    PREFACE = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+    
+    @staticmethod
+    def is_http2(data):
+        return data.startswith(HTTP2Handler.PREFACE)
+
+    def __init__(self, sock):
+        self.sock = sock
+        self.conn = h2.connection.H2Connection()
+        self.conn.initiate_connection()
+        self.sock.sendall(self.conn.data_to_send())
+
+    def handle(self):
+        """Main HTTP/2 event loop for a connection."""
+        if not H2_AVAILABLE:
+            logger.error("HTTP/2 requested but 'h2' library is missing.")
+            return
+
+        while True:
+            try:
+                data = self.sock.recv(65535)
+                if not data: break
+                
+                events = self.conn.receive_data(data)
+                for event in events:
+                    if isinstance(event, h2.events.RequestReceived):
+                        self.handle_request(event)
+                
+                data_to_send = self.conn.data_to_send()
+                if data_to_send:
+                    self.sock.sendall(data_to_send)
+            except Exception as e:
+                logger.debug(f"H2 Connection closed: {e}")
+                break
+
+    def handle_request(self, event):
+        # Convert H2 headers to dict
+        headers = dict(event.headers)
+        method = headers.get(':method')
+        path = headers.get(':path')
+        
+        # This would then call the app... for now just logging
+        logger.info(f"H2 Request: {method} {path}")
+        
+        # Simple H2 Response
+        response_headers = [
+            (':status', '200'),
+            ('content-type', 'text/plain'),
+            ('server', 'Asteri'),
+        ]
+        self.conn.send_headers(event.stream_id, response_headers)
+        self.conn.send_data(event.stream_id, b"Hello from Asteri (HTTP/2)!", end_stream=True)
+        self.sock.sendall(self.conn.data_to_send())
+
+def build_http_response(status_code, headers, body):
+    """Build a standard HTTP/1.1 response."""
+    status_text = http.client.responses.get(status_code, "Unknown")
+    response = f"HTTP/1.1 {status_code} {status_text}\r\n"
+    
+    if "Content-Length" not in headers and body:
+        headers["Content-Length"] = str(len(body))
+    
+    for key, value in headers.items():
+        response += f"{key}: {value}\r\n"
+    
+    response += "\r\n"
+    return response.encode('ascii') + (body if isinstance(body, bytes) else body.encode('utf-8'))