PyVaultRCE 2.0.0__tar.gz

pyvaultrce-2.0.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: PyVaultRCE
+Version: 2.0.0
+Summary: Remote Code Execution & Hosting client for PyVault — source never exposed
+Author: PyVault
+Keywords: remote execution code hosting vault rce session
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Security
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PyVaultRCE
+
+Remote Code Execution & Hosting client for **PyVault**.
+
+Upload Python scripts to a PyVault server and execute them remotely — the source code **never leaves the server**. Clients only ever hold a 21-character hex Session ID.
+
+## Install
+
+```bash
+pip install PyVaultRCE
+```
+
+## Quick Start
+
+```python
+from pyvaultrce import CodeManager
+
+# Upload a local .py file → get Session ID
+sid = CodeManager.enc("my_script.py")
+# [PyVault] ✓ Uploaded  — Session ID : 3a7f1c9b2d0e8a5f41c7e
+
+# Upload from a paste service URL
+sid = CodeManager.enc_url("https://pastebin.com/abcXYZ123")
+
+# Execute remotely (source stays on server)
+CodeManager.run(sid)
+
+# Check metadata without incrementing execution counter
+CodeManager.info(sid)
+
+# Verify server is up
+CodeManager.ping()
+```
+
+## Configuration
+
+Set `PYVAULT_URL` to point at your hosted PyVault server:
+
+```bash
+export PYVAULT_URL=https://your-server.replit.app
+```
+
+## API Reference
+
+| Method | Description |
+|--------|-------------|
+| `CodeManager.enc(file_path)` | Upload a local `.py` file → returns Session ID |
+| `CodeManager.enc_url(url)` | Download code from a paste URL and upload → returns Session ID |
+| `CodeManager.run(session_id)` | Fetch and execute code by Session ID |
+| `CodeManager.info(session_id)` | Get session metadata (no exec count increment) |
+| `CodeManager.ping()` | Check server connectivity |
+| `CodeManager.edit(session_id, file_path, admin_token)` | Replace stored code (admin only) |
+
+## Supported Paste Services (`enc_url`)
+
+- `pastebin.com`
+- `hastebin.com`
+- `dpaste.com`
+- `paste.ofcode.org`
+- GitHub raw URLs
+- Any URL returning raw Python text
+
+## Error Handling
+
+| Exception | When |
+|---|---|
+| `FileNotFoundError` | Local file not found |
+| `ValueError` | Invalid Session ID or empty file |
+| `ConnectionError` | Server unreachable |
+| `TimeoutError` | Request timed out |
+| `RuntimeError` | Server error (404, 403, 500, etc.) |
+| `SyntaxError` | Remote code syntax error (during `run`) |
+
+## Security
+
+- Session IDs are 21-character cryptographically random hex strings
+- Source code is never written to disk on the client
+- Edit operations require a server-side admin token
+- Regular users cannot modify stored code
+
+## License
+
+MIT

pyvaultrce-2.0.0/PyVaultRCE.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: PyVaultRCE
+Version: 2.0.0
+Summary: Remote Code Execution & Hosting client for PyVault — source never exposed
+Author: PyVault
+Keywords: remote execution code hosting vault rce session
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Security
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PyVaultRCE
+
+Remote Code Execution & Hosting client for **PyVault**.
+
+Upload Python scripts to a PyVault server and execute them remotely — the source code **never leaves the server**. Clients only ever hold a 21-character hex Session ID.
+
+## Install
+
+```bash
+pip install PyVaultRCE
+```
+
+## Quick Start
+
+```python
+from pyvaultrce import CodeManager
+
+# Upload a local .py file → get Session ID
+sid = CodeManager.enc("my_script.py")
+# [PyVault] ✓ Uploaded  — Session ID : 3a7f1c9b2d0e8a5f41c7e
+
+# Upload from a paste service URL
+sid = CodeManager.enc_url("https://pastebin.com/abcXYZ123")
+
+# Execute remotely (source stays on server)
+CodeManager.run(sid)
+
+# Check metadata without incrementing execution counter
+CodeManager.info(sid)
+
+# Verify server is up
+CodeManager.ping()
+```
+
+## Configuration
+
+Set `PYVAULT_URL` to point at your hosted PyVault server:
+
+```bash
+export PYVAULT_URL=https://your-server.replit.app
+```
+
+## API Reference
+
+| Method | Description |
+|--------|-------------|
+| `CodeManager.enc(file_path)` | Upload a local `.py` file → returns Session ID |
+| `CodeManager.enc_url(url)` | Download code from a paste URL and upload → returns Session ID |
+| `CodeManager.run(session_id)` | Fetch and execute code by Session ID |
+| `CodeManager.info(session_id)` | Get session metadata (no exec count increment) |
+| `CodeManager.ping()` | Check server connectivity |
+| `CodeManager.edit(session_id, file_path, admin_token)` | Replace stored code (admin only) |
+
+## Supported Paste Services (`enc_url`)
+
+- `pastebin.com`
+- `hastebin.com`
+- `dpaste.com`
+- `paste.ofcode.org`
+- GitHub raw URLs
+- Any URL returning raw Python text
+
+## Error Handling
+
+| Exception | When |
+|---|---|
+| `FileNotFoundError` | Local file not found |
+| `ValueError` | Invalid Session ID or empty file |
+| `ConnectionError` | Server unreachable |
+| `TimeoutError` | Request timed out |
+| `RuntimeError` | Server error (404, 403, 500, etc.) |
+| `SyntaxError` | Remote code syntax error (during `run`) |
+
+## Security
+
+- Session IDs are 21-character cryptographically random hex strings
+- Source code is never written to disk on the client
+- Edit operations require a server-side admin token
+- Regular users cannot modify stored code
+
+## License
+
+MIT

