bashkit 0.1.4__cp39-cp39-win_amd64.whl

bashkit/__init__.py

@@ -0,0 +1,33 @@
+"""
+Bashkit Python Bindings
+
+A sandboxed bash interpreter for AI agents with virtual filesystem.
+
+Example:
+    >>> from bashkit import BashTool
+    >>> tool = BashTool()
+    >>> result = await tool.execute("echo 'Hello, World!'")
+    >>> print(result.stdout)
+    Hello, World!
+
+For LangChain integration:
+    >>> from bashkit.langchain import create_bash_tool
+    >>> tool = create_bash_tool()
+
+For Deep Agents integration:
+    >>> from bashkit.deepagents import create_bash_middleware
+    >>> middleware = create_bash_middleware()
+"""
+
+from bashkit._bashkit import (
+    BashTool,
+    ExecResult,
+    create_langchain_tool_spec,
+)
+
+__version__ = "0.1.2"
+__all__ = [
+    "BashTool",
+    "ExecResult",
+    "create_langchain_tool_spec",
+]

bashkit/_bashkit.pyi

@@ -0,0 +1,101 @@
+"""Type stubs for bashkit_py native module."""
+
+from typing import Optional
+
+class ExecResult:
+    """Result from executing bash commands."""
+
+    stdout: str
+    stderr: str
+    exit_code: int
+    error: Optional[str]
+    success: bool
+
+    def to_dict(self) -> dict[str, any]: ...
+
+class BashTool:
+    """Sandboxed bash interpreter for AI agents.
+
+    BashTool provides a safe execution environment for running bash commands
+    with a virtual filesystem. All file operations are contained within the
+    sandbox - no access to the real filesystem.
+
+    Example:
+        >>> tool = BashTool()
+        >>> result = await tool.execute("echo 'Hello!'")
+        >>> print(result.stdout)
+        Hello!
+    """
+
+    name: str
+    short_description: str
+    version: str
+
+    def __init__(
+        self,
+        username: Optional[str] = None,
+        hostname: Optional[str] = None,
+        max_commands: Optional[int] = None,
+        max_loop_iterations: Optional[int] = None,
+    ) -> None:
+        """Create a new BashTool instance.
+
+        Args:
+            username: Custom username for sandbox (default: "user")
+            hostname: Custom hostname for sandbox (default: "sandbox")
+            max_commands: Maximum commands to execute (default: 10000)
+            max_loop_iterations: Maximum loop iterations (default: 100000)
+        """
+        ...
+
+    async def execute(self, commands: str) -> ExecResult:
+        """Execute bash commands asynchronously.
+
+        Args:
+            commands: Bash commands to execute (like `bash -c "commands"`)
+
+        Returns:
+            ExecResult with stdout, stderr, exit_code
+        """
+        ...
+
+    def execute_sync(self, commands: str) -> ExecResult:
+        """Execute bash commands synchronously (blocking).
+
+        Note: Prefer `execute()` for async contexts. This method blocks.
+
+        Args:
+            commands: Bash commands to execute
+
+        Returns:
+            ExecResult with stdout, stderr, exit_code
+        """
+        ...
+
+    def description(self) -> str:
+        """Get the full description."""
+        ...
+
+    def help(self) -> str:
+        """Get LLM documentation."""
+        ...
+
+    def system_prompt(self) -> str:
+        """Get system prompt for LLMs."""
+        ...
+
+    def input_schema(self) -> str:
+        """Get JSON schema for input validation."""
+        ...
+
+    def output_schema(self) -> str:
+        """Get JSON schema for output."""
+        ...
+
+def create_langchain_tool_spec() -> dict[str, any]:
+    """Create a LangChain-compatible tool specification.
+
+    Returns:
+        Dict with name, description, and args_schema
+    """
+    ...

bashkit/deepagents.py

