shebangrun 0.1.0__tar.gz

shebangrun-0.1.0/PKG-INFO

@@ -0,0 +1,299 @@
+Metadata-Version: 2.4
+Name: shebangrun
+Version: 0.1.0
+Summary: Python client library for shebang.run
+Author-email: "shebang.run" <hello@shebang.run>
+License: MIT
+Project-URL: Homepage, https://shebang.run
+Project-URL: Documentation, https://shebang.run/docs
+Project-URL: Repository, https://github.com/shebangrun/python-client
+Keywords: shebang,scripts,automation,devops
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+
+# shebangrun Python Client
+
+Python client library for [shebang.run](https://shebang.run) - a platform for hosting and sharing shell scripts with versioning, encryption, and signing.
+
+## Installation
+
+```bash
+pip install shebangrun
+```
+
+Or install from source:
+
+```bash
+cd python
+pip install -e .
+```
+
+## Quick Start
+
+### Simple Script Fetching
+
+```python
+from shebangrun import run
+
+# Fetch a script (returns content as string)
+content = run(username="mpruitt", script="bashtest")
+print(content)
+```
+
+### Execute Python Scripts
+
+```python
+from shebangrun import run
+
+# Fetch and execute with confirmation prompt
+run(username="mpruitt", script="myscript", eval=True)
+
+# Execute without confirmation (use with caution!)
+run(username="mpruitt", script="myscript", eval=True, accept=True)
+```
+
+### Working with Versions
+
+```python
+from shebangrun import run
+
+# Get latest version
+content = run(username="mpruitt", script="deploy", version="latest")
+
+# Get specific version
+content = run(username="mpruitt", script="deploy", version="v5")
+
+# Get tagged version
+content = run(username="mpruitt", script="deploy", version="dev")
+```
+
+### Private Scripts
+
+```python
+from shebangrun import run
+
+# Access private script with share token
+content = run(
+    username="mpruitt", 
+    script="private-script",
+    token="your-share-token-here"
+)
+```
+
+## Full API Client
+
+For more advanced usage, use the `ShebangClient` class:
+
+```python
+from shebangrun import ShebangClient
+
+# Initialize client
+client = ShebangClient(url="shebang.run")
+
+# Login
+client.login(username="myuser", password="mypassword")
+
+# Create a script
+client.create_script(
+    name="hello",
+    content="#!/bin/bash\necho 'Hello World'",
+    description="My first script",
+    visibility="public"
+)
+
+# List your scripts
+scripts = client.list_scripts()
+for script in scripts:
+    print(f"{script['name']} - v{script['version']}")
+
+# Update a script (creates new version)
+client.update_script(
+    script_id=1,
+    content="#!/bin/bash\necho 'Hello World v2'",
+    tag="dev"
+)
+
+# Generate share token for private script
+token = client.generate_share_token(script_id=1)
+print(f"Share URL: https://shebang.run/myuser/myscript?token={token}")
+
+# Get script metadata
+meta = client.get_metadata(username="mpruitt", script="bashtest")
+print(f"Version: {meta['version']}, Size: {meta['size']} bytes")
+
+# Verify signature
+verification = client.verify_signature(username="mpruitt", script="bashtest")
+print(f"Signed: {verification['signed']}")
+```
+
+## Key Management
+
+```python
+from shebangrun import ShebangClient
+
+client = ShebangClient(url="shebang.run")
+client.login(username="myuser", password="mypassword")
+
+# Generate a new keypair
+key = client.generate_key(name="my-signing-key")
+print(f"Public Key: {key['public_key']}")
+print(f"Private Key: {key['private_key']}")  # Save this securely!
+
+# List keys
+keys = client.list_keys()
+for key in keys:
+    print(f"{key['name']} - Created: {key['created_at']}")
+
+# Import existing public key
+client.import_key(
+    name="imported-key",
+    public_key="-----BEGIN PUBLIC KEY-----\n..."
+)
+
+# Delete a key
+client.delete_key(key_id=1)
+```
+
+## Account Management
+
+```python
+from shebangrun import ShebangClient
+
+client = ShebangClient(url="shebang.run")
+client.login(username="myuser", password="mypassword")
+
+# Change password
+client.change_password(
+    current_password="oldpass",
+    new_password="newpass"
+)
+
+# Export all data (GDPR)
+data = client.export_data()
+print(f"Exported {len(data['scripts'])} scripts")
+
+# Delete account (permanent!)
+client.delete_account()
+```
+
+## API Reference
+
+### `run()` Function
+
+```python
+run(username, script, key=None, eval=False, accept=False, 
+    url="shebang.run", version=None, token=None)
+```
+
+**Parameters:**
+- `username` (str, required): Script owner's username
+- `script` (str, required): Script name
+- `key` (str, optional): Private key for decryption (not yet implemented)
+- `eval` (bool, optional): Execute the script in Python (default: False)
+- `accept` (bool, optional): Skip confirmation when eval=True (default: False)
+- `url` (str, optional): Base URL (default: "shebang.run")
+- `version` (str, optional): Version tag (e.g., "latest", "v1", "dev")
+- `token` (str, optional): Share token for private scripts
+
+**Returns:**
+- String content if `eval=False`
+- Execution result if `eval=True`
+
+### `ShebangClient` Class
+
+#### Authentication
+- `register(username, email, password)` - Register new user
+- `login(username, password)` - Login and get JWT token
+
+#### Script Management
+- `list_scripts()` - List user's scripts
+- `get_script(username, script, version=None, token=None)` - Fetch script content
+- `get_metadata(username, script)` - Get script metadata
+- `verify_signature(username, script)` - Verify script signature
+- `create_script(name, content, description="", visibility="private", keypair_id=None)` - Create script
+- `update_script(script_id, content=None, description=None, visibility=None, tag=None, keypair_id=None)` - Update script
+- `delete_script(script_id)` - Delete script
+- `generate_share_token(script_id)` - Generate share token
+- `revoke_share_token(script_id, token)` - Revoke share token
+
+#### Key Management
+- `list_keys()` - List keypairs
+- `generate_key(name)` - Generate new keypair
+- `import_key(name, public_key)` - Import public key
+- `delete_key(key_id)` - Delete keypair
+
+#### Account Management
+- `change_password(current_password, new_password)` - Change password
+- `export_data()` - Export all data (GDPR)
+- `delete_account()` - Delete account
+
+## Security Notes
+
+⚠️ **Warning:** Using `eval=True` with `accept=True` will execute remote code without confirmation. Only use this with scripts you trust completely.
+
+✅ **Best Practices:**
+- Always review scripts before executing with `eval=True`
+- Use `accept=False` (default) to see the script before execution
+- Store private keys securely, never commit them to version control
+- Use environment variables for tokens and credentials
+- Verify script signatures when available
+
+## Examples
+
+### Automation Script
+
+```python
+#!/usr/bin/env python3
+from shebangrun import run
+
+# Fetch deployment script and execute with confirmation
+run(
+    username="devops",
+    script="deploy-prod",
+    version="latest",
+    eval=True,
+    accept=False  # Always confirm production deployments!
+)
+```
+
+### CI/CD Integration
+
+```python
+import os
+from shebangrun import ShebangClient
+
+client = ShebangClient()
+client.login(
+    username=os.environ["SHEBANG_USER"],
+    password=os.environ["SHEBANG_PASS"]
+)
+
+# Update deployment script
+client.update_script(
+    script_id=int(os.environ["DEPLOY_SCRIPT_ID"]),
+    content=open("deploy.sh").read(),
+    tag="latest"
+)
+
+print("Deployment script updated!")
+```
+
+## License
+
+MIT
+
+## Links
+
+- Website: https://shebang.run
+- Documentation: https://shebang.run/docs
+- GitHub: https://github.com/shebangrun/python-client

shebangrun-0.1.0/README.md

@@ -0,0 +1,276 @@
+# shebangrun Python Client
+
+Python client library for [shebang.run](https://shebang.run) - a platform for hosting and sharing shell scripts with versioning, encryption, and signing.
+
+## Installation
+
+```bash
+pip install shebangrun
+```
+
+Or install from source:
+
+```bash
+cd python
+pip install -e .
+```
+
+## Quick Start
+
+### Simple Script Fetching
+
+```python
+from shebangrun import run
+
+# Fetch a script (returns content as string)
+content = run(username="mpruitt", script="bashtest")
+print(content)
+```
+
+### Execute Python Scripts
+
+```python
+from shebangrun import run
+
+# Fetch and execute with confirmation prompt
+run(username="mpruitt", script="myscript", eval=True)
+
+# Execute without confirmation (use with caution!)
+run(username="mpruitt", script="myscript", eval=True, accept=True)
+```
+
+### Working with Versions
+
+```python
+from shebangrun import run
+
+# Get latest version
+content = run(username="mpruitt", script="deploy", version="latest")
+
+# Get specific version
+content = run(username="mpruitt", script="deploy", version="v5")
+
+# Get tagged version
+content = run(username="mpruitt", script="deploy", version="dev")
+```
+
+### Private Scripts
+
+```python
+from shebangrun import run
+
+# Access private script with share token
+content = run(
+    username="mpruitt", 
+    script="private-script",
+    token="your-share-token-here"
+)
+```
+
+## Full API Client
+
+For more advanced usage, use the `ShebangClient` class:
+
+```python
+from shebangrun import ShebangClient
+
+# Initialize client
+client = ShebangClient(url="shebang.run")
+
+# Login
+client.login(username="myuser", password="mypassword")
+
+# Create a script
+client.create_script(
+    name="hello",
+    content="#!/bin/bash\necho 'Hello World'",
+    description="My first script",
+    visibility="public"
+)
+
+# List your scripts
+scripts = client.list_scripts()
+for script in scripts:
+    print(f"{script['name']} - v{script['version']}")
+
+# Update a script (creates new version)
+client.update_script(
+    script_id=1,
+    content="#!/bin/bash\necho 'Hello World v2'",
+    tag="dev"
+)
+
+# Generate share token for private script
+token = client.generate_share_token(script_id=1)
+print(f"Share URL: https://shebang.run/myuser/myscript?token={token}")
+
+# Get script metadata
+meta = client.get_metadata(username="mpruitt", script="bashtest")
+print(f"Version: {meta['version']}, Size: {meta['size']} bytes")
+
+# Verify signature
+verification = client.verify_signature(username="mpruitt", script="bashtest")
+print(f"Signed: {verification['signed']}")
+```
+
+## Key Management
+
+```python
+from shebangrun import ShebangClient
+
+client = ShebangClient(url="shebang.run")
+client.login(username="myuser", password="mypassword")
+
+# Generate a new keypair
+key = client.generate_key(name="my-signing-key")
+print(f"Public Key: {key['public_key']}")
+print(f"Private Key: {key['private_key']}")  # Save this securely!
+
+# List keys
+keys = client.list_keys()
+for key in keys:
+    print(f"{key['name']} - Created: {key['created_at']}")
+
+# Import existing public key
+client.import_key(
+    name="imported-key",
+    public_key="-----BEGIN PUBLIC KEY-----\n..."
+)
+
+# Delete a key
+client.delete_key(key_id=1)
+```
+
+## Account Management
+
+```python
+from shebangrun import ShebangClient
+
+client = ShebangClient(url="shebang.run")
+client.login(username="myuser", password="mypassword")
+
+# Change password
+client.change_password(
+    current_password="oldpass",
+    new_password="newpass"
+)
+
+# Export all data (GDPR)
+data = client.export_data()
+print(f"Exported {len(data['scripts'])} scripts")
+
+# Delete account (permanent!)
+client.delete_account()
+```
+
+## API Reference
+
+### `run()` Function
+
+```python
+run(username, script, key=None, eval=False, accept=False, 
+    url="shebang.run", version=None, token=None)
+```
+
+**Parameters:**
+- `username` (str, required): Script owner's username
+- `script` (str, required): Script name
+- `key` (str, optional): Private key for decryption (not yet implemented)
+- `eval` (bool, optional): Execute the script in Python (default: False)
+- `accept` (bool, optional): Skip confirmation when eval=True (default: False)
+- `url` (str, optional): Base URL (default: "shebang.run")
+- `version` (str, optional): Version tag (e.g., "latest", "v1", "dev")
+- `token` (str, optional): Share token for private scripts
+
+**Returns:**
+- String content if `eval=False`
+- Execution result if `eval=True`
+
+### `ShebangClient` Class
+
+#### Authentication
+- `register(username, email, password)` - Register new user
+- `login(username, password)` - Login and get JWT token
+
+#### Script Management
+- `list_scripts()` - List user's scripts
+- `get_script(username, script, version=None, token=None)` - Fetch script content
+- `get_metadata(username, script)` - Get script metadata
+- `verify_signature(username, script)` - Verify script signature
+- `create_script(name, content, description="", visibility="private", keypair_id=None)` - Create script
+- `update_script(script_id, content=None, description=None, visibility=None, tag=None, keypair_id=None)` - Update script
+- `delete_script(script_id)` - Delete script
+- `generate_share_token(script_id)` - Generate share token
+- `revoke_share_token(script_id, token)` - Revoke share token
+
+#### Key Management
+- `list_keys()` - List keypairs
+- `generate_key(name)` - Generate new keypair
+- `import_key(name, public_key)` - Import public key
+- `delete_key(key_id)` - Delete keypair
+
+#### Account Management
+- `change_password(current_password, new_password)` - Change password
+- `export_data()` - Export all data (GDPR)
+- `delete_account()` - Delete account
+
+## Security Notes
+
+⚠️ **Warning:** Using `eval=True` with `accept=True` will execute remote code without confirmation. Only use this with scripts you trust completely.
+
+✅ **Best Practices:**
+- Always review scripts before executing with `eval=True`
+- Use `accept=False` (default) to see the script before execution
+- Store private keys securely, never commit them to version control
+- Use environment variables for tokens and credentials
+- Verify script signatures when available
+
+## Examples
+
+### Automation Script
+
+```python
+#!/usr/bin/env python3
+from shebangrun import run
+
+# Fetch deployment script and execute with confirmation
+run(
+    username="devops",
+    script="deploy-prod",
+    version="latest",
+    eval=True,
+    accept=False  # Always confirm production deployments!
+)
+```
+
+### CI/CD Integration
+
+```python
+import os
+from shebangrun import ShebangClient
+
+client = ShebangClient()
+client.login(
+    username=os.environ["SHEBANG_USER"],
+    password=os.environ["SHEBANG_PASS"]
+)
+
+# Update deployment script
+client.update_script(
+    script_id=int(os.environ["DEPLOY_SCRIPT_ID"]),
+    content=open("deploy.sh").read(),
+    tag="latest"
+)
+
+print("Deployment script updated!")
+```
+
+## License
+
+MIT
+
+## Links
+
+- Website: https://shebang.run
+- Documentation: https://shebang.run/docs
+- GitHub: https://github.com/shebangrun/python-client

shebangrun-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shebangrun"
+version = "0.1.0"
+description = "Python client library for shebang.run"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+authors = [
+    {name = "shebang.run", email = "hello@shebang.run"}
+]
+keywords = ["shebang", "scripts", "automation", "devops"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "requests>=2.25.0",
+]
+
+[project.urls]
+Homepage = "https://shebang.run"
+Documentation = "https://shebang.run/docs"
+Repository = "https://github.com/shebangrun/python-client"

shebangrun-0.1.0/setup.cfg

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

shebangrun-0.1.0/shebangrun/__init__.py

@@ -0,0 +1,11 @@
+"""
+shebangrun - Python client library for shebang.run
+
+A helper library to interact with shebang.run API and execute remote scripts.
+"""
+
+__version__ = "0.1.0"
+
+from .client import ShebangClient, run
+
+__all__ = ["ShebangClient", "run"]

shebangrun-0.1.0/shebangrun/client.py

@@ -0,0 +1,378 @@
+"""
+Main client for interacting with shebang.run
+"""
+
+import requests
+from typing import Optional, Any
+
+
+class ShebangClient:
+    """Client for interacting with shebang.run API"""
+    
+    def __init__(self, url: str = "shebang.run", token: Optional[str] = None):
+        """
+        Initialize the client
+        
+        Args:
+            url: Base URL (default: shebang.run)
+            token: JWT token for authenticated requests
+        """
+        self.base_url = f"https://{url}"
+        self.token = token
+        self.session = requests.Session()
+        if token:
+            self.session.headers.update({"Authorization": f"Bearer {token}"})
+    
+    def get_script(self, username: str, script: str, version: Optional[str] = None, 
+                   token: Optional[str] = None) -> tuple:
+        """
+        Retrieve a script from shebang.run
+        
+        Args:
+            username: Script owner's username
+            script: Script name
+            version: Optional version tag (@latest, @v1, @dev, etc.)
+            token: Optional share token for private scripts
+        
+        Returns:
+            Tuple of (content, metadata) where metadata includes encryption info
+        """
+        script_path = f"{script}@{version}" if version else script
+        url = f"{self.base_url}/{username}/{script_path}"
+        
+        params = {}
+        if token:
+            params["token"] = token
+        
+        response = self.session.get(url, params=params)
+        response.raise_for_status()
+        
+        metadata = {
+            "encrypted": response.headers.get("X-Encrypted") == "true",
+            "version": response.headers.get("X-Script-Version"),
+            "checksum": response.headers.get("X-Script-Checksum"),
+            "key_id": response.headers.get("X-Encryption-KeyID"),
+            "wrapped_key": response.headers.get("X-Wrapped-Key")
+        }
+        
+        return response.content if metadata["encrypted"] else response.text, metadata
+    
+    def get_metadata(self, username: str, script: str) -> dict:
+        """Get script metadata"""
+        url = f"{self.base_url}/{username}/{script}/meta"
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+    
+    def verify_signature(self, username: str, script: str) -> dict:
+        """Verify script signature"""
+        url = f"{self.base_url}/{username}/{script}/verify"
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+    
+    # Authentication
+    def register(self, username: str, email: str, password: str) -> dict:
+        """Register a new user"""
+        url = f"{self.base_url}/api/auth/register"
+        response = self.session.post(url, json={
+            "username": username,
+            "email": email,
+            "password": password
+        })
+        response.raise_for_status()
+        data = response.json()
+        if "token" in data:
+            self.token = data["token"]
+            self.session.headers.update({"Authorization": f"Bearer {self.token}"})
+        return data
+    
+    def login(self, username: str, password: str) -> dict:
+        """Login and get JWT token"""
+        url = f"{self.base_url}/api/auth/login"
+        response = self.session.post(url, json={
+            "username": username,
+            "password": password
+        })
+        response.raise_for_status()
+        data = response.json()
+        if "token" in data:
+            self.token = data["token"]
+            self.session.headers.update({"Authorization": f"Bearer {self.token}"})
+        return data
+    
+    # Script Management
+    def list_scripts(self) -> list:
+        """List user's scripts (requires authentication)"""
+        url = f"{self.base_url}/api/scripts"
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+    
+    def create_script(self, name: str, content: str, description: str = "", 
+                     visibility: str = "private", keypair_id: Optional[int] = None) -> dict:
+        """Create a new script"""
+        url = f"{self.base_url}/api/scripts"
+        data = {
+            "name": name,
+            "content": content,
+            "description": description,
+            "visibility": visibility
+        }
+        if keypair_id:
+            data["keypair_id"] = keypair_id
+        
+        response = self.session.post(url, json=data)
+        response.raise_for_status()
+        return response.json()
+    
+    def update_script(self, script_id: int, content: Optional[str] = None,
+                     description: Optional[str] = None, visibility: Optional[str] = None,
+                     tag: Optional[str] = None, keypair_id: Optional[int] = None) -> dict:
+        """Update a script (creates new version if content changed)"""
+        url = f"{self.base_url}/api/scripts/{script_id}"
+        data = {}
+        if content:
+            data["content"] = content
+        if description:
+            data["description"] = description
+        if visibility:
+            data["visibility"] = visibility
+        if tag:
+            data["tag"] = tag
+        if keypair_id:
+            data["keypair_id"] = keypair_id
+        
+        response = self.session.put(url, json=data)
+        response.raise_for_status()
+        return response.json() if response.text else {}
+    
+    def delete_script(self, script_id: int):
+        """Delete a script"""
+        url = f"{self.base_url}/api/scripts/{script_id}"
+        response = self.session.delete(url)
+        response.raise_for_status()
+    
+    def generate_share_token(self, script_id: int) -> str:
+        """Generate a share token for a private script"""
+        url = f"{self.base_url}/api/scripts/{script_id}/share"
+        response = self.session.post(url)
+        response.raise_for_status()
+        return response.json()["token"]
+    
+    def revoke_share_token(self, script_id: int, token: str):
+        """Revoke a share token"""
+        url = f"{self.base_url}/api/scripts/{script_id}/share/{token}"
+        response = self.session.delete(url)
+        response.raise_for_status()
+    
+    # Key Management
+    def list_keys(self) -> list:
+        """List user's keypairs"""
+        url = f"{self.base_url}/api/keys"
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+    
+    def generate_key(self, name: str) -> dict:
+        """Generate a new keypair (returns private key - save it!)"""
+        url = f"{self.base_url}/api/keys/generate"
+        response = self.session.post(url, json={"name": name})
+        response.raise_for_status()
+        return response.json()
+    
+    def import_key(self, name: str, public_key: str) -> dict:
+        """Import an existing public key"""
+        url = f"{self.base_url}/api/keys/import"
+        response = self.session.post(url, json={
+            "name": name,
+            "public_key": public_key
+        })
+        response.raise_for_status()
+        return response.json()
+    
+    def delete_key(self, key_id: int):
+        """Delete a keypair"""
+        url = f"{self.base_url}/api/keys/{key_id}"
+        response = self.session.delete(url)
+        response.raise_for_status()
+    
+    # Account Management
+    def change_password(self, current_password: str, new_password: str):
+        """Change account password"""
+        url = f"{self.base_url}/api/account/password"
+        response = self.session.put(url, json={
+            "current_password": current_password,
+            "new_password": new_password
+        })
+        response.raise_for_status()
+    
+    def export_data(self) -> dict:
+        """Export all user data (GDPR)"""
+        url = f"{self.base_url}/api/account/export"
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+    
+    def delete_account(self):
+        """Delete account permanently"""
+        url = f"{self.base_url}/api/account"
+        response = self.session.delete(url)
+        response.raise_for_status()
+
+
+def run(username: str, script: str, key: Optional[str] = None, 
+        eval: bool = False, accept: bool = False, url: str = "shebang.run",
+        version: Optional[str] = None, token: Optional[str] = None) -> Any:
+    """
+    Convenience function to fetch and optionally execute a script
+    
+    Args:
+        username: Script owner's username (required)
+        script: Script name (required)
+        key: Private key contents for decryption (optional)
+        eval: If True, evaluate the script in Python (default: False)
+        accept: If True, skip confirmation prompt when eval=True (default: False)
+        url: Base URL (default: shebang.run)
+        version: Version tag (optional, e.g., "latest", "v1", "dev")
+        token: Share token for private scripts (optional)
+    
+    Returns:
+        Script content as string if eval=False, or result of eval() if eval=True
+    
+    Examples:
+        # Just fetch the script
+        content = run(username="mpruitt", script="bashtest")
+        
+        # Fetch encrypted script with private key
+        content = run(username="mpruitt", script="private", key="-----BEGIN PRIVATE KEY-----\\n...")
+        
+        # Fetch and evaluate with confirmation
+        run(username="mpruitt", script="myscript", eval=True)
+    """
+    client = ShebangClient(url=url)
+    
+    # Fetch the script
+    content, metadata = client.get_script(username, script, version=version, token=token)
+    
+    # If encrypted and key is provided, decrypt
+    if metadata.get("encrypted") and key:
+        try:
+            from cryptography.hazmat.primitives import serialization, hashes
+            from cryptography.hazmat.primitives.asymmetric import padding
+            from cryptography.hazmat.backends import default_backend
+            import nacl.bindings
+            
+            # Parse private key
+            private_key = serialization.load_pem_private_key(
+                key.encode() if isinstance(key, str) else key,
+                password=None,
+                backend=default_backend()
+            )
+            
+            # Get wrapped key from headers
+            wrapped_key_hex = metadata.get("wrapped_key")
+            if not wrapped_key_hex:
+                raise Exception("No wrapped key found in response")
+            
+            # Unwrap symmetric key with RSA private key
+            wrapped_key = bytes.fromhex(wrapped_key_hex)
+            symmetric_key = private_key.decrypt(
+                wrapped_key,
+                padding.OAEP(
+                    mgf=padding.MGF1(algorithm=hashes.SHA256()),
+                    algorithm=hashes.SHA256(),
+                    label=None
+                )
+            )
+            
+            # Decrypt content with XChaCha20-Poly1305
+            nonce_size = 24
+            nonce = content[:nonce_size]
+            ciphertext = content[nonce_size:]
+            
+            decrypted = nacl.bindings.crypto_aead_xchacha20poly1305_ietf_decrypt(
+                ciphertext,
+                None,  # no additional data
+                nonce,
+                symmetric_key
+            )
+            
+            content = decrypted.decode('utf-8')
+            
+        except ImportError:
+            raise ImportError("Decryption requires: pip install cryptography pynacl")
+        except Exception as e:
+            raise Exception(f"Decryption failed: {e}")
+    elif metadata.get("encrypted") and not key:
+        # Return encrypted bytes if no key provided
+        return content
+    
+    # Convert bytes to string if needed
+    if isinstance(content, bytes):
+        content = content.decode('utf-8')
+    
+    # If not evaluating, just return the content
+    if not eval:
+        return content
+    
+    # If evaluating, show confirmation unless accept=True
+    if not accept:
+        print("=" * 60)
+        print(f"Script: {username}/{script}")
+        print("=" * 60)
+        print(content)
+        print("=" * 60)
+        response = input("Execute this script? (y/N): ").strip().lower()
+        if response != 'y':
+            print("Execution cancelled.")
+            return None
+    
+    # Execute the script
+    try:
+        import subprocess
+        import tempfile
+        import os
+        import sys
+        
+        # Check for shebang
+        lines = content.split('\n')
+        if lines[0].startswith('#!'):
+            shebang = lines[0].lower()
+            
+            # If shebang contains 'python', execute in current context with exec
+            if 'python' in shebang:
+                exec_globals = {}
+                exec(content, exec_globals)
+                return exec_globals
+            else:
+                # Execute with specified interpreter (bash, sh, etc.)
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.sh', delete=False) as f:
+                    f.write(content)
+                    temp_path = f.name
+                
+                try:
+                    os.chmod(temp_path, 0o755)
+                    result = subprocess.run(
+                        [temp_path],
+                        capture_output=True,
+                        text=True,
+                        shell=False
+                    )
+                    
+                    if result.stdout:
+                        print(result.stdout, end='')
+                    if result.stderr:
+                        print(result.stderr, end='', file=sys.stderr)
+                    
+                    return result.returncode
+                finally:
+                    os.unlink(temp_path)
+        else:
+            # No shebang, execute as Python
+            exec_globals = {}
+            exec(content, exec_globals)
+            return exec_globals
+    except Exception as e:
+        print(f"Error executing script: {e}")
+        raise

shebangrun-0.1.0/shebangrun.egg-info/PKG-INFO

@@ -0,0 +1,299 @@
+Metadata-Version: 2.4
+Name: shebangrun
+Version: 0.1.0
+Summary: Python client library for shebang.run
+Author-email: "shebang.run" <hello@shebang.run>
+License: MIT
+Project-URL: Homepage, https://shebang.run
+Project-URL: Documentation, https://shebang.run/docs
+Project-URL: Repository, https://github.com/shebangrun/python-client
+Keywords: shebang,scripts,automation,devops
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+
+# shebangrun Python Client
+
+Python client library for [shebang.run](https://shebang.run) - a platform for hosting and sharing shell scripts with versioning, encryption, and signing.
+
+## Installation
+
+```bash
+pip install shebangrun
+```
+
+Or install from source:
+
+```bash
+cd python
+pip install -e .
+```
+
+## Quick Start
+
+### Simple Script Fetching
+
+```python
+from shebangrun import run
+
+# Fetch a script (returns content as string)
+content = run(username="mpruitt", script="bashtest")
+print(content)
+```
+
+### Execute Python Scripts
+
+```python
+from shebangrun import run
+
+# Fetch and execute with confirmation prompt
+run(username="mpruitt", script="myscript", eval=True)
+
+# Execute without confirmation (use with caution!)
+run(username="mpruitt", script="myscript", eval=True, accept=True)
+```
+
+### Working with Versions
+
+```python
+from shebangrun import run
+
+# Get latest version
+content = run(username="mpruitt", script="deploy", version="latest")
+
+# Get specific version
+content = run(username="mpruitt", script="deploy", version="v5")
+
+# Get tagged version
+content = run(username="mpruitt", script="deploy", version="dev")
+```
+
+### Private Scripts
+
+```python
+from shebangrun import run
+
+# Access private script with share token
+content = run(
+    username="mpruitt", 
+    script="private-script",
+    token="your-share-token-here"
+)
+```
+
+## Full API Client
+
+For more advanced usage, use the `ShebangClient` class:
+
+```python
+from shebangrun import ShebangClient
+
+# Initialize client
+client = ShebangClient(url="shebang.run")
+
+# Login
+client.login(username="myuser", password="mypassword")
+
+# Create a script
+client.create_script(
+    name="hello",
+    content="#!/bin/bash\necho 'Hello World'",
+    description="My first script",
+    visibility="public"
+)
+
+# List your scripts
+scripts = client.list_scripts()
+for script in scripts:
+    print(f"{script['name']} - v{script['version']}")
+
+# Update a script (creates new version)
+client.update_script(
+    script_id=1,
+    content="#!/bin/bash\necho 'Hello World v2'",
+    tag="dev"
+)
+
+# Generate share token for private script
+token = client.generate_share_token(script_id=1)
+print(f"Share URL: https://shebang.run/myuser/myscript?token={token}")
+
+# Get script metadata
+meta = client.get_metadata(username="mpruitt", script="bashtest")
+print(f"Version: {meta['version']}, Size: {meta['size']} bytes")
+
+# Verify signature
+verification = client.verify_signature(username="mpruitt", script="bashtest")
+print(f"Signed: {verification['signed']}")
+```
+
+## Key Management
+
+```python
+from shebangrun import ShebangClient
+
+client = ShebangClient(url="shebang.run")
+client.login(username="myuser", password="mypassword")
+
+# Generate a new keypair
+key = client.generate_key(name="my-signing-key")
+print(f"Public Key: {key['public_key']}")
+print(f"Private Key: {key['private_key']}")  # Save this securely!
+
+# List keys
+keys = client.list_keys()
+for key in keys:
+    print(f"{key['name']} - Created: {key['created_at']}")
+
+# Import existing public key
+client.import_key(
+    name="imported-key",
+    public_key="-----BEGIN PUBLIC KEY-----\n..."
+)
+
+# Delete a key
+client.delete_key(key_id=1)
+```
+
+## Account Management
+
+```python
+from shebangrun import ShebangClient
+
+client = ShebangClient(url="shebang.run")
+client.login(username="myuser", password="mypassword")
+
+# Change password
+client.change_password(
+    current_password="oldpass",
+    new_password="newpass"
+)
+
+# Export all data (GDPR)
+data = client.export_data()
+print(f"Exported {len(data['scripts'])} scripts")
+
+# Delete account (permanent!)
+client.delete_account()
+```
+
+## API Reference
+
+### `run()` Function
+
+```python
+run(username, script, key=None, eval=False, accept=False, 
+    url="shebang.run", version=None, token=None)
+```
+
+**Parameters:**
+- `username` (str, required): Script owner's username
+- `script` (str, required): Script name
+- `key` (str, optional): Private key for decryption (not yet implemented)
+- `eval` (bool, optional): Execute the script in Python (default: False)
+- `accept` (bool, optional): Skip confirmation when eval=True (default: False)
+- `url` (str, optional): Base URL (default: "shebang.run")
+- `version` (str, optional): Version tag (e.g., "latest", "v1", "dev")
+- `token` (str, optional): Share token for private scripts
+
+**Returns:**
+- String content if `eval=False`
+- Execution result if `eval=True`
+
+### `ShebangClient` Class
+
+#### Authentication
+- `register(username, email, password)` - Register new user
+- `login(username, password)` - Login and get JWT token
+
+#### Script Management
+- `list_scripts()` - List user's scripts
+- `get_script(username, script, version=None, token=None)` - Fetch script content
+- `get_metadata(username, script)` - Get script metadata
+- `verify_signature(username, script)` - Verify script signature
+- `create_script(name, content, description="", visibility="private", keypair_id=None)` - Create script
+- `update_script(script_id, content=None, description=None, visibility=None, tag=None, keypair_id=None)` - Update script
+- `delete_script(script_id)` - Delete script
+- `generate_share_token(script_id)` - Generate share token
+- `revoke_share_token(script_id, token)` - Revoke share token
+
+#### Key Management
+- `list_keys()` - List keypairs
+- `generate_key(name)` - Generate new keypair
+- `import_key(name, public_key)` - Import public key
+- `delete_key(key_id)` - Delete keypair
+
+#### Account Management
+- `change_password(current_password, new_password)` - Change password
+- `export_data()` - Export all data (GDPR)
+- `delete_account()` - Delete account
+
+## Security Notes
+
+⚠️ **Warning:** Using `eval=True` with `accept=True` will execute remote code without confirmation. Only use this with scripts you trust completely.
+
+✅ **Best Practices:**
+- Always review scripts before executing with `eval=True`
+- Use `accept=False` (default) to see the script before execution
+- Store private keys securely, never commit them to version control
+- Use environment variables for tokens and credentials
+- Verify script signatures when available
+
+## Examples
+
+### Automation Script
+
+```python
+#!/usr/bin/env python3
+from shebangrun import run
+
+# Fetch deployment script and execute with confirmation
+run(
+    username="devops",
+    script="deploy-prod",
+    version="latest",
+    eval=True,
+    accept=False  # Always confirm production deployments!
+)
+```
+
+### CI/CD Integration
+
+```python
+import os
+from shebangrun import ShebangClient
+
+client = ShebangClient()
+client.login(
+    username=os.environ["SHEBANG_USER"],
+    password=os.environ["SHEBANG_PASS"]
+)
+
+# Update deployment script
+client.update_script(
+    script_id=int(os.environ["DEPLOY_SCRIPT_ID"]),
+    content=open("deploy.sh").read(),
+    tag="latest"
+)
+
+print("Deployment script updated!")
+```
+
+## License
+
+MIT
+
+## Links
+
+- Website: https://shebang.run
+- Documentation: https://shebang.run/docs
+- GitHub: https://github.com/shebangrun/python-client

shebangrun-0.1.0/shebangrun.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+shebangrun/__init__.py
+shebangrun/client.py
+shebangrun.egg-info/PKG-INFO
+shebangrun.egg-info/SOURCES.txt
+shebangrun.egg-info/dependency_links.txt
+shebangrun.egg-info/requires.txt
+shebangrun.egg-info/top_level.txt

shebangrun-0.1.0/shebangrun.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

shebangrun-0.1.0/shebangrun.egg-info/requires.txt

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

shebangrun-0.1.0/shebangrun.egg-info/top_level.txt

@@ -0,0 +1 @@
+shebangrun