pyvaultrce-2.0.0/PyVaultRCE.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+PyVaultRCE.egg-info/PKG-INFO
+PyVaultRCE.egg-info/SOURCES.txt
+PyVaultRCE.egg-info/dependency_links.txt
+PyVaultRCE.egg-info/requires.txt
+PyVaultRCE.egg-info/top_level.txt
+codemanager/__init__.py
+codemanager/manager.py
+pyvaultrce/__init__.py
+pyvaultrce/manager.py

pyvaultrce-2.0.0/PyVaultRCE.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyvaultrce-2.0.0/PyVaultRCE.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28.0

pyvaultrce-2.0.0/PyVaultRCE.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+codemanager
+pyvaultrce

pyvaultrce-2.0.0/README.md

@@ -0,0 +1,83 @@
+# PyVaultRCE
+
+Remote Code Execution & Hosting client for **PyVault**.
+
+Upload Python scripts to a PyVault server and execute them remotely — the source code **never leaves the server**. Clients only ever hold a 21-character hex Session ID.
+
+## Install
+
+```bash
+pip install PyVaultRCE
+```
+
+## Quick Start
+
+```python
+from pyvaultrce import CodeManager
+
+# Upload a local .py file → get Session ID
+sid = CodeManager.enc("my_script.py")
+# [PyVault] ✓ Uploaded  — Session ID : 3a7f1c9b2d0e8a5f41c7e
+
+# Upload from a paste service URL
+sid = CodeManager.enc_url("https://pastebin.com/abcXYZ123")
+
+# Execute remotely (source stays on server)
+CodeManager.run(sid)
+
+# Check metadata without incrementing execution counter
+CodeManager.info(sid)
+
+# Verify server is up
+CodeManager.ping()
+```
+
+## Configuration
+
+Set `PYVAULT_URL` to point at your hosted PyVault server:
+
+```bash
+export PYVAULT_URL=https://your-server.replit.app
+```
+
+## API Reference
+
+| Method | Description |
+|--------|-------------|
+| `CodeManager.enc(file_path)` | Upload a local `.py` file → returns Session ID |
+| `CodeManager.enc_url(url)` | Download code from a paste URL and upload → returns Session ID |
+| `CodeManager.run(session_id)` | Fetch and execute code by Session ID |
+| `CodeManager.info(session_id)` | Get session metadata (no exec count increment) |
+| `CodeManager.ping()` | Check server connectivity |
+| `CodeManager.edit(session_id, file_path, admin_token)` | Replace stored code (admin only) |
+
+## Supported Paste Services (`enc_url`)
+
+- `pastebin.com`
+- `hastebin.com`
+- `dpaste.com`
+- `paste.ofcode.org`
+- GitHub raw URLs
+- Any URL returning raw Python text
+
+## Error Handling
+
+| Exception | When |
+|---|---|
+| `FileNotFoundError` | Local file not found |
+| `ValueError` | Invalid Session ID or empty file |
+| `ConnectionError` | Server unreachable |
+| `TimeoutError` | Request timed out |
+| `RuntimeError` | Server error (404, 403, 500, etc.) |
+| `SyntaxError` | Remote code syntax error (during `run`) |
+
+## Security
+
+- Session IDs are 21-character cryptographically random hex strings
+- Source code is never written to disk on the client
+- Edit operations require a server-side admin token
+- Regular users cannot modify stored code
+
+## License
+
+MIT

pyvaultrce-2.0.0/codemanager/__init__.py

