claude-code-tools 1.0.10__py3-none-any.whl

claude_code_tools/delete_session.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Delete Claude Code or Codex session files with confirmation."""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Tuple
+
+from claude_code_tools.session_utils import resolve_session_path
+
+
+def get_session_info(session_file: Path) -> dict:
+    """
+    Extract session information for display.
+
+    Args:
+        session_file: Path to session file
+
+    Returns:
+        Dict with session metadata (lines, date_range, last_user_msg, etc.)
+    """
+    with open(session_file, 'r') as f:
+        lines = f.readlines()
+
+    total_lines = len(lines)
+    first_timestamp = None
+    last_timestamp = None
+    last_user_msg = None
+
+    for line in lines:
+        try:
+            data = json.loads(line.strip())
+
+            # Extract timestamp
+            timestamp = None
+            if 'timestamp' in data:
+                timestamp = data['timestamp']
+            elif 'created_at' in data:
+                timestamp = data['created_at']
+
+            if timestamp:
+                if first_timestamp is None:
+                    first_timestamp = timestamp
+                last_timestamp = timestamp
+
+            # Look for last user message
+            msg_type = data.get('type')
+
+            # Claude Code format
+            if msg_type == 'user':
+                message = data.get('message', {})
+                content = message.get('content', [])
+                if isinstance(content, list):
+                    for item in content:
+                        if isinstance(item, dict) and item.get('type') == 'text':
+                            text = item.get('text', '').strip()
+                            if text:
+                                last_user_msg = text
+                elif isinstance(content, str):
+                    last_user_msg = content.strip()
+
+            # Codex format
+            elif msg_type == 'response_item':
+                payload = data.get('payload', {})
+                if payload.get('type') == 'message' and payload.get('role') == 'user':
+                    content = payload.get('content', [])
+                    if isinstance(content, list):
+                        for item in content:
+                            if isinstance(item, dict) and item.get('type') == 'input_text':
+                                text = item.get('text', '').strip()
+                                if text:
+                                    last_user_msg = text
+
+        except (json.JSONDecodeError, KeyError):
+            continue
+
+    return {
+        'total_lines': total_lines,
+        'first_timestamp': first_timestamp,
+        'last_timestamp': last_timestamp,
+        'last_user_msg': last_user_msg,
+    }
+
+
+def format_timestamp(ts: Optional[str]) -> str:
+    """Format timestamp for display."""
+    if not ts:
+        return 'Unknown'
+
+    try:
+        # Try ISO format
+        dt = datetime.fromisoformat(ts.replace('Z', '+00:00'))
+        return dt.strftime('%Y-%m-%d %H:%M:%S')
+    except:
+        return ts
+
+
+def confirm_deletion(session_file: Path, info: dict) -> bool:
+    """
+    Show session info and ask for confirmation.
+
+    Args:
+        session_file: Path to session file
+        info: Session metadata dict
+
+    Returns:
+        True if user confirms deletion, False otherwise
+    """
+    print("\n" + "=" * 70)
+    print("SESSION DELETION CONFIRMATION")
+    print("=" * 70)
+    print(f"\nFile: {session_file}")
+    print(f"Session ID: {session_file.stem}")
+    print(f"\nTotal lines: {info['total_lines']}")
+
+    # Date range
+    first = format_timestamp(info['first_timestamp'])
+    last = format_timestamp(info['last_timestamp'])
+    if first != 'Unknown' or last != 'Unknown':
+        print(f"Date range: {first} → {last}")
+
+    # Last user message
+    if info['last_user_msg']:
+        # Truncate if too long
+        msg = info['last_user_msg']
+        if len(msg) > 200:
+            msg = msg[:200] + "..."
+        print(f"\nLast user message:")
+        print(f"  {msg}")
+
+    print("\n" + "=" * 70)
+    response = input("\nAre you sure you want to DELETE this session? (yes/no): ").strip().lower()
+    return response in ['yes', 'y']
+
+
+def main():
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Delete Claude Code or Codex session files with confirmation"
+    )
+    parser.add_argument(
+        "session_file",
+        help="Session file path or session ID (supports partial matching)"
+    )
+    parser.add_argument(
+        "--claude-home",
+        type=str,
+        help="Path to Claude home directory (default: ~/.claude or $CLAUDE_CONFIG_DIR)"
+    )
+    parser.add_argument(
+        "--force",
+        "-f",
+        action="store_true",
+        help="Skip confirmation prompt (use with caution!)"
+    )
+
+    args = parser.parse_args()
+
+    # Resolve session file
+    try:
+        session_file = resolve_session_path(args.session_file, claude_home=args.claude_home)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except SystemExit:
+        # resolve_session_path calls sys.exit for multiple matches
+        sys.exit(1)
+
+    # Get session info
+    try:
+        info = get_session_info(session_file)
+    except Exception as e:
+        print(f"Error reading session file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Confirm deletion
+    if not args.force:
+        if not confirm_deletion(session_file, info):
+            print("\nDeletion cancelled.")
+            sys.exit(0)
+
+    # Delete the file
+    try:
+        session_file.unlink()
+        print(f"\n✅ Session deleted: {session_file.stem}")
+    except Exception as e:
+        print(f"\n❌ Error deleting session: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

claude_code_tools/dotenv_vault.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+"""Centralized encrypted backup for .env files using SOPS."""
+
+import os
+import sys
+import subprocess
+import datetime
+from pathlib import Path
+
+import click
+
+
+class DotenvVault:
+    def __init__(self):
+        self.vault_dir = Path.home() / "Git" / "dotenvs"
+        self.vault_dir.mkdir(parents=True, exist_ok=True)
+        self._ensure_gpg_key()
+
+    def _ensure_gpg_key(self):
+        """Detect GPG key or fail early."""
+        try:
+            result = subprocess.run(
+                ["gpg", "--list-secret-keys", "--keyid-format", "LONG"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            lines = result.stdout.strip().split('\n')
+            for line in lines:
+                if 'sec' in line:
+                    key = line.split()[1].split('/')[1]
+                    self.gpg_key = key
+                    return
+            click.echo("❌ No GPG key found. Run: gpg --gen-key", err=True)
+            sys.exit(1)
+        except subprocess.CalledProcessError:
+            click.echo("❌ GPG not found or error listing keys", err=True)
+            sys.exit(1)
+
+    def _project_name(self):
+        """Get current project name from directory."""
+        return Path.cwd().name
+
+    def _backup_path(self, project=None):
+        """Get encrypted file path for project."""
+        project = project or self._project_name()
+        return self.vault_dir / f"{project}.env.encrypt"
+
+    def encrypt(self, force=False):
+        """Encrypt current .env to centralized vault with protection."""
+        env_file = Path.cwd() / ".env"
+        if not env_file.exists():
+            click.echo("❌ .env not found in current directory")
+            return False
+
+        backup_path = self._backup_path()
+        
+        # Protect encrypted backup
+        if backup_path.exists():
+            if not force:
+                click.echo("⚠️  Encrypted backup already exists!")
+                if not click.confirm("Overwrite encrypted backup?", default=False):
+                    return False
+            
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_save = f"{backup_path}.backup-{timestamp}"
+            backup_path.rename(backup_save)
+            click.echo(f"💾 Backed up encrypted file → {backup_save}")
+
+        cmd = [
+            "sops", "--encrypt", 
+            "--pgp", self.gpg_key,
+            "--input-type", "dotenv",
+            "--output-type", "dotenv",
+            str(env_file)
+        ]
+        
+        try:
+            with open(backup_path, 'w') as f:
+                subprocess.run(cmd, stdout=f, check=True)
+            click.echo(f"✅ Encrypted .env → {backup_path}")
+            return True
+        except subprocess.CalledProcessError as e:
+            click.echo(f"❌ Encryption failed: {e}")
+            return False
+
+    def decrypt(self, force=False):
+        """Decrypt from centralized vault to .env with safety checks."""
+        backup_path = self._backup_path()
+        if not backup_path.exists():
+            click.echo(f"❌ {backup_path} not found")
+            return False
+
+        env_file = Path.cwd() / ".env"
+        
+        # Check if current .env is newer than backup
+        if env_file.exists():
+            env_mtime = env_file.stat().st_mtime
+            backup_mtime = backup_path.stat().st_mtime
+            
+            if env_mtime > backup_mtime:
+                click.echo("⚠️  Current .env is newer than backup!")
+                if not click.confirm("Proceed with decryption?", default=False):
+                    return False
+        
+        # Always backup current .env if it exists
+        if env_file.exists():
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_name = f".env.backup-{timestamp}"
+            env_file.rename(backup_name)
+            click.echo(f"💾 Backed up current .env → {backup_name}")
+
+        cmd = [
+            "sops", "--decrypt",
+            "--input-type", "dotenv",
+            "--output-type", "dotenv",
+            str(backup_path)
+        ]
+        
+        try:
+            with open(env_file, 'w') as f:
+                subprocess.run(cmd, stdout=f, check=True)
+            click.echo(f"✅ Decrypted {backup_path} → {env_file}")
+            return True
+        except subprocess.CalledProcessError as e:
+            click.echo(f"❌ Decryption failed: {e}")
+            return False
+
+    def list_backups(self):
+        """List all encrypted backups."""
+        backups = list(self.vault_dir.glob("*.env.encrypt"))
+        if not backups:
+            click.echo("❌ No encrypted files found")
+            return
+        
+        click.echo(f"📋 Encrypted files in {self.vault_dir}:")
+        for backup in sorted(backups):
+            size = backup.stat().st_size
+            click.echo(f"  {backup.name} ({size} bytes)")
+
+    def status(self):
+        """Show status for current project."""
+        project = self._project_name()
+        backup_path = self._backup_path()
+        
+        env_exists = Path(".env").exists()
+        backup_exists = backup_path.exists()
+        
+        if env_exists and backup_exists:
+            env_mtime = Path(".env").stat().st_mtime
+            backup_mtime = backup_path.stat().st_mtime
+            
+            if env_mtime > backup_mtime:
+                click.echo("📊 Local .env is NEWER than backup")
+                click.echo(f"   .env: {datetime.datetime.fromtimestamp(env_mtime).strftime('%Y-%m-%d %H:%M:%S')}")
+                click.echo(f"   backup: {datetime.datetime.fromtimestamp(backup_mtime).strftime('%Y-%m-%d %H:%M:%S')}")
+                return "local_newer"
+            elif backup_mtime > env_mtime:
+                click.echo("📊 Backup is NEWER than local .env")
+                click.echo(f"   .env: {datetime.datetime.fromtimestamp(env_mtime).strftime('%Y-%m-%d %H:%M:%S')}")
+                click.echo(f"   backup: {datetime.datetime.fromtimestamp(backup_mtime).strftime('%Y-%m-%d %H:%M:%S')}")
+                return "backup_newer"
+            else:
+                click.echo("✅ .env and backup are identical")
+                return "identical"
+        elif env_exists:
+            click.echo("📊 .env exists, no backup")
+            return "local_only"
+        elif backup_exists:
+            click.echo("📊 Backup exists, no local .env")
+            return "backup_only"
+        else:
+            click.echo("❌ Neither .env nor backup exists")
+            return "neither"
+
+    def sync(self, direction=None):
+        """Smart sync between local .env and centralized vault."""
+        project = self._project_name()
+        backup_path = self._backup_path()
+        env_file = Path.cwd() / ".env"
+        
+        status = self.status()
+        
+        if status == "identical":
+            click.echo("✅ Already in sync")
+            return True
+            
+        elif status == "local_only":
+            click.echo("🔄 Encrypting local .env to centralized vault")
+            return self.encrypt()
+            
+        elif status == "backup_only":
+            click.echo("🔄 Decrypting centralized vault to local .env")
+            return self.decrypt()
+            
+        elif status == "local_newer":
+            if direction == "pull":
+                click.echo("⚠️  Local .env is newer but --pull requested")
+                if click.confirm("Overwrite local .env with backup?", default=False):
+                    return self.decrypt()
+            else:
+                click.echo("🔄 Encrypting local .env to centralized vault")
+                return self.encrypt()
+                
+        elif status == "backup_newer":
+            if direction == "push":
+                click.echo("⚠️  Backup is newer but --push requested")
+                if click.confirm("Overwrite backup with local .env?", default=False):
+                    return self.encrypt()
+            else:
+                click.echo("🔄 Decrypting centralized vault to local .env")
+                return self.decrypt()
+
+
+def main():
+    """Centralized encrypted backup for .env files."""
+    import sys
+    
+    if len(sys.argv) == 1:
+        # Default to sync if no command provided
+        vault = DotenvVault()
+        vault.sync()
+    else:
+        # Normal CLI handling
+        import click
+        
+        @click.group()
+        def cli():
+            """Centralized encrypted backup for .env files."""
+            pass
+
+        @cli.command()
+        def encrypt():
+            """Encrypt current .env to centralized vault."""
+            vault = DotenvVault()
+            vault.encrypt()
+
+        @cli.command()
+        def decrypt():
+            """Decrypt from centralized vault to .env."""
+            vault = DotenvVault()
+            vault.decrypt()
+
+        @cli.command()
+        def list():
+            """List all encrypted backups."""
+            vault = DotenvVault()
+            vault.list_backups()
+
+        @cli.command()
+        def status():
+            """Show detailed status for current project."""
+            vault = DotenvVault()
+            vault.status()
+
+        @cli.command()
+        @click.option('--push', 'direction', flag_value='push', help='Force push (encrypt)')
+        @click.option('--pull', 'direction', flag_value='pull', help='Force pull (decrypt)')
+        def sync(direction):
+            """Smart sync between local .env and centralized vault."""
+            vault = DotenvVault()
+            vault.sync(direction)
+
+        cli()
+
+
+if __name__ == "__main__":
+    main()

claude_code_tools/env_safe.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+env-safe: A safe way to inspect .env files without exposing sensitive values.
+
+This tool allows Claude Code and other automated tools to:
+- List environment variable keys without showing values
+- Check if specific keys exist
+- Count the number of variables defined
+- Validate .env file syntax
+
+It specifically avoids displaying actual values to prevent accidental exposure
+of secrets, API keys, and other sensitive information.
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+from typing import List, Tuple, Optional
+import re
+
+
+def parse_env_file(filepath: Path) -> List[Tuple[str, bool]]:
+    """
+    Parse a .env file and extract variable names.
+    
+    Returns:
+        List of tuples: (variable_name, has_value)
+    """
+    if not filepath.exists():
+        raise FileNotFoundError(f"File not found: {filepath}")
+    
+    variables = []
+    
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line_num, line in enumerate(f, 1):
+            # Skip empty lines and comments
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            
+            # Match KEY=value pattern
+            match = re.match(r'^([A-Za-z_][A-Za-z0-9_]*)\s*=(.*)$', line)
+            if match:
+                key = match.group(1)
+                value = match.group(2).strip()
+                has_value = bool(value and value != '""' and value != "''")
+                variables.append((key, has_value))
+            elif '=' in line:
+                # Malformed line - has = but doesn't match pattern
+                print(f"Warning: Line {line_num} appears malformed: {line[:50]}...", 
+                      file=sys.stderr)
+    
+    return variables
+
+
+def list_keys(filepath: Path, show_status: bool = False) -> None:
+    """List all environment variable keys in the file."""
+    try:
+        variables = parse_env_file(filepath)
+        
+        if not variables:
+            print("No environment variables found in file.")
+            return
+        
+        if show_status:
+            print(f"{'KEY':<30} {'STATUS':<10}")
+            print("-" * 40)
+            for key, has_value in sorted(variables):
+                status = "defined" if has_value else "empty"
+                print(f"{key:<30} {status:<10}")
+        else:
+            for key, _ in sorted(variables):
+                print(key)
+                
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def check_key(filepath: Path, key_name: str) -> None:
+    """Check if a specific key exists in the .env file."""
+    try:
+        variables = parse_env_file(filepath)
+        
+        for key, has_value in variables:
+            if key == key_name:
+                if has_value:
+                    print(f"✓ {key_name} is defined with a value")
+                else:
+                    print(f"⚠ {key_name} is defined but empty")
+                sys.exit(0)
+        
+        print(f"✗ {key_name} is not defined")
+        sys.exit(1)
+        
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def count_variables(filepath: Path) -> None:
+    """Count the number of variables defined."""
+    try:
+        variables = parse_env_file(filepath)
+        total = len(variables)
+        with_values = sum(1 for _, has_value in variables if has_value)
+        empty = total - with_values
+        
+        print(f"Total variables: {total}")
+        if total > 0:
+            print(f"  With values: {with_values}")
+            print(f"  Empty: {empty}")
+            
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def validate_syntax(filepath: Path) -> None:
+    """Validate the syntax of the .env file."""
+    try:
+        if not filepath.exists():
+            print(f"Error: File not found: {filepath}", file=sys.stderr)
+            sys.exit(1)
+            
+        issues = []
+        valid_lines = 0
+        
+        with open(filepath, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, 1):
+                original_line = line
+                line = line.strip()
+                
+                # Skip empty lines and comments
+                if not line or line.startswith('#'):
+                    continue
+                
+                # Check for valid KEY=value pattern
+                if not re.match(r'^[A-Za-z_][A-Za-z0-9_]*\s*=.*$', line):
+                    if '=' in line:
+                        issues.append(f"Line {line_num}: Invalid key format")
+                    else:
+                        issues.append(f"Line {line_num}: Missing '=' separator")
+                else:
+                    valid_lines += 1
+        
+        if issues:
+            print(f"✗ Found {len(issues)} syntax issue(s):")
+            for issue in issues[:10]:  # Show first 10 issues
+                print(f"  {issue}")
+            if len(issues) > 10:
+                print(f"  ... and {len(issues) - 10} more")
+            sys.exit(1)
+        else:
+            print(f"✓ Syntax valid ({valid_lines} variables defined)")
+            
+    except Exception as e:
+        print(f"Error reading file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Safely inspect .env files without exposing sensitive values",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  env-safe list                    # List all keys
+  env-safe list --status           # List keys with defined/empty status
+  env-safe check API_KEY           # Check if API_KEY exists
+  env-safe count                   # Count variables
+  env-safe validate                # Check syntax
+  env-safe list --file config.env  # Use different file
+
+This tool is designed to be safe for automated tools like Claude Code,
+preventing accidental exposure of sensitive environment values.
+        """
+    )
+    
+    parser.add_argument(
+        '--file', '-f',
+        default='.env',
+        help='Path to env file (default: .env)'
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+    
+    # List command
+    list_parser = subparsers.add_parser('list', help='List all environment keys')
+    list_parser.add_argument(
+        '--status', '-s',
+        action='store_true',
+        help='Show whether each key has a value'
+    )
+    
+    # Check command
+    check_parser = subparsers.add_parser('check', help='Check if a key exists')
+    check_parser.add_argument('key', help='The key name to check')
+    
+    # Count command
+    count_parser = subparsers.add_parser('count', help='Count variables')
+    
+    # Validate command
+    validate_parser = subparsers.add_parser('validate', help='Validate syntax')
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    filepath = Path(args.file)
+    
+    if args.command == 'list':
+        list_keys(filepath, args.status)
+    elif args.command == 'check':
+        check_key(filepath, args.key)
+    elif args.command == 'count':
+        count_variables(filepath)
+    elif args.command == 'validate':
+        validate_syntax(filepath)
+
+
+if __name__ == '__main__':
+    main()