@@ -0,0 +1,338 @@
+"""
+Deep Agents integration for Bashkit.
+
+Provides middleware and backend for Deep Agents using Bashkit's VFS:
+- BashkitMiddleware: Adds `bash` tool via AgentMiddleware.tools
+- BashkitBackend: SandboxBackendProtocol for execute/read_file/write_file/etc.
+
+Use together for shared VFS:
+    >>> backend = BashkitBackend()
+    >>> middleware = backend.create_middleware()  # shares VFS
+    >>> agent = create_deep_agent(backend=backend, middleware=[middleware])
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Optional, TYPE_CHECKING
+
+from bashkit import BashTool as NativeBashTool
+
+if TYPE_CHECKING:
+    pass
+
+# Check for deepagents availability
+try:
+    from deepagents.backends.protocol import (
+        SandboxBackendProtocol,
+        ExecuteResponse,
+        FileInfo,
+        GrepMatch,
+        EditResult,
+        WriteResult,
+        FileDownloadResponse,
+        FileUploadResponse,
+    )
+    from langchain.agents.middleware.types import AgentMiddleware
+    from langchain_core.tools import tool as langchain_tool
+
+    DEEPAGENTS_AVAILABLE = True
+except ImportError:
+    DEEPAGENTS_AVAILABLE = False
+    SandboxBackendProtocol = object
+    AgentMiddleware = object
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _make_bash_tool(bash_instance: NativeBashTool):
+    """Create a bash tool function from a BashTool instance."""
+    # Use name and description from bashkit lib
+    tool_name = bash_instance.name
+    tool_description = bash_instance.description()
+
+    @langchain_tool(tool_name, description=tool_description)
+    def bashkit(command: str) -> str:
+        result = bash_instance.execute_sync(command)
+        output = result.stdout
+        if result.stderr:
+            output += f"\n{result.stderr}"
+        if result.exit_code != 0:
+            output += f"\n[Exit code: {result.exit_code}]"
+        return output.strip() if output else "[No output]"
+
+    return bashkit
+
+
+if DEEPAGENTS_AVAILABLE:
+
+    class BashkitMiddleware(AgentMiddleware):
+        """Middleware that adds `bash` tool for shell execution in VFS.
+
+        Example standalone:
+            >>> middleware = BashkitMiddleware()
+            >>> agent = create_deep_agent(middleware=[middleware])
+
+        Example with shared VFS (recommended):
+            >>> backend = BashkitBackend()
+            >>> middleware = backend.create_middleware()
+            >>> agent = create_deep_agent(backend=backend, middleware=[middleware])
+        """
+
+        def __init__(
+            self,
+            bash_tool: Optional[NativeBashTool] = None,
+            username: Optional[str] = None,
+            hostname: Optional[str] = None,
+            max_commands: Optional[int] = None,
+            max_loop_iterations: Optional[int] = None,
+        ):
+            """Initialize middleware.
+
+            Args:
+                bash_tool: Existing BashTool to use (for shared VFS)
+                username: Username for new BashTool (ignored if bash_tool provided)
+                hostname: Hostname for new BashTool (ignored if bash_tool provided)
+                max_commands: Max commands (ignored if bash_tool provided)
+                max_loop_iterations: Max iterations (ignored if bash_tool provided)
+            """
+            if bash_tool is not None:
+                self._bash = bash_tool
+                self._owns_bash = False
+            else:
+                self._bash = NativeBashTool(
+                    username=username,
+                    hostname=hostname,
+                    max_commands=max_commands,
+                    max_loop_iterations=max_loop_iterations,
+                )
+                self._owns_bash = True
+
+            self._tools = [_make_bash_tool(self._bash)]
+
+        @property
+        def tools(self):
+            """Tools provided by this middleware."""
+            return self._tools
+
+        def execute_sync(self, command: str) -> str:
+            """Execute command synchronously (for setup scripts)."""
+            result = self._bash.execute_sync(command)
+            return result.stdout + (result.stderr or "")
+
+        def reset(self) -> None:
+            """Reset VFS to initial state."""
+            if self._owns_bash:
+                self._bash.reset()
+
+
+    class BashkitBackend(SandboxBackendProtocol):
+        """Backend implementing SandboxBackendProtocol with Bashkit VFS.
+
+        Provides execute, read_file, write_file, edit_file, ls, glob, grep
+        all operating on the same virtual filesystem.
+
+        Example:
+            >>> backend = BashkitBackend()
+            >>> agent = create_deep_agent(backend=backend)
+
+        With middleware for additional `bash` tool:
+            >>> backend = BashkitBackend()
+            >>> middleware = backend.create_middleware()
+            >>> agent = create_deep_agent(backend=backend, middleware=[middleware])
+        """
+
+        def __init__(
+            self,
+            username: Optional[str] = None,
+            hostname: Optional[str] = None,
+            max_commands: Optional[int] = None,
+            max_loop_iterations: Optional[int] = None,
+        ):
+            self._bash = NativeBashTool(
+                username=username,
+                hostname=hostname,
+                max_commands=max_commands,
+                max_loop_iterations=max_loop_iterations,
+            )
+            self._id = f"bashkit-{uuid.uuid4().hex[:8]}"
+
+        @property
+        def id(self) -> str:
+            return self._id
+
+        def create_middleware(self) -> BashkitMiddleware:
+            """Create middleware that shares this backend's VFS.
+
+            Returns:
+                BashkitMiddleware using same BashTool instance
+            """
+            return BashkitMiddleware(bash_tool=self._bash)
+
+        # === Shell Execution ===
+
+        def execute(self, command: str) -> ExecuteResponse:
+            result = self._bash.execute_sync(command)
+            output = result.stdout + (result.stderr or "")
+            return ExecuteResponse(output=output, exit_code=result.exit_code, truncated=False)
+
+        async def aexecute(self, command: str) -> ExecuteResponse:
+            return self.execute(command)
+
+        # === File Operations ===
+
+        def read(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
+            result = self._bash.execute_sync(f"cat {file_path}")
+            if result.exit_code != 0:
+                return f"Error: {result.stderr or 'File not found'}"
+            lines = result.stdout.splitlines()
+            selected = lines[offset:offset + limit]
+            return "\n".join(f"{i:6d}\t{line}" for i, line in enumerate(selected, start=offset + 1))
+
+        async def aread(self, file_path: str, offset: int = 0, limit: int = 2000) -> str:
+            return self.read(file_path, offset, limit)
+
+        def write(self, file_path: str, content: str) -> WriteResult:
+            cmd = f"cat > {file_path} << 'BASHKIT_EOF'\n{content}\nBASHKIT_EOF"
+            result = self._bash.execute_sync(cmd)
+            return WriteResult(error=result.stderr if result.exit_code != 0 else None, path=file_path)
+
+        async def awrite(self, file_path: str, content: str) -> WriteResult:
+            return self.write(file_path, content)
+
+        def edit(self, file_path: str, old_string: str, new_string: str, replace_all: bool = False) -> EditResult:
+            result = self._bash.execute_sync(f"cat {file_path}")
+            if result.exit_code != 0:
+                return EditResult(error=f"File not found: {file_path}")
+            content = result.stdout
+            count = content.count(old_string)
+            if count == 0:
+                return EditResult(error="old_string not found")
+            if count > 1 and not replace_all:
+                return EditResult(error=f"Found {count} times. Use replace_all=True")
+            new_content = content.replace(old_string, new_string) if replace_all else content.replace(old_string, new_string, 1)
+            wr = self.write(file_path, new_content)
+            return EditResult(error=wr.error, path=file_path)
+
+        async def aedit(self, file_path: str, old_string: str, new_string: str, replace_all: bool = False) -> EditResult:
+            return self.edit(file_path, old_string, new_string, replace_all)
+
+        # === File Discovery ===
+
+        def ls_info(self, path: str) -> list[FileInfo]:
+            result = self._bash.execute_sync(f"ls -la {path}")
+            if result.exit_code != 0:
+                return []
+            files = []
+            for line in result.stdout.splitlines():
+                parts = line.split()
+                if len(parts) < 9 or parts[0].startswith("total"):
+                    continue
+                name = " ".join(parts[8:])
+                if name in (".", ".."):
+                    continue
+                files.append(FileInfo(
+                    path=f"{path.rstrip('/')}/{name}", name=name,
+                    is_dir=parts[0].startswith("d"),
+                    size=int(parts[4]) if parts[4].isdigit() else 0,
+                    created_at=_now_iso(), modified_at=_now_iso(),
+                ))
+            return files
+
+        async def als_info(self, path: str) -> list[FileInfo]:
+            return self.ls_info(path)
+
+        def glob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
+            name_pattern = pattern.replace("**/", "").replace("**", "*") if "**" in pattern else pattern
+            result = self._bash.execute_sync(f"find {path} -name '{name_pattern}' -type f")
+            if result.exit_code != 0:
+                return []
+            return [
+                FileInfo(path=p.strip(), name=p.strip().split("/")[-1], is_dir=False, size=0, created_at=_now_iso(), modified_at=_now_iso())
+                for p in result.stdout.splitlines() if p.strip()
+            ]
+
+        async def aglob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
+            return self.glob_info(pattern, path)
+
+        def grep_raw(self, pattern: str, path: str | None = None, glob: str | None = None) -> list[GrepMatch] | str:
+            cmd = f"grep -rn '{pattern}' {path}" if path else f"grep -rn '{pattern}' /home"
+            result = self._bash.execute_sync(cmd)
+            matches = []
+            for line in result.stdout.splitlines():
+                if ":" not in line:
+                    continue
+                parts = line.split(":", 2)
+                if len(parts) >= 3:
+                    try:
+                        matches.append(GrepMatch(path=parts[0], line_number=int(parts[1]), content=parts[2]))
+                    except ValueError:
+                        continue
+            return matches
+
+        async def agrep_raw(self, pattern: str, path: str | None = None, glob: str | None = None) -> list[GrepMatch] | str:
+            return self.grep_raw(pattern, path, glob)
+
+        # === File Transfer ===
+
+        def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+            responses = []
+            for p in paths:
+                result = self._bash.execute_sync(f"cat {p}")
+                if result.exit_code == 0:
+                    responses.append(FileDownloadResponse(path=p, content=result.stdout.encode(), error=None))
+                else:
+                    responses.append(FileDownloadResponse(path=p, content=None, error=result.stderr or "File not found"))
+            return responses
+
+        async def adownload_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+            return self.download_files(paths)
+
+        def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+            responses = []
+            for p, content in files:
+                try:
+                    wr = self.write(p, content.decode("utf-8"))
+                    responses.append(FileUploadResponse(path=p, error=None if wr.success else wr.error))
+                except UnicodeDecodeError:
+                    responses.append(FileUploadResponse(path=p, error="Binary files not supported"))
+            return responses
+
+        async def aupload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+            return self.upload_files(files)
+
+        # === Utility ===
+
+        def setup(self, script: str) -> str:
+            """Execute setup script."""
+            result = self._bash.execute_sync(script)
+            return result.stdout + (result.stderr or "")
+
+        def reset(self) -> None:
+            """Reset VFS."""
+            self._bash.reset()
+
+
+def create_bash_middleware(**kwargs) -> "BashkitMiddleware":
+    """Create BashkitMiddleware for Deep Agents."""
+    if not DEEPAGENTS_AVAILABLE:
+        raise ImportError("deepagents required. Install: pip install 'bashkit[deepagents]'")
+    return BashkitMiddleware(**kwargs)
+
+
+def create_bashkit_backend(**kwargs) -> "BashkitBackend":
+    """Create BashkitBackend for Deep Agents."""
+    if not DEEPAGENTS_AVAILABLE:
+        raise ImportError("deepagents required. Install: pip install 'bashkit[deepagents]'")
+    return BashkitBackend(**kwargs)
+
+
+__all__ = [
+    "BashkitMiddleware",
+    "BashkitBackend",
+    "create_bash_middleware",
+    "create_bashkit_backend",
+]

bashkit/langchain.py

@@ -0,0 +1,167 @@
+"""
+LangChain integration for Bashkit.
+
+Provides a LangChain-compatible tool that wraps BashTool for use with
+LangChain agents and chains.
+
+Example:
+    >>> from bashkit.langchain import create_bash_tool
+    >>> from langchain.agents import create_agent
+    >>>
+    >>> tool = create_bash_tool()
+    >>> agent = create_agent(model="claude-sonnet-4-20250514", tools=[tool])
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Optional, Type
+
+try:
+    from langchain_core.tools import BaseTool, ToolException
+    from pydantic import BaseModel, Field, PrivateAttr
+
+    LANGCHAIN_AVAILABLE = True
+except ImportError:
+    LANGCHAIN_AVAILABLE = False
+    BaseTool = object
+    BaseModel = object
+
+    def Field(*args, **kwargs):
+        return None
+
+    def PrivateAttr(*args, **kwargs):
+        return None
+
+
+from bashkit import BashTool as NativeBashTool
+
+
+class BashToolInput(BaseModel):
+    """Input schema for BashTool."""
+
+    commands: str = Field(
+        description="Bash commands to execute (like `bash -c 'commands'`)"
+    )
+
+
+if LANGCHAIN_AVAILABLE:
+
+    class BashkitTool(BaseTool):
+        """LangChain tool wrapper for Bashkit sandboxed bash interpreter.
+
+        Example:
+            >>> tool = BashkitTool()
+            >>> result = tool.invoke({"commands": "echo 'Hello!'"})
+            >>> print(result)  # Hello!
+        """
+
+        name: str = ""  # Set in __init__ from bashkit
+        description: str = ""  # Set in __init__ from bashkit
+        args_schema: Type[BaseModel] = BashToolInput
+        handle_tool_error: bool = True
+
+        # Internal state - use PrivateAttr for pydantic v2 compatibility
+        _bash_tool: NativeBashTool = PrivateAttr()
+
+        def __init__(
+            self,
+            username: Optional[str] = None,
+            hostname: Optional[str] = None,
+            max_commands: Optional[int] = None,
+            max_loop_iterations: Optional[int] = None,
+            **kwargs,
+        ):
+            """Initialize BashkitTool.
+
+            Args:
+                username: Custom username for sandbox
+                hostname: Custom hostname for sandbox
+                max_commands: Max commands to execute
+                max_loop_iterations: Max loop iterations
+            """
+            bash_tool = NativeBashTool(
+                username=username,
+                hostname=hostname,
+                max_commands=max_commands,
+                max_loop_iterations=max_loop_iterations,
+            )
+            # Use name and description from bashkit lib
+            kwargs["name"] = bash_tool.name
+            kwargs["description"] = bash_tool.description()
+            super().__init__(**kwargs)
+            object.__setattr__(self, "_bash_tool", bash_tool)
+
+        def _run(self, commands: str) -> str:
+            """Execute bash commands synchronously."""
+            result = self._bash_tool.execute_sync(commands)
+
+            if result.error:
+                raise ToolException(f"Execution error: {result.error}")
+
+            # Return combined output for the agent
+            output = result.stdout
+            if result.stderr:
+                output += f"\nSTDERR: {result.stderr}"
+            if result.exit_code != 0:
+                output += f"\n[Exit code: {result.exit_code}]"
+
+            return output
+
+        async def _arun(self, commands: str) -> str:
+            """Execute bash commands asynchronously."""
+            result = await self._bash_tool.execute(commands)
+
+            if result.error:
+                raise ToolException(f"Execution error: {result.error}")
+
+            # Return combined output for the agent
+            output = result.stdout
+            if result.stderr:
+                output += f"\nSTDERR: {result.stderr}"
+            if result.exit_code != 0:
+                output += f"\n[Exit code: {result.exit_code}]"
+
+            return output
+
+
+def create_bash_tool(
+    username: Optional[str] = None,
+    hostname: Optional[str] = None,
+    max_commands: Optional[int] = None,
+    max_loop_iterations: Optional[int] = None,
+) -> "BashkitTool":
+    """Create a LangChain-compatible Bashkit tool.
+
+    Args:
+        username: Custom username for sandbox
+        hostname: Custom hostname for sandbox
+        max_commands: Max commands to execute
+        max_loop_iterations: Max loop iterations
+
+    Returns:
+        BashkitTool instance for use with LangChain agents
+
+    Raises:
+        ImportError: If langchain-core is not installed
+
+    Example:
+        >>> from bashkit.langchain import create_bash_tool
+        >>> tool = create_bash_tool()
+        >>> result = tool.invoke({"commands": "ls -la"})
+    """
+    if not LANGCHAIN_AVAILABLE:
+        raise ImportError(
+            "langchain-core is required for LangChain integration. "
+            "Install with: pip install 'bashkit[langchain]'"
+        )
+
+    return BashkitTool(
+        username=username,
+        hostname=hostname,
+        max_commands=max_commands,
+        max_loop_iterations=max_loop_iterations,
+    )
+
+
+__all__ = ["BashkitTool", "BashToolInput", "create_bash_tool"]