@@ -0,0 +1,25 @@
+"""
+codemanager — Remote Code Execution & Hosting PyPI Module
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Provides the CodeManager class to upload, execute, and edit
+Python scripts hosted on a PyVault backend — without exposing
+the source code to the client.
+
+Usage:
+    from codemanager import CodeManager
+
+    # Upload a local script and get a Session ID
+    session_id = CodeManager.enc("my_script.py")
+
+    # Execute the remote script by Session ID
+    CodeManager.run(session_id)
+
+    # Push an updated version of the script
+    CodeManager.edit(session_id, "my_script_v2.py")
+"""
+
+from .manager import CodeManager
+
+__all__ = ["CodeManager"]
+__version__ = "1.0.0"
+__author__  = "PyVault"

pyvaultrce-2.0.0/codemanager/manager.py

@@ -0,0 +1,318 @@
+"""
+manager.py — CodeManager implementation
+"""
+
+import os
+import sys
+import traceback
+import textwrap
+from typing import Optional
+
+try:
+    import requests
+except ImportError:
+    raise ImportError(
+        "The 'requests' library is required. Install it with: pip install requests"
+    )
+
+_DEFAULT_BASE_URL = os.environ.get("PYVAULT_URL", "http://localhost:5000")
+
+# ── Validation helpers ───────────────────────────────────────────────────────
+
+def _is_valid_session_id(session_id: str) -> bool:
+    return (
+        isinstance(session_id, str)
+        and len(session_id) == 21
+        and all(c in "0123456789abcdef" for c in session_id)
+    )
+
+
+def _validate_session_id(session_id: str) -> None:
+    if not _is_valid_session_id(session_id):
+        raise ValueError(
+            f"Invalid Session ID: '{session_id}'. "
+            "A Session ID must be exactly 21 lowercase hexadecimal characters."
+        )
+
+
+def _get_base_url(base_url: Optional[str]) -> str:
+    url = (base_url or _DEFAULT_BASE_URL).rstrip("/")
+    return url
+
+
+# ── CodeManager ─────────────────────────────────────────────────────────────
+
+class CodeManager:
+    """
+    Remote code management client for PyVault.
+
+    All methods are static so no instantiation is needed:
+
+        from codemanager import CodeManager
+        sid = CodeManager.enc("script.py")
+        CodeManager.run(sid)
+        CodeManager.edit(sid, "script_v2.py")
+    """
+
+    @staticmethod
+    def enc(
+        file_path: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+    ) -> str:
+        """
+        Read a local Python file and upload it to the PyVault backend.
+
+        Args:
+            file_path: Path to the local .py file to upload.
+            base_url:  Override the server URL (default: PYVAULT_URL env or localhost:5000).
+            timeout:   HTTP timeout in seconds.
+
+        Returns:
+            The 21-character hex Session ID assigned to this upload.
+
+        Raises:
+            FileNotFoundError: If file_path does not exist.
+            ValueError:        If the file is empty.
+            ConnectionError:   If the server is unreachable.
+            RuntimeError:      If the server returns an error response.
+        """
+        path = os.path.abspath(file_path)
+        if not os.path.isfile(path):
+            raise FileNotFoundError(
+                f"File not found: '{file_path}'. "
+                "Ensure the path is correct and the file exists."
+            )
+
+        try:
+            with open(path, "r", encoding="utf-8") as fh:
+                code = fh.read()
+        except UnicodeDecodeError:
+            with open(path, "r", encoding="latin-1") as fh:
+                code = fh.read()
+
+        if not code.strip():
+            raise ValueError(f"The file '{file_path}' is empty. Nothing to upload.")
+
+        url = _get_base_url(base_url) + "/pyv/save"
+        try:
+            response = requests.post(
+                url,
+                json={"code": code},
+                timeout=timeout,
+            )
+        except requests.exceptions.ConnectionError:
+            raise ConnectionError(
+                f"Unable to connect to PyVault at '{url}'. "
+                "Ensure the server is running and PYVAULT_URL is set correctly."
+            )
+        except requests.exceptions.Timeout:
+            raise TimeoutError(
+                f"Request to '{url}' timed out after {timeout}s. "
+                "Try increasing the timeout parameter or check the server."
+            )
+        except requests.exceptions.RequestException as exc:
+            raise ConnectionError(f"HTTP request failed: {exc}") from exc
+
+        if response.status_code != 201:
+            try:
+                err = response.json().get("error", response.text)
+            except Exception:
+                err = response.text
+            raise RuntimeError(
+                f"Server rejected the upload (HTTP {response.status_code}): {err}"
+            )
+
+        data = response.json()
+        session_id = data.get("session_id", "")
+        if not _is_valid_session_id(session_id):
+            raise RuntimeError(
+                f"Server returned an unexpected Session ID format: '{session_id}'"
+            )
+
+        print(f"[PyVault] ✓ Code uploaded successfully.")
+        print(f"[PyVault]   Session ID : {session_id}")
+        print(f"[PyVault]   File       : {path}")
+        print(f"[PyVault]   Size       : {len(code)} characters")
+        return session_id
+
+    @staticmethod
+    def run(
+        session_id: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+        globals_dict: Optional[dict] = None,
+    ) -> None:
+        """
+        Fetch the code for a Session ID from PyVault and execute it locally.
+
+        The source code is fetched over the network and run via exec() —
+        the caller never has direct access to the source file on disk.
+
+        Args:
+            session_id:   The 21-character hex Session ID.
+            base_url:     Override the server URL.
+            timeout:      HTTP timeout in seconds.
+            globals_dict: Optional globals dict passed to exec(). If None,
+                          a clean namespace is used to avoid polluting the
+                          caller's namespace.
+
+        Raises:
+            ValueError:    If the Session ID format is invalid.
+            ConnectionError: If the server is unreachable.
+            RuntimeError:  If the session is not found or the server errors.
+            Exception:     Re-raises any exception that occurs during exec().
+        """
+        _validate_session_id(session_id)
+
+        url = _get_base_url(base_url) + f"/pyv/get/{session_id}"
+        try:
+            response = requests.get(url, timeout=timeout)
+        except requests.exceptions.ConnectionError:
+            raise ConnectionError(
+                f"Unable to connect to PyVault at '{url}'. "
+                "Ensure the server is running and PYVAULT_URL is set correctly."
+            )
+        except requests.exceptions.Timeout:
+            raise TimeoutError(
+                f"Request timed out after {timeout}s while fetching session '{session_id}'."
+            )
+        except requests.exceptions.RequestException as exc:
+            raise ConnectionError(f"HTTP request failed: {exc}") from exc
+
+        if response.status_code == 404:
+            try:
+                err = response.json().get("error", "Session not found.")
+            except Exception:
+                err = "Session not found."
+            raise RuntimeError(
+                f"Session ID '{session_id}' was not found on the server. "
+                f"Server message: {err}"
+            )
+
+        if response.status_code != 200:
+            try:
+                err = response.json().get("error", response.text)
+            except Exception:
+                err = response.text
+            raise RuntimeError(
+                f"Server error (HTTP {response.status_code}): {err}"
+            )
+
+        data = response.json()
+        code = data.get("code", "")
+        exec_count = data.get("execution_count", "?")
+
+        if not code:
+            raise RuntimeError(
+                f"Server returned empty code for session '{session_id}'."
+            )
+
+        print(f"[PyVault] Executing session '{session_id}' (run #{exec_count})…")
+
+        namespace = globals_dict if globals_dict is not None else {
+            "__name__": "__pyvault__",
+            "__builtins__": __builtins__,
+        }
+
+        try:
+            compiled = compile(code, f"<pyvault:{session_id}>", "exec")
+            exec(compiled, namespace)
+        except SyntaxError as exc:
+            print(f"\n[PyVault] ✕ Syntax error in remote code:", file=sys.stderr)
+            print(f"  Line {exc.lineno}: {exc.msg}", file=sys.stderr)
+            if exc.text:
+                print(f"  >>> {exc.text.strip()}", file=sys.stderr)
+            raise
+        except Exception as exc:
+            print(f"\n[PyVault] ✕ Runtime error during execution:", file=sys.stderr)
+            tb_lines = traceback.format_exc().splitlines()
+            for line in tb_lines:
+                print(f"  {line}", file=sys.stderr)
+            raise
+
+        print(f"[PyVault] ✓ Execution complete.")
+
+    @staticmethod
+    def edit(
+        session_id: str,
+        file_path: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+    ) -> None:
+        """
+        Read a local Python file and push it as an update to an existing session.
+
+        Args:
+            session_id: The 21-character hex Session ID to update.
+            file_path:  Path to the local .py file with the updated code.
+            base_url:   Override the server URL.
+            timeout:    HTTP timeout in seconds.
+
+        Raises:
+            ValueError:       If the Session ID format is invalid.
+            FileNotFoundError: If file_path does not exist.
+            ValueError:       If the file is empty.
+            ConnectionError:  If the server is unreachable.
+            RuntimeError:     If the session is not found or the server errors.
+        """
+        _validate_session_id(session_id)
+
+        path = os.path.abspath(file_path)
+        if not os.path.isfile(path):
+            raise FileNotFoundError(
+                f"File not found: '{file_path}'. "
+                "Ensure the path is correct and the file exists."
+            )
+
+        try:
+            with open(path, "r", encoding="utf-8") as fh:
+                code = fh.read()
+        except UnicodeDecodeError:
+            with open(path, "r", encoding="latin-1") as fh:
+                code = fh.read()
+
+        if not code.strip():
+            raise ValueError(f"The file '{file_path}' is empty. Nothing to upload.")
+
+        url = _get_base_url(base_url) + f"/pyv/edit/{session_id}"
+        try:
+            response = requests.put(
+                url,
+                json={"code": code},
+                timeout=timeout,
+            )
+        except requests.exceptions.ConnectionError:
+            raise ConnectionError(
+                f"Unable to connect to PyVault at '{url}'. "
+                "Ensure the server is running and PYVAULT_URL is set correctly."
+            )
+        except requests.exceptions.Timeout:
+            raise TimeoutError(
+                f"Request timed out after {timeout}s while editing session '{session_id}'."
+            )
+        except requests.exceptions.RequestException as exc:
+            raise ConnectionError(f"HTTP request failed: {exc}") from exc
+
+        if response.status_code == 404:
+            try:
+                err = response.json().get("error", "Session not found.")
+            except Exception:
+                err = "Session not found."
+            raise RuntimeError(
+                f"Session ID '{session_id}' was not found. Cannot edit a non-existent session. "
+                f"Server message: {err}"
+            )
+
+        if response.status_code != 200:
+            try:
+                err = response.json().get("error", response.text)
+            except Exception:
+                err = response.text
+            raise RuntimeError(
+                f"Server rejected the edit (HTTP {response.status_code}): {err}"
+            )
+
+        print(f"[PyVault] ✓ Session '{session_id}' updated successfully.")
+        print(f"[PyVault]   File : {path}")
+        print(f"[PyVault]   Size : {len(code)} characters")

