shebangrun 0.2.0__py3-none-any.whl

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/cli.py

@@ -0,0 +1,530 @@
+#!/usr/bin/env python3
+"""
+shebang - CLI tool for shebang.run
+"""
+
+import sys
+import os
+import argparse
+import json
+from pathlib import Path
+
+try:
+    from shebangrun import ShebangClient, run
+except ImportError:
+    print("Error: shebangrun library not found", file=sys.stderr)
+    print("Install with: pip install shebangrun", file=sys.stderr)
+    sys.exit(1)
+
+CONFIG_FILE = Path.home() / '.shebangrc'
+
+def load_config():
+    """Load configuration from ~/.shebangrc"""
+    config = {}
+    if CONFIG_FILE.exists():
+        with open(CONFIG_FILE) as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#') and '=' in line:
+                    key, value = line.split('=', 1)
+                    config[key] = value.strip('"')
+    return config
+
+def save_config(config):
+    """Save configuration to ~/.shebangrc"""
+    with open(CONFIG_FILE, 'w') as f:
+        f.write('# shebang.run CLI configuration\n')
+        for key, value in config.items():
+            f.write(f'{key}="{value}"\n')
+    CONFIG_FILE.chmod(0o600)
+
+def cmd_login(args):
+    """Login and generate API credentials"""
+    print("shebang.run Login")
+    print("=" * 50)
+    print()
+    
+    url = input("Server URL [https://shebang.run]: ").strip() or "https://shebang.run"
+    username = input("Username: ").strip()
+    if not username:
+        print("Error: Username required", file=sys.stderr)
+        sys.exit(1)
+    
+    import getpass
+    password = getpass.getpass("Password: ")
+    if not password:
+        print("Error: Password required", file=sys.stderr)
+        sys.exit(1)
+    
+    key_path = input("Private Key Path (optional): ").strip()
+    
+    # Login
+    print("Logging in...")
+    client = ShebangClient(url=url.replace('https://', '').replace('http://', ''))
+    
+    try:
+        response = client.login(username, password)
+        token = response['token']
+    except Exception as e:
+        print(f"Error: Login failed - {e}", file=sys.stderr)
+        sys.exit(1)
+    
+    # Generate API token
+    print("Generating API credentials...")
+    try:
+        import datetime
+        token_name = f"CLI-{datetime.datetime.now().strftime('%Y%m%d-%H%M%S')}"
+        api_token = client.create_api_token(token_name)
+        
+        config = {
+            'SHEBANG_URL': url,
+            'SHEBANG_USERNAME': username,
+            'SHEBANG_CLIENT_ID': api_token['client_id'],
+            'SHEBANG_CLIENT_SECRET': api_token['client_secret'],
+            'SHEBANG_KEY_PATH': key_path
+        }
+        save_config(config)
+        
+        print("✓ API credentials generated!")
+        print()
+        print(f"Client ID: {api_token['client_id']}")
+        print(f"Client Secret: {api_token['client_secret'][:20]}...")
+        print()
+        print(f"Config saved to {CONFIG_FILE}")
+        print("Keep your credentials secure!")
+        
+    except Exception as e:
+        print(f"Error: Failed to generate API credentials - {e}", file=sys.stderr)
+        sys.exit(1)
+
+def cmd_list(args):
+    """List scripts"""
+    config = load_config()
+    if not config.get('SHEBANG_CLIENT_ID'):
+        print("Error: Not logged in. Run: shebang login", file=sys.stderr)
+        sys.exit(1)
+    
+    client = ShebangClient(url=config['SHEBANG_URL'].replace('https://', '').replace('http://', ''))
+    client.session.auth = (config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+    
+    print("Your Scripts:")
+    print("=" * 50)
+    
+    try:
+        scripts = client.list_scripts()
+        for s in scripts:
+            vis = s['visibility']
+            color = '\033[0;32m' if vis == 'public' else '\033[1;33m' if vis == 'unlisted' else '\033[0;31m'
+            print(f"{color}{s['name']}\033[0m (v{s['version']}) - {s.get('description', 'No description')} [{vis}]")
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    
+    if args.community:
+        print()
+        print("Community Scripts:")
+        print("=" * 50)
+        
+        try:
+            import requests
+            response = requests.get(
+                f"{config['SHEBANG_URL']}/api/community/scripts",
+                auth=(config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+            )
+            scripts = response.json()
+            for s in scripts:
+                print(f"\033[0;32m{s['username']}/{s['name']}\033[0m (v{s['version']}) - {s.get('description', 'No description')}")
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+
+def cmd_search(args):
+    """Search scripts"""
+    config = load_config()
+    if not config.get('SHEBANG_CLIENT_ID'):
+        print("Error: Not logged in. Run: shebang login", file=sys.stderr)
+        sys.exit(1)
+    
+    if not args.query:
+        print("Error: Search query required", file=sys.stderr)
+        sys.exit(1)
+    
+    client = ShebangClient(url=config['SHEBANG_URL'].replace('https://', '').replace('http://', ''))
+    client.session.auth = (config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+    
+    query = args.query.lower()
+    
+    print(f"Searching for: {args.query}")
+    print()
+    
+    try:
+        scripts = client.list_scripts()
+        found = False
+        for s in scripts:
+            if query in s['name'].lower() or query in s.get('description', '').lower():
+                found = True
+                vis = s['visibility']
+                color = '\033[0;32m' if vis == 'public' else '\033[1;33m' if vis == 'unlisted' else '\033[0;31m'
+                print(f"{color}{s['name']}\033[0m (v{s['version']}) - {s.get('description', 'No description')} [{vis}]")
+        
+        if not found:
+            print("No matches in your scripts")
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+    
+    if args.community:
+        print()
+        print("Community Results:")
+        
+        try:
+            import requests
+            response = requests.get(
+                f"{config['SHEBANG_URL']}/api/community/scripts",
+                auth=(config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+            )
+            scripts = response.json()
+            found = False
+            for s in scripts:
+                if query in s['name'].lower() or query in s.get('description', '').lower() or query in s['username'].lower():
+                    found = True
+                    print(f"\033[0;32m{s['username']}/{s['name']}\033[0m (v{s['version']}) - {s.get('description', 'No description')}")
+            
+            if not found:
+                print("No matches in community")
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+
+def cmd_get(args):
+    """Get a script"""
+    config = load_config()
+    
+    user = args.user or config.get('SHEBANG_USERNAME')
+    if not user:
+        print("Error: Username required. Use -u or login first.", file=sys.stderr)
+        sys.exit(1)
+    
+    key_path = args.key or config.get('SHEBANG_KEY_PATH')
+    key_content = None
+    if key_path and os.path.exists(key_path):
+        with open(key_path) as f:
+            key_content = f.read()
+    
+    try:
+        content = run(
+            username=user,
+            script=args.script,
+            key=key_content,
+            url=config.get('SHEBANG_URL', 'shebang.run').replace('https://', '').replace('http://', '')
+        )
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(content)
+            print(f"✓ Script saved to: {args.output}")
+        else:
+            print(content)
+            
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def cmd_run(args):
+    """Run a script"""
+    config = load_config()
+    
+    user = args.user or config.get('SHEBANG_USERNAME')
+    if not user:
+        print("Error: Username required. Use -u or login first.", file=sys.stderr)
+        sys.exit(1)
+    
+    key_path = args.key or config.get('SHEBANG_KEY_PATH')
+    key_content = None
+    if key_path and os.path.exists(key_path):
+        with open(key_path) as f:
+            key_content = f.read()
+    
+    try:
+        content = run(
+            username=user,
+            script=args.script,
+            key=key_content,
+            url=config.get('SHEBANG_URL', 'shebang.run').replace('https://', '').replace('http://', '')
+        )
+        
+        # Save to temp file or specified output
+        import tempfile
+        if args.output:
+            script_file = args.output
+        else:
+            fd, script_file = tempfile.mkstemp(suffix=f'-{args.script}')
+            os.close(fd)
+        
+        with open(script_file, 'w') as f:
+            f.write(content)
+        os.chmod(script_file, 0o755)
+        
+        # Show script and prompt if not auto-accept
+        if not args.accept:
+            print()
+            print("Script content:")
+            print("=" * 60)
+            print(content)
+            print("=" * 60)
+            print()
+            confirm = input("Execute this script? (y/N): ").strip().lower()
+            if confirm != 'y':
+                if not args.output:
+                    os.unlink(script_file)
+                print("Execution cancelled")
+                sys.exit(0)
+        
+        # Execute script
+        print("Executing script...")
+        print()
+        
+        import subprocess
+        result = subprocess.run(
+            [script_file] + (args.script_args or []),
+            capture_output=False
+        )
+        
+        # Cleanup
+        if args.delete or not args.output:
+            os.unlink(script_file)
+        elif not args.output:
+            print(f"\n✓ Script saved to: {script_file}")
+        
+        sys.exit(result.returncode)
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def cmd_list_keys(args):
+    """List keypairs"""
+    config = load_config()
+    if not config.get('SHEBANG_CLIENT_ID'):
+        print("Error: Not logged in. Run: shebang login", file=sys.stderr)
+        sys.exit(1)
+    
+    client = ShebangClient(url=config['SHEBANG_URL'].replace('https://', '').replace('http://', ''))
+    client.session.auth = (config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+    
+    try:
+        keys = client.list_keys()
+        if not keys:
+            print("No keys found")
+            return
+        
+        print("Your Keys:")
+        print("=" * 50)
+        for k in keys:
+            print(f"{k['name']}")
+            print(f"  Created: {k['created_at']}")
+            print()
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def cmd_create_key(args):
+    """Create a new keypair"""
+    config = load_config()
+    if not config.get('SHEBANG_CLIENT_ID'):
+        print("Error: Not logged in. Run: shebang login", file=sys.stderr)
+        sys.exit(1)
+    
+    name = input("Key name: ").strip()
+    if not name:
+        print("Error: Key name required", file=sys.stderr)
+        sys.exit(1)
+    
+    client = ShebangClient(url=config['SHEBANG_URL'].replace('https://', '').replace('http://', ''))
+    client.session.auth = (config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+    
+    try:
+        print("Generating RSA-4096 keypair...")
+        key = client.generate_key(name)
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(key['private_key'])
+            print(f"✓ Private key saved to: {args.output}")
+            print(f"✓ Public key stored in account: {name}")
+        else:
+            print(key['private_key'])
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def cmd_delete_key(args):
+    """Delete a keypair"""
+    config = load_config()
+    if not config.get('SHEBANG_CLIENT_ID'):
+        print("Error: Not logged in. Run: shebang login", file=sys.stderr)
+        sys.exit(1)
+    
+    client = ShebangClient(url=config['SHEBANG_URL'].replace('https://', '').replace('http://', ''))
+    client.session.auth = (config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+    
+    try:
+        # Find key by name
+        keys = client.list_keys()
+        key = next((k for k in keys if k['name'] == args.keyname), None)
+        
+        if not key:
+            print(f"Error: Key '{args.keyname}' not found", file=sys.stderr)
+            sys.exit(1)
+        
+        confirm = input(f"Delete key '{args.keyname}'? (y/N): ").strip().lower()
+        if confirm != 'y':
+            print("Cancelled")
+            sys.exit(0)
+        
+        client.delete_key(key['id'])
+        print(f"✓ Key '{args.keyname}' deleted")
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def cmd_put(args):
+    """Upload a script"""
+    config = load_config()
+    if not config.get('SHEBANG_CLIENT_ID'):
+        print("Error: Not logged in. Run: shebang login", file=sys.stderr)
+        sys.exit(1)
+    
+    # Read content
+    if args.stdin:
+        content = sys.stdin.read()
+    elif args.file:
+        with open(args.file) as f:
+            content = f.read()
+    else:
+        print("Error: Must specify -s/--stdin or -f/--file", file=sys.stderr)
+        sys.exit(1)
+    
+    # Validate visibility
+    visibility_map = {'priv': 'private', 'unlist': 'unlisted', 'public': 'public'}
+    visibility = visibility_map.get(args.visibility, args.visibility)
+    if visibility not in ['private', 'unlisted', 'public']:
+        print("Error: Visibility must be priv, unlist, or public", file=sys.stderr)
+        sys.exit(1)
+    
+    client = ShebangClient(url=config['SHEBANG_URL'].replace('https://', '').replace('http://', ''))
+    client.session.auth = (config['SHEBANG_CLIENT_ID'], config['SHEBANG_CLIENT_SECRET'])
+    
+    try:
+        # Get keypair ID if specified
+        keypair_id = None
+        if args.keyname:
+            keys = client.list_keys()
+            key = next((k for k in keys if k['name'] == args.keyname), None)
+            if not key:
+                print(f"Error: Key '{args.keyname}' not found", file=sys.stderr)
+                sys.exit(1)
+            keypair_id = key['id']
+        elif visibility == 'private':
+            print("Error: Private scripts require -k/--keyname", file=sys.stderr)
+            sys.exit(1)
+        
+        print(f"Uploading script '{args.name}'...")
+        result = client.create_script(
+            name=args.name,
+            content=content,
+            description=args.description or "",
+            visibility=visibility,
+            keypair_id=keypair_id
+        )
+        
+        print(f"✓ Script created: {args.name} (v{result['version']})")
+        print(f"  URL: {config['SHEBANG_URL']}/{config['SHEBANG_USERNAME']}/{args.name}")
+        
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='shebang',
+        description='CLI tool for shebang.run',
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+    
+    # Login
+    subparsers.add_parser('login', help='Login and generate API credentials')
+    
+    # List
+    list_parser = subparsers.add_parser('list', help='List scripts')
+    list_parser.add_argument('-c', '--community', action='store_true', help='Include community scripts')
+    
+    # Search
+    search_parser = subparsers.add_parser('search', help='Search scripts')
+    search_parser.add_argument('query', help='Search query')
+    search_parser.add_argument('-c', '--community', action='store_true', help='Include community scripts')
+    
+    # Get
+    get_parser = subparsers.add_parser('get', help='Download a script')
+    get_parser.add_argument('script', help='Script name')
+    get_parser.add_argument('-u', '--user', help='Username')
+    get_parser.add_argument('-O', '--output', help='Output file')
+    get_parser.add_argument('-k', '--key', help='Private key path')
+    
+    # Run
+    run_parser = subparsers.add_parser('run', help='Download and execute a script')
+    run_parser.add_argument('script', help='Script name')
+    run_parser.add_argument('-u', '--user', help='Username')
+    run_parser.add_argument('-O', '--output', help='Output file')
+    run_parser.add_argument('-k', '--key', help='Private key path')
+    run_parser.add_argument('-a', '--accept', action='store_true', help='Auto-accept execution')
+    run_parser.add_argument('-d', '--delete', action='store_true', help='Delete after execution')
+    run_parser.add_argument('script_args', nargs='*', help='Arguments to pass to script')
+    
+    # List keys
+    subparsers.add_parser('list-keys', help='List your keypairs')
+    
+    # Create key
+    create_key_parser = subparsers.add_parser('create-key', help='Generate a new keypair')
+    create_key_parser.add_argument('-O', '--output', help='Save private key to file')
+    
+    # Delete key
+    delete_key_parser = subparsers.add_parser('delete-key', help='Delete a keypair')
+    delete_key_parser.add_argument('keyname', help='Key name to delete')
+    
+    # Put (upload script)
+    put_parser = subparsers.add_parser('put', help='Upload a script')
+    put_parser.add_argument('-n', '--name', required=True, help='Script name')
+    put_parser.add_argument('-v', '--visibility', required=True, choices=['priv', 'unlist', 'public'], help='Visibility')
+    put_parser.add_argument('-d', '--description', default='', help='Description')
+    put_parser.add_argument('-k', '--keyname', help='Key name for encryption (required for private)')
+    put_parser.add_argument('-s', '--stdin', action='store_true', help='Read from stdin')
+    put_parser.add_argument('-f', '--file', help='Read from file')
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+    
+    if args.command == 'login':
+        cmd_login(args)
+    elif args.command == 'list':
+        cmd_list(args)
+    elif args.command == 'search':
+        cmd_search(args)
+    elif args.command == 'get':
+        cmd_get(args)
+    elif args.command == 'run':
+        cmd_run(args)
+    elif args.command == 'list-keys':
+        cmd_list_keys(args)
+    elif args.command == 'create-key':
+        cmd_create_key(args)
+    elif args.command == 'delete-key':
+        cmd_delete_key(args)
+    elif args.command == 'put':
+        cmd_put(args)
+
+if __name__ == '__main__':
+    main()

shebangrun/client.py

@@ -0,0 +1,385 @@
+"""
+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 create_api_token(self, name: str) -> dict:
+        """Create API token for CLI access"""
+        url = f"{self.base_url}/api/account/tokens"
+        response = self.session.post(url, json={"name": name})
+        response.raise_for_status()
+        return response.json()
+
+
+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.2.0.dist-info/METADATA

@@ -0,0 +1,419 @@
+Metadata-Version: 2.4
+Name: shebangrun
+Version: 0.2.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/skibare87/shebangrun
+Project-URL: Bug Tracker, https://github.com/skibare87/shebangrun/issues
+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
+Requires-Dist: cryptography>=3.4.0
+Requires-Dist: pynacl>=1.4.0
+
+# shebangrun Python Client
+
+Python client library and CLI tool for [shebang.run](https://shebang.run) - a platform for hosting and sharing shell scripts with versioning, encryption, and signing.
+
+## Installation
+
+```bash
+pip install shebangrun
+```
+
+This installs both the Python library and the `shebang` CLI tool.
+
+## CLI Tool
+
+### Quick Start
+
+```bash
+# Login and generate API credentials
+shebang login
+
+# List your scripts
+shebang list
+
+# Get a script
+shebang get myscript
+
+# Run a script
+shebang run myscript
+```
+
+### Commands
+
+#### Login
+```bash
+shebang login
+```
+Interactive wizard that:
+- Prompts for server URL, username, password
+- Generates API credentials (Client ID/Secret)
+- Saves to `~/.shebangrc`
+
+#### List Scripts
+```bash
+# Your scripts
+shebang list
+
+# Include community scripts
+shebang list -c
+```
+
+#### Search Scripts
+```bash
+# Search your scripts
+shebang search "deploy"
+
+# Search community
+shebang search -c "backup"
+```
+
+#### Get Script
+```bash
+# Download to stdout
+shebang get myscript
+
+# From another user
+shebang get -u username scriptname
+
+# Save to file
+shebang get -O deploy.sh myscript
+
+# Decrypt with private key
+shebang get -k private.pem encrypted-script
+```
+
+#### Run Script
+```bash
+# Run with confirmation
+shebang run myscript
+
+# Auto-accept (no prompt)
+shebang run -a myscript
+
+# Pass arguments
+shebang run myscript arg1 arg2
+
+# Run and delete
+shebang run -d myscript
+```
+
+#### Key Management
+```bash
+# List keys
+shebang list-keys
+
+# Create new keypair
+shebang create-key
+shebang create-key -O mykey.pem
+
+# Delete key
+shebang delete-key keyname
+```
+
+#### Upload Script
+```bash
+# Upload from file
+shebang put -n myscript -v public -f script.sh
+
+# Upload from stdin
+cat script.sh | shebang put -n myscript -v public -s
+
+# Upload private script with encryption
+shebang put -n private-script -v priv -k my-key -f script.sh -d "My private script"
+```
+
+### CLI Options
+
+**Visibility:**
+- `priv` - Private (encrypted, requires key)
+- `unlist` - Unlisted (accessible via URL only)
+- `public` - Public (listed in community)
+
+**Configuration:**
+Stored in `~/.shebangrc`:
+```bash
+SHEBANG_URL="https://shebang.run"
+SHEBANG_USERNAME="myuser"
+SHEBANG_CLIENT_ID="..."
+SHEBANG_CLIENT_SECRET="..."
+SHEBANG_KEY_PATH="/path/to/key.pem"
+```
+
+## Python Library
+
+## Python Library
+
+### 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/skibare87/shebangrun
+- PyPI: https://pypi.org/project/shebangrun/

shebangrun-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+shebangrun/__init__.py,sha256=YQhIJG4ln6svf_ZGIk460mj8Juh8CDmNIYdaQ81BVYc,237
+shebangrun/cli.py,sha256=1BFYH_Cgretn0I4s6sjJIciq5OWLzc01W3xS7WKw3dU,18495
+shebangrun/client.py,sha256=k6kqNgweDdM1i4ZHJGx5FLAh7ZChBAWVgkUEb3uCmPc,14143
+shebangrun-0.2.0.dist-info/METADATA,sha256=p1mxO152mxd_DXVhlWsfPQl1XcSYe-_D0YZ-xAXsTlQ,9941
+shebangrun-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shebangrun-0.2.0.dist-info/entry_points.txt,sha256=je5p9fSB9d-GzrI4XAeqMnzVAW9a-HNCZOZUnS2vp1U,48
+shebangrun-0.2.0.dist-info/top_level.txt,sha256=XGgqFinUfnCC_bMMYqexpD-W9Pqh2i-LKrqSEdrPhgU,11
+shebangrun-0.2.0.dist-info/RECORD,,

shebangrun-0.2.0.dist-info/WHEEL

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

shebangrun-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shebang = shebangrun.cli:main

shebangrun-0.2.0.dist-info/top_level.txt

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