bashkit-0.1.4.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: bashkit
+Version: 0.1.4
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Interpreters
+Classifier: Topic :: Security
+Requires-Dist: deepagents>=0.3.11 ; extra == 'deepagents'
+Requires-Dist: langchain-anthropic>=0.3 ; extra == 'deepagents'
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'
+Requires-Dist: langchain-core>=0.3 ; extra == 'langchain'
+Requires-Dist: langchain-anthropic>=0.3 ; extra == 'langchain'
+Provides-Extra: deepagents
+Provides-Extra: dev
+Provides-Extra: langchain
+Summary: Python bindings for Bashkit - a sandboxed bash interpreter for AI agents
+Keywords: bash,sandbox,ai,agent,shell,interpreter
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# Bashkit Python Bindings
+
+Python bindings for [Bashkit](https://github.com/everruns/bashkit) - a sandboxed bash interpreter for AI agents.
+
+## Features
+
+- **Sandboxed execution**: All commands run in isolation with a virtual filesystem
+- **68+ built-in commands**: echo, cat, grep, sed, awk, jq, curl, find, and more
+- **Full bash syntax**: Variables, pipelines, redirects, loops, functions, arrays
+- **Resource limits**: Protect against infinite loops and runaway scripts
+- **LangChain integration**: Ready-to-use tool for LangChain agents
+
+## Installation
+
+```bash
+# From PyPI (when published)
+pip install bashkit
+
+# With LangChain support
+pip install 'bashkit[langchain]'
+
+# From source
+pip install maturin
+maturin develop
+```
+
+## Quick Start
+
+```python
+import asyncio
+from bashkit import BashTool
+
+async def main():
+    tool = BashTool()
+
+    # Simple command
+    result = await tool.execute("echo 'Hello, World!'")
+    print(result.stdout)  # Hello, World!
+
+    # Pipeline
+    result = await tool.execute("echo -e 'banana\\napple\\ncherry' | sort")
+    print(result.stdout)  # apple\nbanana\ncherry
+
+    # Virtual filesystem
+    result = await tool.execute("""
+        echo 'data' > /tmp/file.txt
+        cat /tmp/file.txt
+    """)
+    print(result.stdout)  # data
+
+asyncio.run(main())
+```
+
+## LangChain Integration
+
+```python
+from bashkit.langchain import create_bash_tool
+from langchain.agents import create_agent
+
+# Create tool
+bash_tool = create_bash_tool()
+
+# Create agent
+agent = create_agent(
+    model="claude-sonnet-4-20250514",
+    tools=[bash_tool],
+    system_prompt="You are a helpful assistant with bash skills."
+)
+
+# Run
+result = agent.invoke({
+    "messages": [{"role": "user", "content": "Create a file with today's date"}]
+})
+```
+
+## Configuration
+
+```python
+tool = BashTool(
+    username="agent",           # Custom username (whoami)
+    hostname="sandbox",         # Custom hostname
+    max_commands=1000,          # Limit total commands
+    max_loop_iterations=10000,  # Limit loop iterations
+)
+```
+
+## Synchronous API
+
+```python
+from bashkit import BashTool
+
+tool = BashTool()
+result = tool.execute_sync("echo 'Hello!'")
+print(result.stdout)
+```
+
+## API Reference
+
+### BashTool
+
+- `execute(commands: str) -> ExecResult`: Execute commands asynchronously
+- `execute_sync(commands: str) -> ExecResult`: Execute commands synchronously
+- `description() -> str`: Get tool description
+- `help() -> str`: Get LLM documentation
+- `input_schema() -> str`: Get JSON input schema
+- `output_schema() -> str`: Get JSON output schema
+
+### ExecResult
+
+- `stdout: str`: Standard output
+- `stderr: str`: Standard error
+- `exit_code: int`: Exit code (0 = success)
+- `error: Optional[str]`: Error message if execution failed
+- `success: bool`: True if exit_code == 0
+- `to_dict() -> dict`: Convert to dictionary
+
+## License
+
+MIT
+

bashkit-0.1.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+bashkit\__init__.py,sha256=HROdnwXGjHVQ0y04XdXnrlIs7wPKyJrdgragm2yXU0Y,770
+bashkit\_bashkit.cp39-win_amd64.pyd,sha256=gycW5oS4QTkcjqNXijtsuhrtT11R8S3hB9oFnQY5xQc,5978112
+bashkit\_bashkit.pyi,sha256=wT_nNxhsaLWPSx6uoHEXF84j0uBpk-dMDu6Ffo07hu8,2740
+bashkit\deepagents.py,sha256=mOOq40P1BAdfQohbdVpki_AkCOzPZMZjQpMzNQo2mTQ,13584
+bashkit\langchain.py,sha256=F7xZVxK-qYFPRw4ebz9WuGUlwhHCEjMTPCNu_U3wheQ,5249
+bashkit\py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bashkit-0.1.4.dist-info\METADATA,sha256=Re1qoMU9C2iRDeflX4ZaIj0WnoE0qJYuugltFS585Dw,4227
+bashkit-0.1.4.dist-info\WHEEL,sha256=H5klTgXu3iVXpFbMzUkXja9m3gL244ExCR0k1sRMImo,95
+bashkit-0.1.4.dist-info\RECORD,,

bashkit-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp39-cp39-win_amd64