pyvaultrce-2.0.0/pyvaultrce/__init__.py

@@ -0,0 +1,22 @@
+"""
+pyvaultrce — Remote Code Execution & Hosting Module for PyVault
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Upload Python scripts to a PyVault server and execute them remotely.
+The source code never leaves the server — clients only ever hold a
+21-character hex Session ID.
+
+Quick start:
+    from pyvaultrce import CodeManager
+
+    sid = CodeManager.enc("script.py")          # upload local file
+    sid = CodeManager.enc_url("https://...")     # upload from paste URL
+    CodeManager.run(sid)                         # execute remotely
+    CodeManager.info(sid)                        # check metadata
+    CodeManager.ping()                           # verify server is up
+"""
+
+from .manager import CodeManager
+
+__all__    = ["CodeManager"]
+__version__ = "2.0.0"
+__author__  = "PyVault"

pyvaultrce-2.0.0/pyvaultrce/manager.py

@@ -0,0 +1,438 @@
+"""
+manager.py — CodeManager implementation for PyVaultRCE
+"""
+
+import os
+import re
+import sys
+import traceback
+from typing import Optional
+
+try:
+    import requests
+except ImportError:
+    raise ImportError(
+        "The 'requests' library is required. Install it with: pip install requests"
+    )
+
+_DEFAULT_BASE = os.environ.get("PYVAULT_URL", "http://localhost:5000")
+_MAX_CHARS    = 10_000
+_SID_LEN      = 21
+_HEX_SET      = frozenset("0123456789abcdef")
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _base(url: Optional[str]) -> str:
+    return (url or _DEFAULT_BASE).rstrip("/")
+
+
+def _valid_sid(sid: str) -> bool:
+    return isinstance(sid, str) and len(sid) == _SID_LEN and all(c in _HEX_SET for c in sid)
+
+
+def _check_sid(sid: str) -> None:
+    if not _valid_sid(sid):
+        raise ValueError(
+            f"Invalid Session ID: '{sid}'. "
+            f"Must be exactly {_SID_LEN} lowercase hexadecimal characters."
+        )
+
+
+def _read_file(path: str) -> str:
+    path = os.path.abspath(path)
+    if not os.path.isfile(path):
+        raise FileNotFoundError(
+            f"File not found: '{path}'. Check the path and try again."
+        )
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            return fh.read()
+    except UnicodeDecodeError:
+        with open(path, "r", encoding="latin-1") as fh:
+            return fh.read()
+
+
+def _resolve_paste_url(url: str) -> str:
+    """
+    Rewrite common paste service URLs to their raw endpoints.
+    Supports pastebin.com, hastebin.com, dpaste.com, paste.ofcode.org,
+    GitHub Gist raw URLs, and any URL already pointing to raw text.
+    """
+    # pastebin.com/XXXX → pastebin.com/raw/XXXX
+    url = re.sub(
+        r"(https?://pastebin\.com/)(?!raw/)([A-Za-z0-9]+)(\?.*)?$",
+        r"\1raw/\2",
+        url,
+    )
+    # hastebin.com/XXXX → hastebin.com/raw/XXXX
+    url = re.sub(
+        r"(https?://hastebin\.com/)(?!raw/)([A-Za-z0-9]+)(\?.*)?$",
+        r"\1raw/\2",
+        url,
+    )
+    # dpaste.com/XXXX → dpaste.com/XXXX.txt
+    url = re.sub(
+        r"(https?://dpaste\.com/)([A-Z0-9]+)(?!\.txt)(\?.*)?$",
+        r"\1\2.txt",
+        url,
+    )
+    # paste.ofcode.org/XXXX → paste.ofcode.org/raw/XXXX
+    url = re.sub(
+        r"(https?://paste\.ofcode\.org/)(?!raw/)([A-Za-z0-9]+)(\?.*)?$",
+        r"\1raw/\2",
+        url,
+    )
+    return url
+
+
+def _http_post(url: str, payload: dict, timeout: int) -> requests.Response:
+    try:
+        return requests.post(url, json=payload, timeout=timeout)
+    except requests.exceptions.ConnectionError:
+        raise ConnectionError(
+            f"Unable to connect to PyVault at '{url}'. "
+            "Ensure the server is running and PYVAULT_URL is set correctly."
+        )
+    except requests.exceptions.Timeout:
+        raise TimeoutError(f"Request to '{url}' timed out after {timeout}s.")
+    except requests.exceptions.RequestException as exc:
+        raise ConnectionError(f"HTTP request failed: {exc}") from exc
+
+
+def _http_get(url: str, timeout: int, headers: Optional[dict] = None) -> requests.Response:
+    try:
+        return requests.get(url, timeout=timeout, headers=headers or {})
+    except requests.exceptions.ConnectionError:
+        raise ConnectionError(
+            f"Unable to connect at '{url}'. "
+            "Ensure the server is running and PYVAULT_URL is set correctly."
+        )
+    except requests.exceptions.Timeout:
+        raise TimeoutError(f"Request to '{url}' timed out after {timeout}s.")
+    except requests.exceptions.RequestException as exc:
+        raise ConnectionError(f"HTTP request failed: {exc}") from exc
+
+
+def _upload_code(code: str, base_url: Optional[str], timeout: int) -> str:
+    """Internal: push code string to /pyv/save and return the session ID."""
+    if not code.strip():
+        raise ValueError("Code is empty — nothing to upload.")
+    if len(code) > _MAX_CHARS:
+        raise ValueError(
+            f"Code is {len(code):,} characters, which exceeds the server limit of {_MAX_CHARS:,}."
+        )
+    url  = _base(base_url) + "/pyv/save"
+    resp = _http_post(url, {"code": code}, timeout)
+    if resp.status_code != 201:
+        try:
+            err = resp.json().get("error", resp.text)
+        except Exception:
+            err = resp.text
+        raise RuntimeError(f"Server rejected upload (HTTP {resp.status_code}): {err}")
+    data = resp.json()
+    sid  = data.get("session_id", "")
+    if not _valid_sid(sid):
+        raise RuntimeError(f"Server returned unexpected Session ID: '{sid}'")
+    return sid
+
+
+# ── CodeManager ───────────────────────────────────────────────────────────────
+
+class CodeManager:
+    """
+    Remote code management client for PyVault.
+
+    All methods are static — no instantiation required.
+
+    Typical flow:
+        from pyvaultrce import CodeManager
+
+        sid = CodeManager.enc("script.py")
+        CodeManager.run(sid)
+
+    Environment variables:
+        PYVAULT_URL — base URL of the PyVault server (default: http://localhost:5000)
+    """
+
+    @staticmethod
+    def enc(
+        file_path: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+    ) -> str:
+        """
+        Read a local .py file and upload it to PyVault.
+
+        Args:
+            file_path: Path to the local Python file.
+            base_url:  Override the server URL.
+            timeout:   HTTP timeout in seconds.
+
+        Returns:
+            The 21-character hex Session ID.
+
+        Raises:
+            FileNotFoundError, ValueError, ConnectionError, RuntimeError
+        """
+        code = _read_file(file_path)
+        if not code.strip():
+            raise ValueError(f"The file '{file_path}' is empty — nothing to upload.")
+        sid = _upload_code(code, base_url, timeout)
+        print(f"[PyVault] ✓ Uploaded  — Session ID : {sid}", flush=True)
+        print(f"[PyVault]   Source    : {os.path.abspath(file_path)}", flush=True)
+        print(f"[PyVault]   Size      : {len(code):,} chars", flush=True)
+        return sid
+
+    @staticmethod
+    def enc_url(
+        paste_url: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+    ) -> str:
+        """
+        Download Python code from a paste service URL and upload to PyVault.
+
+        Automatically rewrites paste service links to their raw endpoints
+        (pastebin.com, hastebin.com, dpaste.com, paste.ofcode.org, GitHub raw).
+
+        Args:
+            paste_url: URL pointing to Python source code.
+            base_url:  Override the server URL.
+            timeout:   HTTP timeout in seconds.
+
+        Returns:
+            The 21-character hex Session ID.
+
+        Raises:
+            ValueError, ConnectionError, RuntimeError
+        """
+        raw_url = _resolve_paste_url(paste_url.strip())
+        try:
+            resp = requests.get(
+                raw_url,
+                timeout=timeout,
+                headers={"User-Agent": "PyVaultRCE/2.0"},
+            )
+            resp.raise_for_status()
+        except requests.exceptions.ConnectionError:
+            raise ConnectionError(f"Could not fetch code from '{paste_url}'.")
+        except requests.exceptions.HTTPError as exc:
+            raise RuntimeError(
+                f"Failed to download from '{paste_url}': HTTP {exc.response.status_code}"
+            )
+        except requests.exceptions.Timeout:
+            raise TimeoutError(f"Timed out fetching '{paste_url}'.")
+        except requests.exceptions.RequestException as exc:
+            raise ConnectionError(f"HTTP request failed: {exc}") from exc
+
+        code = resp.text
+        if not code.strip():
+            raise ValueError("Downloaded content is empty.")
+
+        sid = _upload_code(code, base_url, timeout)
+        print(f"[PyVault] ✓ Uploaded from URL — Session ID : {sid}", flush=True)
+        print(f"[PyVault]   Source : {paste_url}", flush=True)
+        print(f"[PyVault]   Size   : {len(code):,} chars", flush=True)
+        return sid
+
+    @staticmethod
+    def run(
+        session_id: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+        _ns: Optional[dict] = None,
+    ) -> None:
+        """
+        Fetch the code for a Session ID from PyVault and execute it locally.
+
+        The source code is transmitted over the network and run via exec().
+        It is never written to disk and is not accessible after execution.
+
+        Args:
+            session_id: The 21-character hex Session ID.
+            base_url:   Override the server URL.
+            timeout:    HTTP timeout in seconds.
+            _ns:        Optional namespace dict passed to exec(). Leave as None
+                        unless you intentionally want to share a namespace.
+
+        Raises:
+            ValueError, ConnectionError, RuntimeError, plus any exception
+            raised by the remote code itself.
+        """
+        _check_sid(session_id)
+
+        url  = _base(base_url) + f"/pyv/get/{session_id}"
+        resp = _http_get(url, timeout)
+
+        if resp.status_code == 404:
+            try:
+                err = resp.json().get("error", "Session not found.")
+            except Exception:
+                err = "Session not found."
+            raise RuntimeError(
+                f"Session '{session_id}' not found on the server. {err}"
+            )
+        if resp.status_code != 200:
+            try:
+                err = resp.json().get("error", resp.text)
+            except Exception:
+                err = resp.text
+            raise RuntimeError(f"Server error (HTTP {resp.status_code}): {err}")
+
+        data      = resp.json()
+        code      = data.get("code", "")
+        run_count = data.get("execution_count", "?")
+
+        if not code:
+            raise RuntimeError(f"Server returned empty code for session '{session_id}'.")
+
+        print(f"[PyVault] ▶ Running session '{session_id}' (execution #{run_count})…", flush=True)
+
+        namespace = _ns if _ns is not None else {
+            "__name__": "__pyvault__",
+            "__builtins__": __builtins__,
+        }
+
+        try:
+            exec(compile(code, f"<vault:{session_id[:8]}…>", "exec"), namespace)
+        except SyntaxError as exc:
+            print(f"\n[PyVault] ✕ Syntax error:", file=sys.stderr, flush=True)
+            print(f"  Line {exc.lineno}: {exc.msg}", file=sys.stderr)
+            if exc.text:
+                print(f"  >>> {exc.text.strip()}", file=sys.stderr)
+            raise
+        except Exception:
+            print(f"\n[PyVault] ✕ Runtime error:", file=sys.stderr, flush=True)
+            for line in traceback.format_exc().splitlines():
+                print(f"  {line}", file=sys.stderr)
+            raise
+
+        print(f"[PyVault] ✓ Execution complete.", flush=True)
+
+    @staticmethod
+    def info(
+        session_id: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+    ) -> dict:
+        """
+        Fetch metadata for a Session ID without executing the code and without
+        incrementing the execution counter.
+
+        Returns:
+            dict with keys: session_id, execution_count, created_at, code_size
+
+        Raises:
+            ValueError, ConnectionError, RuntimeError
+        """
+        _check_sid(session_id)
+        url  = _base(base_url) + f"/pyv/info/{session_id}"
+        resp = _http_get(url, timeout)
+        if resp.status_code == 404:
+            raise RuntimeError(f"Session '{session_id}' not found.")
+        if resp.status_code != 200:
+            try:
+                err = resp.json().get("error", resp.text)
+            except Exception:
+                err = resp.text
+            raise RuntimeError(f"Server error (HTTP {resp.status_code}): {err}")
+        data = resp.json()
+        print(
+            f"[PyVault] ℹ Session   : {data['session_id']}\n"
+            f"[PyVault]   Executions: {data['execution_count']}\n"
+            f"[PyVault]   Created   : {data['created_at']}\n"
+            f"[PyVault]   Code size : {data['code_size']:,} chars",
+            flush=True,
+        )
+        return data
+
+    @staticmethod
+    def ping(
+        base_url: Optional[str] = None,
+        timeout: int = 10,
+    ) -> bool:
+        """
+        Check whether the PyVault server is reachable.
+
+        Returns:
+            True if server responded with valid stats, False otherwise.
+        """
+        url = _base(base_url) + "/pyv/stats"
+        try:
+            resp = requests.get(url, timeout=timeout)
+            if resp.status_code == 200:
+                d = resp.json()
+                print(
+                    f"[PyVault] ✓ Server online — "
+                    f"{d.get('total_sessions', '?')} sessions, "
+                    f"{d.get('total_executions', '?')} total executions.",
+                    flush=True,
+                )
+                return True
+        except Exception:
+            pass
+        print(f"[PyVault] ✕ Server unreachable at '{_base(base_url)}'.", flush=True)
+        return False
+
+    @staticmethod
+    def edit(
+        session_id: str,
+        file_path: str,
+        admin_token: str,
+        base_url: Optional[str] = None,
+        timeout: int = 30,
+    ) -> None:
+        """
+        Replace the code stored for a Session ID (admin-only operation).
+
+        Requires the admin access token from the PyVault server.
+
+        Args:
+            session_id:  The 21-character hex Session ID to update.
+            file_path:   Path to the .py file with the new code.
+            admin_token: Admin access token (from server console on first start).
+            base_url:    Override the server URL.
+            timeout:     HTTP timeout in seconds.
+
+        Raises:
+            ValueError, FileNotFoundError, ConnectionError, RuntimeError
+        """
+        _check_sid(session_id)
+        if not admin_token or not admin_token.strip():
+            raise ValueError("admin_token is required. Check the server console for your token.")
+
+        code = _read_file(file_path)
+        if not code.strip():
+            raise ValueError(f"The file '{file_path}' is empty — nothing to upload.")
+        if len(code) > _MAX_CHARS:
+            raise ValueError(f"Code is {len(code):,} chars, exceeds {_MAX_CHARS:,} limit.")
+
+        url = _base(base_url) + f"/pyv/edit/{session_id}"
+        try:
+            resp = requests.put(
+                url,
+                json={"code": code},
+                headers={"X-Admin-Token": admin_token},
+                timeout=timeout,
+            )
+        except requests.exceptions.ConnectionError:
+            raise ConnectionError(f"Unable to connect to PyVault at '{url}'.")
+        except requests.exceptions.Timeout:
+            raise TimeoutError(f"Request timed out after {timeout}s.")
+        except requests.exceptions.RequestException as exc:
+            raise ConnectionError(f"HTTP request failed: {exc}") from exc
+
+        if resp.status_code == 403:
+            raise RuntimeError("Admin token rejected. Check your token and try again.")
+        if resp.status_code == 404:
+            raise RuntimeError(f"Session '{session_id}' not found.")
+        if resp.status_code != 200:
+            try:
+                err = resp.json().get("error", resp.text)
+            except Exception:
+                err = resp.text
+            raise RuntimeError(f"Server rejected edit (HTTP {resp.status_code}): {err}")
+
+        print(f"[PyVault] ✓ Session '{session_id}' updated.", flush=True)
+        print(f"[PyVault]   File : {os.path.abspath(file_path)}", flush=True)
+        print(f"[PyVault]   Size : {len(code):,} chars", flush=True)

pyvaultrce-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyvaultrce-2.0.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="PyVaultRCE",
+    version="2.0.0",
+    author="PyVault",
+    description="Remote Code Execution & Hosting client for PyVault — source never exposed",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=[
+        "requests>=2.28.0",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Software Development :: Libraries",
+        "Topic :: Security",
+        "Topic :: Internet :: WWW/HTTP",
+    ],
+    keywords="remote execution code hosting vault rce session",
+    entry_points={},
+)