stupidpythonbrowser 1.0.1__py3-none-any.whl

pybrowser/terminal.py

@@ -0,0 +1,451 @@
+"""
+PyBrowser Embedded Terminal Session Manager.
+Spawns native login shells over pseudo-terminals (PTY) and bridges I/O to WebKit.
+Integrates with PyBrowser's DNS-over-HTTPS (DoH) proxy server for secure network I/O.
+"""
+
+import os
+import pty
+import select
+import subprocess
+import termios
+import fcntl
+import struct
+import threading
+import base64
+import time
+import signal
+import socket
+import Cocoa
+
+
+def dispatch_to_main(fn, *args):
+    """Executes a function on the macOS main Cocoa run loop."""
+    if Cocoa.NSThread.isMainThread():
+        fn(*args)
+    else:
+        Cocoa.NSOperationQueue.mainQueue().addOperationWithBlock_(lambda: fn(*args))
+
+
+def get_proxy_port():
+    """Resolves the local proxy port configured in PyBrowser settings."""
+    try:
+        from pybrowser.settings import LOCAL_PROXY_PORT
+        return int(LOCAL_PROXY_PORT)
+    except ImportError:
+        try:
+            from settings import LOCAL_PROXY_PORT
+            return int(LOCAL_PROXY_PORT)
+        except ImportError:
+            return 8888
+
+
+def get_data_dir():
+    """Resolves the PyBrowser data directory path."""
+    try:
+        from pybrowser.settings import DATA_DIR
+        return DATA_DIR
+    except ImportError:
+        try:
+            from settings import DATA_DIR
+            return DATA_DIR
+        except ImportError:
+            return os.path.expanduser("~/data")
+
+
+def ensure_doh_proxy_running():
+    """Ensures that PyBrowser's local DoH proxy server is running and accepting connections."""
+    port = get_proxy_port()
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout=0.15):
+            return True
+    except Exception:
+        pass
+
+    try:
+        try:
+            from pybrowser.doh_server import (
+                start_proxy_server, load_dns_cache, load_adblock_filters_from_disk
+            )
+        except ImportError:
+            from doh_server import (
+                start_proxy_server, load_dns_cache, load_adblock_filters_from_disk
+            )
+
+        try:
+            load_dns_cache()
+        except Exception:
+            pass
+        try:
+            load_adblock_filters_from_disk()
+        except Exception:
+            pass
+
+        start_proxy_server()
+
+        deadline = time.time() + 1.0
+        while time.time() < deadline:
+            try:
+                with socket.create_connection(("127.0.0.1", port), timeout=0.1):
+                    return True
+            except Exception:
+                time.sleep(0.05)
+    except Exception as e:
+        print(f"[Terminal DoH Integration Warning] Could not ensure proxy server: {e}")
+    return False
+
+
+def ensure_doh_cli_helper(bin_dir, proxy_port):
+    """Creates CLI helpers inside ~/data/bin for manual DNS inspection and proxy routing."""
+    try:
+        os.makedirs(bin_dir, exist_ok=True)
+        helper_path = os.path.join(bin_dir, "doh-resolve")
+        helper_code = f"""#!/usr/bin/env python3
+import sys
+import urllib.request
+import json
+import socket
+
+try:
+    from pybrowser.doh_server import doh_resolve
+except ImportError:
+    try:
+        from doh_server import doh_resolve
+    except ImportError:
+        doh_resolve = None
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: doh-resolve <hostname>")
+        sys.exit(1)
+    hostname = sys.argv[1].strip()
+    if doh_resolve:
+        try:
+            ip = doh_resolve(hostname)
+            print(f"{{hostname}} -> {{ip}} (via PyBrowser DoH Engine)")
+            return
+        except Exception:
+            pass
+
+    try:
+        proxy_handler = urllib.request.ProxyHandler({{
+            "http": "http://127.0.0.1:{proxy_port}",
+            "https": "http://127.0.0.1:{proxy_port}"
+        }})
+        opener = urllib.request.build_opener(proxy_handler)
+        url = "https://cloudflare-dns.com/dns-query?name=" + hostname + "&type=A"
+        req = urllib.request.Request(url, headers={{"Accept": "application/dns-json", "User-Agent": "PyBrowser-DoH-CLI"}})
+        with opener.open(req, timeout=5) as resp:
+            data = json.loads(resp.read().decode('utf-8'))
+            answers = [ans.get("data") for ans in data.get("Answer", []) if ans.get("type") == 1]
+            if answers:
+                for ip in answers:
+                    print(f"{{hostname}} -> {{ip}} (via PyBrowser DoH Proxy)")
+                return
+    except Exception:
+        pass
+
+    try:
+        ip = socket.gethostbyname(hostname)
+        print(f"{{hostname}} -> {{ip}}")
+    except Exception as e:
+        print(f"Resolution failed for {{hostname}}: {{e}}")
+
+if __name__ == "__main__":
+    main()
+"""
+        with open(helper_path, "w", encoding="utf-8") as f:
+            f.write(helper_code)
+        os.chmod(helper_path, 0o755)
+    except Exception:
+        pass
+
+
+class TerminalSession:
+    """Non-blocking PTY session streaming raw I/O over Base64 to xterm.js."""
+    def __init__(self, webview, cols=80, rows=24, on_close=None):
+        self.webview = webview
+        self.cols = max(10, int(cols))
+        self.rows = max(5, int(rows))
+        self.alive = True
+        self.master_fd = -1
+        self.proc = None
+        self.lock = threading.Lock()
+        self.on_close = on_close
+        self.spawn()
+
+    def _apply_doh_environment(self, env):
+        """Configures shell environment variables to route network requests and DNS via doh_server."""
+        port = get_proxy_port()
+        proxy_url = f"http://127.0.0.1:{port}"
+        no_proxy_hosts = "localhost,127.0.0.1,::1,.local"
+
+        # Standard HTTP/HTTPS/All proxy environment variables (lowercase and uppercase)
+        env["http_proxy"] = proxy_url
+        env["https_proxy"] = proxy_url
+        env["all_proxy"] = proxy_url
+        env["ftp_proxy"] = proxy_url
+
+        env["HTTP_PROXY"] = proxy_url
+        env["HTTPS_PROXY"] = proxy_url
+        env["ALL_PROXY"] = proxy_url
+        env["FTP_PROXY"] = proxy_url
+
+        env["no_proxy"] = no_proxy_hosts
+        env["NO_PROXY"] = no_proxy_hosts
+
+        # Git proxy configuration: ensure git clone / fetch always routes through doh_server
+        try:
+            count = int(env.get("GIT_CONFIG_COUNT", "0"))
+        except (ValueError, TypeError):
+            count = 0
+        has_git_proxy = False
+        for i in range(count):
+            if env.get(f"GIT_CONFIG_KEY_{i}") == "http.proxy":
+                has_git_proxy = True
+                break
+        if not has_git_proxy:
+            env[f"GIT_CONFIG_KEY_{count}"] = "http.proxy"
+            env[f"GIT_CONFIG_VALUE_{count}"] = proxy_url
+            env["GIT_CONFIG_COUNT"] = str(count + 1)
+
+        # Git SSH proxy tunnel fallback via netcat through our CONNECT proxy
+        if os.path.exists("/usr/bin/nc") and "GIT_SSH_COMMAND" not in env:
+            env["GIT_SSH_COMMAND"] = f"ssh -o ProxyCommand='/usr/bin/nc -X connect -x 127.0.0.1:{port} %h %p'"
+
+        # Package manager & developer CLI proxy overrides
+        env["NPM_CONFIG_PROXY"] = proxy_url
+        env["NPM_CONFIG_HTTPS_PROXY"] = proxy_url
+        env["npm_config_proxy"] = proxy_url
+        env["npm_config_https_proxy"] = proxy_url
+        env["PIP_PROXY"] = proxy_url
+        env["CARGO_HTTP_PROXY"] = proxy_url
+
+        # Inject PyBrowser CLI tools into PATH
+        bin_dir = os.path.join(get_data_dir(), "bin")
+        ensure_doh_cli_helper(bin_dir, port)
+        cur_path = env.get("PATH", "/usr/bin:/bin:/usr/sbin:/sbin")
+        if bin_dir not in cur_path:
+            env["PATH"] = f"{bin_dir}:{cur_path}"
+
+        # PyBrowser session indicators
+        env["PYBROWSER_DOH_PROXY"] = proxy_url
+        env["PYBROWSER_DOH_PORT"] = str(port)
+
+    def spawn(self):
+        try:
+            # Ensure DoH proxy server is initialized and listening
+            ensure_doh_proxy_running()
+
+            self.master_fd, slave_fd = pty.openpty()
+            winsize = struct.pack("HHHH", int(self.rows), int(self.cols), 0, 0)
+            fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, winsize)
+
+            flags = fcntl.fcntl(self.master_fd, fcntl.F_GETFL)
+            fcntl.fcntl(self.master_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+            env = os.environ.copy()
+            env["TERM"] = "xterm-256color"
+            env["LANG"] = "en_US.UTF-8"
+            env["SHELL"] = "/bin/zsh" if os.path.exists("/bin/zsh") else "/bin/bash"
+            env["COLUMNS"] = str(self.cols)
+            env["LINES"] = str(self.rows)
+
+            # Apply DoH proxy routing to all commands run in this terminal
+            self._apply_doh_environment(env)
+
+            # Pre-exec setup to establish controlling terminal for SIGWINCH support
+            def _preexec_child():
+                try:
+                    if hasattr(os, "login_tty"):
+                        os.login_tty(slave_fd)
+                    elif hasattr(pty, "login_tty"):
+                        pty.login_tty(slave_fd)
+                    else:
+                        os.setsid()
+                        try:
+                            fcntl.ioctl(slave_fd, termios.TIOCSCTTY, 0)
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+
+            self.proc = subprocess.Popen(
+                [env["SHELL"], "-l"],
+                stdin=slave_fd,
+                stdout=slave_fd,
+                stderr=slave_fd,
+                preexec_fn=_preexec_child,
+                close_fds=True,
+                env=env,
+                cwd=os.path.expanduser("~")
+            )
+            os.close(slave_fd)
+            threading.Thread(target=self._read_loop, daemon=True).start()
+        except Exception as e:
+            print(f"[Terminal Spawn Error] {e}")
+
+    def _read_loop(self):
+        while self.alive and self.master_fd >= 0:
+            try:
+                r, _, _ = select.select([self.master_fd], [], [], 0.05)
+                if r:
+                    with self.lock:
+                        if self.master_fd < 0:
+                            break
+                        try:
+                            data = os.read(self.master_fd, 8192)
+                        except (BlockingIOError, InterruptedError):
+                            continue
+                        except OSError:
+                            break
+
+                    if not data:
+                        break
+                    b64_str = base64.b64encode(data).decode('ascii')
+                    wv = self.webview
+                    if wv:
+                        dispatch_to_main(lambda b=b64_str, w=wv: self._flush_to_webview(w, b))
+            except (OSError, ValueError):
+                break
+        self.close()
+
+    def _flush_to_webview(self, wv, b64_str):
+        try:
+            wv.evaluateJavaScript_completionHandler_(
+                f"if (window.writeToTerm) window.writeToTerm('{b64_str}');", None
+            )
+        except Exception:
+            pass
+
+    def write(self, text):
+        if not self.alive or self.master_fd < 0:
+            return
+        try:
+            data = text.encode('utf-8')
+            total = 0
+            while total < len(data) and self.master_fd >= 0:
+                try:
+                    with self.lock:
+                        if self.master_fd < 0:
+                            break
+                        n = os.write(self.master_fd, data[total:])
+                    total += n
+                except (BlockingIOError, InterruptedError):
+                    time.sleep(0.001)
+                except OSError:
+                    break
+        except Exception as e:
+            print(f"[Terminal Write Error] {e}")
+
+    def resize(self, cols, rows):
+        c = max(10, int(cols))
+        r = max(5, int(rows))
+        if self.cols == c and self.rows == r:
+            return
+        self.cols = c
+        self.rows = r
+        if self.master_fd >= 0 and self.alive:
+            try:
+                winsize = struct.pack("HHHH", int(self.rows), int(self.cols), 0, 0)
+                fcntl.ioctl(self.master_fd, termios.TIOCSWINSZ, winsize)
+            except Exception as e:
+                print(f"[Terminal Resize Error] {e}")
+
+            # Send SIGWINCH directly to child process group to immediately update vim/less
+            if self.proc:
+                try:
+                    pgid = os.getpgid(self.proc.pid)
+                    os.killpg(pgid, signal.SIGWINCH)
+                except Exception:
+                    pass
+
+    def close(self):
+        if not self.alive and self.master_fd < 0 and self.proc is None:
+            return
+        self.alive = False
+        with self.lock:
+            if self.master_fd >= 0:
+                try:
+                    os.close(self.master_fd)
+                except Exception:
+                    pass
+                self.master_fd = -1
+
+        if self.proc:
+            try:
+                pgid = os.getpgid(self.proc.pid)
+                os.killpg(pgid, signal.SIGTERM)
+                try:
+                    self.proc.wait(timeout=0.2)
+                except subprocess.TimeoutExpired:
+                    os.killpg(pgid, signal.SIGKILL)
+                    self.proc.wait(timeout=0.2)
+            except Exception:
+                try:
+                    self.proc.terminate()
+                    self.proc.wait(timeout=0.2)
+                except Exception:
+                    pass
+            self.proc = None
+
+        self.webview = None
+        if self.on_close:
+            try:
+                self.on_close(self)
+            except Exception:
+                pass
+            self.on_close = None
+
+
+class TerminalManager:
+    def __init__(self):
+        self.sessions = {}
+        self.lock = threading.Lock()
+
+    def get_or_create(self, webview, cols=None, rows=None):
+        with self.lock:
+            session = self.sessions.get(webview)
+            if session and session.alive:
+                if cols is not None and rows is not None:
+                    session.resize(cols, rows)
+                return session
+            if session:
+                session.close()
+
+            c = cols if cols is not None else 80
+            r = rows if rows is not None else 24
+            session = TerminalSession(
+                webview, c, r,
+                on_close=lambda s: self._remove_session(webview, s)
+            )
+            self.sessions[webview] = session
+            return session
+
+    def _remove_session(self, webview, session):
+        with self.lock:
+            if self.sessions.get(webview) is session:
+                self.sessions.pop(webview, None)
+
+    def write_active(self, webview, text):
+        with self.lock:
+            session = self.sessions.get(webview)
+        if not session or not session.alive:
+            session = self.get_or_create(webview)
+        session.write(text)
+
+    def close_for_webview(self, webview):
+        with self.lock:
+            session = self.sessions.pop(webview, None)
+        if session:
+            session.close()
+
+    def close_all(self):
+        with self.lock:
+            sessions = list(self.sessions.values())
+            self.sessions.clear()
+        for s in sessions:
+            s.close()
+
+
+TERMINAL_MANAGER = TerminalManager()

stupidpythonbrowser-1.0.1.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: stupidpythonbrowser
+Version: 1.0.1
+Summary: Native macOS Chromium/Material 3 Web Browser in PyObjC & WebKit
+Author: avevall
+Classifier: Environment :: MacOS X :: Cocoa
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyobjc-core>=10.0
+Requires-Dist: pyobjc-framework-Cocoa>=10.0
+Requires-Dist: pyobjc-framework-WebKit>=10.0
+Requires-Dist: pyobjc-framework-Network>=10.0
+Requires-Dist: psutil>=5.9.0
+Dynamic: license-file
+
+# pythonbrowser
+This is mainly just a personal project, don't take it too seriously and don't expect too much out of it. 

stupidpythonbrowser-1.0.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+pybrowser/__init__.py,sha256=aJCcRt702Cy9fTLbE1N3qudmz28OxHG9SgrpPt4wHHY,217
+pybrowser/browser.py,sha256=dp_zsN_oHJ0p1b_t-L7eTa7ugIe2mPmE47Bmki8pUg8,154448
+pybrowser/doh_server.py,sha256=uLlyu5wvn0cXSr2aDKa2EjOlXN4Mhzz81WM53jSA0s4,15253
+pybrowser/incognito.py,sha256=GEc-xeVkElsDPzFIVLhTgSXtDHK3whTzxdnz7wYVJ0o,1675
+pybrowser/main.py,sha256=DwtxNLZ0PrhH0RPUn3UzPFSHQgHcnO7AHriElxxOP2A,2332
+pybrowser/settings.py,sha256=JCPBQumdJ-fTgBAatp2TVRCY8fIavA12255_eYWeIXI,38817
+pybrowser/task_manager.py,sha256=DRTazfw6MAqM360DkiMGIC0oZq6XuMBCpkMgHZAJ-II,15079
+pybrowser/terminal.py,sha256=3pXosw9IfpcuPE59lHDpahHMeJq5lVNt-OrRgAIDshc,15124
+stupidpythonbrowser-1.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+stupidpythonbrowser-1.0.1.dist-info/METADATA,sha256=yzzmqRIqveRn2vVhM0bdVLouTr9T4KTsHIniJVilQmk,977
+stupidpythonbrowser-1.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stupidpythonbrowser-1.0.1.dist-info/entry_points.txt,sha256=ntsWkCj6QvxpckUUie3agZV8YJQdV5tQMzYfPK4NopM,46
+stupidpythonbrowser-1.0.1.dist-info/top_level.txt,sha256=-Qio7UVGVcEO-lZkeLbyefDgD31D6lsx3CxPpKMipKE,10
+stupidpythonbrowser-1.0.1.dist-info/RECORD,,

stupidpythonbrowser-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stupidpythonbrowser-1.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[gui_scripts]
+pybrowser = pybrowser.main:main