hypha-debugger 0.1.8__tar.gz → 0.1.10__tar.gz

{hypha_debugger-0.1.8 → hypha_debugger-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha-debugger
-Version: 0.1.8
+Version: 0.1.10
 Summary: Injectable debugger for Python processes and AI agents, powered by Hypha RPC
 Author: Amun AI AB
 License: MIT

{hypha_debugger-0.1.8 → hypha_debugger-0.1.10}/hypha_debugger/__init__.py

@@ -12,5 +12,5 @@ Usage (sync):
 
 from hypha_debugger.debugger import start_debugger, start_debugger_sync, DebugSession
 
-__version__ = "0.1.8"
+__version__ = "0.1.10"
 __all__ = ["start_debugger", "start_debugger_sync", "DebugSession", "__version__"]

{hypha_debugger-0.1.8 → hypha_debugger-0.1.10}/hypha_debugger/services/filesystem.py

@@ -1,4 +1,4 @@
-"""File system browsing and writing service (sandboxed to CWD)."""
+"""File system browsing and writing service."""
 
 import os
 
@@ -10,19 +10,19 @@ try:
     def list_files(
         path: str = Field(
             default=".",
-            description='Directory path relative to CWD. Default: "." (current directory).',
+            description='Directory path (absolute or relative to CWD). Default: ".".',
         ),
         pattern: str = Field(
             default="",
             description='Glob pattern to filter files, e.g. "*.py".',
         ),
     ) -> dict:
-        """List files and directories in a path relative to the process CWD."""
+        """List files and directories at the given path."""
         return _list_files_impl(path, pattern)
 
     @schema_function
     def read_file(
-        path: str = Field(..., description="File path relative to CWD."),
+        path: str = Field(..., description="File path (absolute or relative to CWD)."),
         max_lines: int = Field(
             default=500,
             description="Maximum number of lines to read. Default: 500.",
@@ -36,7 +36,7 @@ try:
             description="File encoding. Default: utf-8.",
         ),
     ) -> dict:
-        """Read a file relative to the process CWD. Returns the content as a string.
+        """Read a file. Returns the content as a string.
 
         Use offset and max_lines to paginate through large files.
         """
@@ -44,7 +44,7 @@ try:
 
     @schema_function
     def write_file(
-        path: str = Field(..., description="File path relative to CWD."),
+        path: str = Field(..., description="File path (absolute or relative to CWD)."),
         content: str = Field(..., description="Content to write to the file."),
         mode: str = Field(
             default="w",
@@ -59,47 +59,39 @@ try:
             description="File encoding. Default: utf-8.",
         ),
     ) -> dict:
-        """Write content to a file relative to the process CWD.
+        """Write content to a file.
 
         Creates parent directories automatically. Use mode="a" to append.
-        Sandboxed: cannot write outside the process CWD.
         """
         return _write_file_impl(path, content, mode, create_dirs, encoding)
 
 except ImportError:
 
     def list_files(path: str = ".", pattern: str = "") -> dict:
-        """List files and directories in a path relative to CWD."""
+        """List files and directories at the given path."""
         return _list_files_impl(path, pattern)
 
     def read_file(
         path: str = "", max_lines: int = 500, offset: int = 0, encoding: str = "utf-8"
     ) -> dict:
-        """Read a file relative to CWD."""
+        """Read a file."""
         return _read_file_impl(path, max_lines, offset, encoding)
 
     def write_file(
         path: str = "", content: str = "", mode: str = "w",
         create_dirs: bool = True, encoding: str = "utf-8"
     ) -> dict:
-        """Write content to a file relative to CWD."""
+        """Write content to a file."""
         return _write_file_impl(path, content, mode, create_dirs, encoding)
 
 
-def _resolve_safe(path: str) -> str:
-    """Resolve path and ensure it's within CWD."""
-    cwd = os.path.realpath(os.getcwd())
-    resolved = os.path.realpath(os.path.join(cwd, path))
-    if not resolved.startswith(cwd):
-        raise PermissionError(f"Access denied: path escapes CWD ({path})")
-    return resolved
+def _resolve(path: str) -> str:
+    """Resolve path to absolute."""
+    return os.path.realpath(os.path.expanduser(path))
 
 
 def _list_files_impl(path: str, pattern: str) -> dict:
-    try:
-        resolved = _resolve_safe(path)
-    except PermissionError as e:
-        return {"error": str(e)}
+    resolved = _resolve(path)
 
     if not os.path.isdir(resolved):
         return {"error": f"Not a directory: {path}"}
@@ -123,7 +115,7 @@ def _list_files_impl(path: str, pattern: str) -> dict:
         return {"error": f"Permission denied: {path}"}
 
     return {
-        "path": os.path.relpath(resolved, os.getcwd()),
+        "path": resolved,
         "entries": entries[:500],
         "total": len(entries),
     }
@@ -144,10 +136,7 @@ def _entry_info(name: str, full_path: str) -> dict:
 
 
 def _read_file_impl(path: str, max_lines: int, offset: int, encoding: str) -> dict:
-    try:
-        resolved = _resolve_safe(path)
-    except PermissionError as e:
-        return {"error": str(e)}
+    resolved = _resolve(path)
 
     if not os.path.isfile(resolved):
         return {"error": f"Not a file: {path}"}
@@ -163,7 +152,7 @@ def _read_file_impl(path: str, max_lines: int, offset: int, encoding: str) -> di
                 lines.append(line)
         content = "".join(lines)
         return {
-            "path": os.path.relpath(resolved, os.getcwd()),
+            "path": resolved,
             "content": content,
             "lines_read": len(lines),
             "offset": offset,
@@ -179,20 +168,19 @@ def _write_file_impl(
     if mode not in ("w", "a"):
         return {"error": f'Invalid mode: {mode}. Use "w" or "a".'}
 
-    try:
-        resolved = _resolve_safe(path)
-    except PermissionError as e:
-        return {"error": str(e)}
+    resolved = _resolve(path)
 
     try:
         if create_dirs:
-            os.makedirs(os.path.dirname(resolved), exist_ok=True)
+            parent = os.path.dirname(resolved)
+            if parent:
+                os.makedirs(parent, exist_ok=True)
 
         with open(resolved, mode, encoding=encoding) as f:
             f.write(content)
 
         return {
-            "path": os.path.relpath(resolved, os.getcwd()),
+            "path": resolved,
             "bytes_written": len(content.encode(encoding)),
             "mode": mode,
         }

{hypha_debugger-0.1.8 → hypha_debugger-0.1.10}/hypha_debugger/services/source.py

@@ -87,104 +87,90 @@ def _get_skill_md_impl() -> str:
     return """# Hypha Remote Debugger — Python Process API
 
 ## Overview
-A debugger is attached to a running Python process. You can remotely execute code,
-read/write files, inspect variables, and query process info via the HTTP API.
+A remote debugger is attached to a running Python process. You have full access
+to execute code, read/write files, inspect variables, and install packages.
 
-## Functions
+**Recommended approach**: Use `execute_code` as your primary tool — it's a
+persistent Python REPL where variables, imports, and functions survive across
+calls. The other endpoints are convenience shortcuts.
 
-### get_process_info()
-Get information about the current Python process.
-- **Returns**: `{pid, cwd, python_version, hostname, platform, memory_mb, cpu_count, ...}`
-- **Example**: `curl "$SERVICE_URL/get_process_info"`
+## Quick Start
 
-### execute_code(code, namespace?, timeout?)
-Execute arbitrary Python code in the process. Uses AST parsing to automatically
-capture the last expression's value. Variables, functions, and imports persist
-across calls in the default REPL namespace.
-- **code** (string, required): Python code to execute.
-- **namespace** (string, default `""`): Namespace. Empty = persistent REPL. `"__main__"` = main module.
-- **timeout** (int, default `30`): Timeout in seconds. 0 for no timeout.
-- **Returns**: `{ok, stdout, stderr, result, result_repr, result_type, error?, error_type?, error_message?, traceback?, timed_out?}`
-- The last expression in the code block is automatically captured as `result`.
-  E.g. `"x = 1\\nx + 1"` returns `result=2`.
-- **Example**:
-  ```bash
-  curl -X POST "$SERVICE_URL/execute_code" \\
-    -H "Content-Type: application/json" \\
-    -d '{"code": "import sys; sys.version"}'
-  ```
+```bash
+# Set the service URL (provided when debugger starts)
+SERVICE_URL="<your-service-url>"
 
-### get_variable(name, namespace?)
-Inspect a variable by name.
-- **name** (string, required): Variable name.
-- **namespace** (string, default `"__main__"`): Module namespace.
-- **Returns**: `{name, type, repr, length?, shape?, dtype?, keys?}`
+# Run Python code (persistent REPL — variables survive across calls):
+curl -X POST "$SERVICE_URL/execute_code" \\
+  -H "Content-Type: application/json" \\
+  -d '{"code": "import os; os.listdir(\\".\\")"}'
 
-### list_variables(namespace?, filter?, include_private?)
-List variables in a namespace.
-- **namespace** (string, default `"__main__"`): Module namespace.
-- **filter** (string): Substring filter for names.
-- **include_private** (bool, default `false`): Include `_`-prefixed names.
-- **Returns**: List of `{name, type, repr}`.
+# Install a package:
+curl -X POST "$SERVICE_URL/execute_code" \\
+  -H "Content-Type: application/json" \\
+  -d '{"code": "import subprocess; subprocess.check_output([\\\"pip\\\", \\\"install\\\", \\\"requests\\\"])"}'
 
-### get_stack_trace()
-Get stack traces of all threads.
-- **Returns**: List of `{thread_id, thread_name, stack}`.
-- **Example**: `curl "$SERVICE_URL/get_stack_trace"`
+# Write a file via execute_code (avoids JSON escaping issues):
+curl -X POST "$SERVICE_URL/execute_code" \\
+  -H "Content-Type: application/json" \\
+  -d '{"code": "with open(\\\"hello.py\\\", \\\"w\\\") as f: f.write(\\\"print(42)\\\\n\\\")"}'
+```
+
+## Functions
+
+### execute_code(code, namespace?, timeout?) — PRIMARY
+Execute Python code in a persistent REPL. The last expression is automatically
+captured as the return value via AST parsing.
+- **code** (str, required): Python code to execute.
+- **namespace** (str, default `""`): Empty = persistent REPL, `"__main__"` = main module.
+- **timeout** (int, default `30`): Seconds. 0 = no timeout.
+- **Returns**: `{ok, stdout, stderr, result, result_repr, result_type, error?, error_type?, error_message?, traceback?, timed_out?}`
+- Variables, functions, and imports persist across calls.
+- Example: `"x = 1\\nx + 1"` returns `{ok: true, result: 2}`.
+
+### get_process_info()
+PID, CWD, Python version, hostname, platform, memory usage, CPU count.
+- **Example**: `curl "$SERVICE_URL/get_process_info"`
 
 ### list_files(path?, pattern?)
-List files and directories (sandboxed to CWD).
-- **path** (string, default `"."`): Directory path relative to CWD.
-- **pattern** (string): Glob filter, e.g. `"*.py"`.
+List directory contents. Accepts absolute or relative paths.
+- **path** (str, default `"."`), **pattern** (str): glob filter e.g. `"*.py"`.
 - **Returns**: `{path, entries: [{name, type, size?}], total}`
-- **Example**: `curl "$SERVICE_URL/list_files"`
 
 ### read_file(path, max_lines?, offset?, encoding?)
-Read a file (sandboxed to CWD).
-- **path** (string, required): File path relative to CWD.
-- **max_lines** (int, default `500`): Max lines to read.
-- **offset** (int, default `0`): Lines to skip from beginning.
+Read a file. Accepts absolute or relative paths.
+- **path** (str, required), **max_lines** (int, default `500`), **offset** (int, default `0`).
 - **Returns**: `{path, content, lines_read, offset, truncated}`
-- **Example**:
-  ```bash
-  curl -X POST "$SERVICE_URL/read_file" \\
-    -H "Content-Type: application/json" \\
-    -d '{"path": "main.py"}'
-  ```
 
 ### write_file(path, content, mode?, create_dirs?, encoding?)
-Write content to a file (sandboxed to CWD).
-- **path** (string, required): File path relative to CWD.
-- **content** (string, required): Content to write.
-- **mode** (string, default `"w"`): `"w"` to overwrite, `"a"` to append.
-- **create_dirs** (bool, default `true`): Create parent directories.
+Write/append to a file. Auto-creates parent dirs. Accepts absolute or relative paths.
+- **path** (str), **content** (str), **mode** (`"w"` or `"a"`).
 - **Returns**: `{path, bytes_written, mode}`
-- **Example**:
-  ```bash
-  curl -X POST "$SERVICE_URL/write_file" \\
-    -H "Content-Type: application/json" \\
-    -d '{"path": "hello.txt", "content": "Hello!"}'
-  ```
+
+### get_variable(name, namespace?)
+Inspect a variable by name in a module namespace.
+- **Returns**: `{name, type, repr, length?, shape?, dtype?, keys?}`
+
+### list_variables(namespace?, filter?, include_private?)
+List variables in a namespace. Filters by substring.
+
+### get_stack_trace()
+Stack traces of all threads. Useful for debugging hangs.
 
 ### get_installed_packages(filter?)
-List installed pip packages.
-- **filter** (string): Substring filter for package names.
-- **Returns**: List of `{name, version}`.
-- **Example**: `curl "$SERVICE_URL/get_installed_packages"`
+List pip packages. Optional name substring filter.
 
 ### get_source(module?)
-Get the source code of debugger modules.
-- **module** (string): Module path, e.g. `"services.execute"`. Empty to list modules.
-- **Returns**: `{module, source, lines}` or `{modules, hint}`.
+Get debugger source code. Empty = list modules, e.g. `"services.execute"`.
 
 ### get_skill_md()
-Get this API documentation as Markdown.
-- **Returns**: This document as a string.
-- **Example**: `curl "$SERVICE_URL/get_skill_md"`
-
-## Notes
-- All file operations are sandboxed to the process CWD.
-- POST endpoints accept JSON body with parameter names as keys.
-- GET endpoints take no parameters (or use query params).
-- Code execution has a default 30s timeout to prevent hangs.
+Returns this document.
+
+## Tips
+- **Use `execute_code` for file writes** when content has special characters —
+  it avoids JSON/curl escaping issues that affect `write_file` via HTTP.
+- File operations accept absolute paths or paths relative to the process CWD.
+- POST endpoints accept JSON body. GET endpoints take no body.
+- Code execution has a 30s default timeout to prevent hangs.
+- The REPL namespace is independent from `__main__` by default.
 """

{hypha_debugger-0.1.8 → hypha_debugger-0.1.10}/hypha_debugger.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha-debugger
-Version: 0.1.8
+Version: 0.1.10
 Summary: Injectable debugger for Python processes and AI agents, powered by Hypha RPC
 Author: Amun AI AB
 License: MIT

{hypha_debugger-0.1.8 → hypha_debugger-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypha-debugger"
-version = "0.1.8"
+version = "0.1.10"
 description = "Injectable debugger for Python processes and AI agents, powered by Hypha RPC"
 readme = "README.md"
 license = {text = "MIT"}

{hypha_debugger-0.1.8 → hypha_debugger-0.1.10}/tests/test_services.py

@@ -185,10 +185,13 @@ def test_read_file_with_offset():
     assert result["lines_read"] <= 2
 
 
-def test_read_file_sandbox():
-    result = read_file("../../etc/passwd")
-    assert "error" in result
-    assert "Access denied" in result["error"] or "Not a file" in result["error"]
+def test_read_file_absolute():
+    """Can read files by absolute path."""
+    import pathlib
+    toml_path = str(pathlib.Path("pyproject.toml").resolve())
+    result = read_file(toml_path)
+    assert result.get("error") is None
+    assert "hypha-debugger" in result["content"]
 
 
 def test_write_file():
@@ -234,10 +237,27 @@ def test_write_file_create_dirs():
             os.chdir(old_cwd)
 
 
-def test_write_file_sandbox():
-    result = write_file("../../etc/evil.txt", "pwned")
-    assert "error" in result
-    assert "Access denied" in result["error"]
+def test_write_file_absolute():
+    """Can write files by absolute path."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        abs_path = os.path.join(tmpdir, "abs_test.txt")
+        result = write_file(abs_path, "absolute write")
+        assert result.get("error") is None
+        assert result["bytes_written"] == 14
+        read_result = read_file(abs_path)
+        assert read_result["content"] == "absolute write"
+
+
+def test_list_files_absolute():
+    """Can list files by absolute path."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create a test file
+        with open(os.path.join(tmpdir, "hello.txt"), "w") as f:
+            f.write("hi")
+        result = list_files(tmpdir)
+        assert result.get("error") is None
+        names = [e["name"] for e in result["entries"]]
+        assert "hello.txt" in names
 
 
 def test_write_file_invalid_mode():