shellmate-cli 3.0.0__py3-none-any.whl

shellmate/rules/catastrophic.yaml

@@ -0,0 +1,96 @@
+# Catastrophic commands requiring confirmation (NO API dependency)
+- id: "rm_rf_root"
+  category: "catastrophic"
+  instant: true
+  severity: "CRITICAL"
+  program: "rm"
+  flags: ["-rf", "-fr"]
+  arguments: ["^/$", "^/\\*$", "^~/$"]
+  message: "⚠️  DANGER: Deletes entire filesystem"
+  confirm_required: true
+
+- id: "git_push_force"
+  category: "catastrophic"
+  instant: true
+  severity: "CRITICAL"
+  program: "git"
+  subcommand: "push"
+  flags: ["--force", "-f"]
+  message: "⚠️  Rewrites remote history"
+  confirm_required: true
+
+- id: "dd_to_device"
+  category: "catastrophic"
+  instant: true
+  severity: "CRITICAL"
+  program: "dd"
+  arguments: ["of=/dev/sd", "of=/dev/nvme", "of=/dev/vd"]
+  message: "⚠️  Writes raw data to disk"
+  confirm_required: true
+
+- id: "drop_database"
+  category: "catastrophic"
+  instant: true
+  severity: "CRITICAL"
+  program: "mysql"
+  arguments: ["DROP\\s+DATABASE"]
+  message: "⚠️  Deletes entire database"
+  confirm_required: true
+
+- id: "chmod_777_recursive"
+  category: "catastrophic"
+  instant: true
+  severity: "HIGH"
+  program: "chmod"
+  flags: ["-R"]
+  arguments: ["777"]
+  message: "⚠️  Removes all security protections"
+  confirm_required: true
+
+- id: "git_reset_hard"
+  category: "catastrophic"
+  instant: true
+  severity: "HIGH"
+  program: "git"
+  subcommand: "reset"
+  flags: ["--hard"]
+  message: "⚠️  Discards all uncommitted changes"
+  confirm_required: true
+
+- id: "docker_rm_all"
+  category: "catastrophic"
+  instant: true
+  severity: "HIGH"
+  program: "docker"
+  subcommand: "rm"
+  flags: ["-f"]
+  arguments: ["\\$\\(docker ps", "\\$\\(docker container"]
+  message: "⚠️  Deletes all containers"
+  confirm_required: true
+
+- id: "kill_all_processes"
+  category: "catastrophic"
+  instant: true
+  severity: "HIGH"
+  program: "kill"
+  arguments: ["-9 -1", "-9 1"]
+  message: "⚠️  Kills all user processes"
+  confirm_required: true
+
+- id: "mkfs_on_device"
+  category: "catastrophic"
+  instant: true
+  severity: "CRITICAL"
+  program: "mkfs"
+  arguments: ["/dev/sd", "/dev/nvme", "/dev/vd"]
+  message: "⚠️  Formats disk device"
+  confirm_required: true
+
+- id: "curl_pipe_bash"
+  category: "catastrophic"
+  instant: true
+  severity: "HIGH"
+  program: "curl"
+  arguments: ["\\|\\s*bash", "\\|\\s*sh"]
+  message: "⚠️  Executes remote script"
+  confirm_required: true

shellmate/rules/catastrophic_matcher.py

@@ -0,0 +1,167 @@
+import os
+import re
+import yaml
+from shellmate.parser.command_parser import parse_command
+
+CATASTROPHIC_FILE = os.path.join(os.path.dirname(__file__), "catastrophic.yaml")
+
+# In-memory cache — YAML reload every keystroke blew past the <5–10ms budget (~11ms P99).
+# Do NOT call getmtime on every match: on WSL /mnt/* mounts that alone can be 5–8ms.
+_CACHED_RULES = None
+
+
+def load_catastrophic_rules(force_reload: bool = False):
+    """Load instant-match catastrophic rules (no API dependency).
+
+    Rules are cached in-process. Pass force_reload=True after editing YAML.
+    """
+    global _CACHED_RULES
+
+    if not force_reload and _CACHED_RULES is not None:
+        return _CACHED_RULES
+
+    if not os.path.exists(CATASTROPHIC_FILE):
+        _CACHED_RULES = []
+        return []
+
+    with open(CATASTROPHIC_FILE, "r", encoding="utf-8") as f:
+        rules = yaml.safe_load(f) or []
+    _CACHED_RULES = [r for r in rules if r.get("instant")]
+    return _CACHED_RULES
+
+
+def match_catastrophic(command_string):
+    """
+    Instant match against catastrophic commands.
+    Returns: {"matched": bool, "rule": dict, "message": str}
+    """
+    rules = load_catastrophic_rules()
+    parsed = parse_command(command_string)
+    
+    for rule in rules:
+        # Handle both single commands and pipelines
+        if isinstance(parsed, dict) and parsed.get("pipeline"):
+            # For pipelines, check all segments
+            for segment_type, segment_data in parsed.get("segments", []):
+                if segment_type == "command" and _match_rule(segment_data, command_string, rule):
+                    return {
+                        "matched": True,
+                        "rule_id": rule["id"],
+                        "category": rule["category"],
+                        "severity": rule["severity"],
+                        "message": rule["message"],
+                        "confirm_required": rule.get("confirm_required", True),
+                    }
+        elif _match_rule(parsed, command_string, rule):
+            return {
+                "matched": True,
+                "rule_id": rule["id"],
+                "category": rule["category"],
+                "severity": rule["severity"],
+                "message": rule["message"],
+                "confirm_required": rule.get("confirm_required", True),
+            }
+    
+    return {"matched": False}
+
+def _match_rule(parsed, command_string, rule):
+    """Match single rule using existing engine logic"""
+    if isinstance(parsed, dict):
+        cmd_program = parsed.get("program")
+    else:
+        import shlex
+        try:
+            tokens = shlex.split(str(command_string))
+            cmd_program = tokens[0] if tokens else None
+        except ValueError:
+            return False
+    
+    # Check program match (handle variants like mkfs.ext4 matching mkfs)
+    rule_program = rule.get("program")
+    if cmd_program != rule_program:
+        # Try prefix match for programs like mkfs.ext4
+        if not (cmd_program and cmd_program.startswith(rule_program + ".")):
+            return False
+    
+    # Check subcommand (for git push, git reset, docker rm, etc.)
+    expected_subcommand = rule.get("subcommand")
+    if expected_subcommand:
+        if isinstance(parsed, dict):
+            actual_subcommand = parsed.get("subcommand")
+            if actual_subcommand != expected_subcommand:
+                return False
+        else:
+            import shlex
+            try:
+                tokens = shlex.split(command_string)
+                if len(tokens) < 2 or tokens[1] != expected_subcommand:
+                    return False
+            except ValueError:
+                return False
+    
+    # Check flags
+    expected_flags = rule.get("flags", [])
+    if expected_flags:
+        cmd_flags = parsed.get("flags", []) if isinstance(parsed, dict) else []
+        flag_values = {f["flag"] for f in cmd_flags} if cmd_flags else set()
+        
+        # Check if any expected flag is present (handle combined flags like -rf)
+        found_flag = False
+        for expected_flag in expected_flags:
+            # Direct match
+            if expected_flag in flag_values or expected_flag in command_string:
+                found_flag = True
+                break
+            # Check for combined flags (e.g., "-rf" contains both "-r" and "-f")
+            if expected_flag.startswith("-") and not expected_flag.startswith("--"):
+                # Single dash flags can be combined
+                expected_letters = set(expected_flag.lstrip("-"))
+                for actual_flag in flag_values:
+                    if actual_flag.startswith("-") and not actual_flag.startswith("--"):
+                        actual_letters = set(actual_flag.lstrip("-"))
+                        if expected_letters.issubset(actual_letters):
+                            found_flag = True
+                            break
+                if found_flag:
+                    break
+        
+        if not found_flag:
+            return False
+    
+    # Check arguments
+    expected_args = rule.get("arguments", [])
+    if expected_args:
+        cmd_args = parsed.get("arguments", []) if isinstance(parsed, dict) else []
+        arg_str = " ".join(cmd_args) if cmd_args else ""
+        
+        # Try matching against arguments first, then full command (for pipes)
+        found_arg = False
+        for pat in expected_args:
+            # Try matching individual arguments for patterns like ^/$
+            if arg_str and re.search(pat, arg_str):
+                found_arg = True
+                break
+            # Also check each argument individually
+            for arg in cmd_args:
+                if re.search(pat, arg):
+                    found_arg = True
+                    break
+            if found_arg:
+                break
+            # Fallback: check full command string for patterns like pipes
+            if re.search(pat, command_string):
+                found_arg = True
+                break
+        
+        if not found_arg:
+            return False
+    
+    return True
+
+
+if __name__ == "__main__":
+    import json
+    import sys
+
+    cmd = sys.argv[1] if len(sys.argv) > 1 else ""
+    print(json.dumps(match_catastrophic(cmd)))

shellmate/rules/definitions/file_deletion.yaml

@@ -0,0 +1,54 @@
+- id: "rm_force_recursive_root"
+  category: "file_deletion"
+  severity: "CRITICAL"
+  description: "Force recursive delete on root directory"
+  program: "rm"
+  flags:
+    - "-rf"
+    - "-fr"
+  arguments:
+    - "^/$"
+  message: "This will recursively delete all files on the system without confirmation."
+  confidence: 0.98
+
+- id: "rm_force_recursive"
+  category: "file_deletion"
+  severity: "HIGH"
+  description: "Force recursive delete without confirmation"
+  program: "rm"
+  flags:
+    - "-rf"
+    - "-fr"
+  message: "Recursively deletes files without confirmation. Consider using -ri for interactive deletion."
+  confidence: 0.85
+
+- id: "rm_force"
+  category: "file_deletion"
+  severity: "HIGH"
+  description: "Force delete without confirmation"
+  program: "rm"
+  flags:
+    - "-f"
+  message: "Force deletes files without confirmation. Use -i for interactive mode."
+  confidence: 0.80
+
+- id: "shred_command"
+  category: "file_deletion"
+  severity: "HIGH"
+  description: "Secure file deletion with shred"
+  program: "shred"
+  message: "Permanently deletes files making recovery difficult."
+  confidence: 0.90
+
+- id: "rm_rf_var_log"
+  category: "file_deletion"
+  severity: "CRITICAL"
+  description: "Delete critical system log directory"
+  program: "rm"
+  flags:
+    - "-rf"
+    - "-fr"
+  arguments:
+    - "^/var/log"
+  message: "Deleting /var/log will remove all system logs."
+  confidence: 0.95

shellmate/rules/definitions/filesystem.yaml

@@ -0,0 +1,43 @@
+- id: "mkfs_command"
+  category: "filesystem"
+  severity: "CRITICAL"
+  description: "Create a filesystem (format a partition)"
+  program: "mkfs"
+  message: "This will format the target device, destroying all data on it."
+  confidence: 0.97
+
+- id: "fdisk_write"
+  category: "filesystem"
+  severity: "CRITICAL"
+  description: "Write partition table changes"
+  program: "fdisk"
+  flags:
+    - "-w"
+  message: "Writing partition table changes can destroy data on disk."
+  confidence: 0.95
+
+- id: "dd_command"
+  category: "filesystem"
+  severity: "CRITICAL"
+  description: "Raw disk copy/wipe operation"
+  program: "dd"
+  message: "dd can overwrite disks and partitions directly, potentially destroying data."
+  confidence: 0.95
+
+- id: "parted_mklabel"
+  category: "filesystem"
+  severity: "CRITICAL"
+  description: "Create partition table label"
+  program: "parted"
+  arguments:
+    - "mklabel"
+  message: "Creating a new partition table will destroy existing partitions."
+  confidence: 0.96
+
+- id: "mkswap"
+  category: "filesystem"
+  severity: "HIGH"
+  description: "Set up swap area on device"
+  program: "mkswap"
+  message: "Setting up a swap area on the wrong device can destroy data."
+  confidence: 0.85

shellmate/rules/definitions/network_execution.yaml

@@ -0,0 +1,46 @@
+- id: "curl_pipe_bash"
+  category: "network_execution"
+  severity: "HIGH"
+  description: "Pipe curl output to bash (remote code execution)"
+  pipeline: true
+  pattern:
+    - program: "curl"
+    - operator: "pipe"
+    - program: "bash"
+  message: "Piping a remote script directly to bash is a security risk. Review the script before executing."
+  confidence: 0.92
+
+- id: "wget_pipe_sh"
+  category: "network_execution"
+  severity: "HIGH"
+  description: "Pipe wget output to sh (remote code execution)"
+  pipeline: true
+  pattern:
+    - program: "wget"
+    - operator: "pipe"
+    - program: "sh"
+  message: "Piping a remote script directly to sh is a security risk. Review the script before executing."
+  confidence: 0.92
+
+- id: "curl_pipe_sh"
+  category: "network_execution"
+  severity: "HIGH"
+  description: "Pipe curl output to sh (remote code execution)"
+  pipeline: true
+  pattern:
+    - program: "curl"
+    - operator: "pipe"
+    - program: "sh"
+  message: "Piping a remote script directly to sh is a security risk. Review the script before executing."
+  confidence: 0.92
+
+- id: "curl_insecure"
+  category: "network_execution"
+  severity: "MEDIUM"
+  description: "Skip SSL certificate verification"
+  program: "curl"
+  flags:
+    - "-k"
+    - "--insecure"
+  message: "Skipping SSL verification exposes the connection to MITM attacks."
+  confidence: 0.80

shellmate/rules/definitions/permissions.yaml

@@ -0,0 +1,54 @@
+- id: "chmod_recursive_777_root"
+  category: "permissions"
+  severity: "CRITICAL"
+  description: "Recursively set world-writable permissions on root"
+  program: "chmod"
+  flags:
+    - "-R"
+  arguments:
+    - "777"
+    - "^/$"
+  message: "Makes all files world-writable. This is a severe security risk."
+  confidence: 0.98
+
+- id: "chmod_777"
+  category: "permissions"
+  severity: "HIGH"
+  description: "Set world-writable permissions"
+  program: "chmod"
+  arguments:
+    - "777"
+  message: "Makes files world-writable. Consider using more restrictive permissions."
+  confidence: 0.90
+
+- id: "chmod_recursive_777"
+  category: "permissions"
+  severity: "HIGH"
+  description: "Recursively set world-writable permissions"
+  program: "chmod"
+  flags:
+    - "-R"
+  arguments:
+    - "777"
+  message: "Recursively makes files world-writable. This is a security risk."
+  confidence: 0.95
+
+- id: "chown_recursive"
+  category: "permissions"
+  severity: "MEDIUM"
+  description: "Recursively change ownership"
+  program: "chown"
+  flags:
+    - "-R"
+  message: "Recursively changing ownership can affect many files."
+  confidence: 0.75
+
+- id: "chmod_000"
+  category: "permissions"
+  severity: "HIGH"
+  description: "Remove all permissions from files"
+  program: "chmod"
+  arguments:
+    - "000"
+  message: "Removes all permissions, making files inaccessible."
+  confidence: 0.90

shellmate/rules/definitions/process_control.yaml

@@ -0,0 +1,37 @@
+- id: "kill_9"
+  category: "process_control"
+  severity: "HIGH"
+  description: "Force kill a process (SIGKILL)"
+  program: "kill"
+  flags:
+    - "-9"
+    - "-KILL"
+    - "--signal"
+  message: "Force kills a process without allowing cleanup. Use -15 (SIGTERM) for graceful shutdown."
+  confidence: 0.85
+
+- id: "killall_command"
+  category: "process_control"
+  severity: "MEDIUM"
+  description: "Kill all processes by name"
+  program: "killall"
+  message: "Kills all processes with the given name. Use with caution."
+  confidence: 0.80
+
+- id: "pkill_command"
+  category: "process_control"
+  severity: "MEDIUM"
+  description: "Kill processes by name pattern"
+  program: "pkill"
+  message: "Kills processes matching a pattern. May affect unintended processes."
+  confidence: 0.75
+
+- id: "xargs_kill"
+  category: "process_control"
+  severity: "HIGH"
+  description: "Pipe to xargs kill"
+  program: "xargs"
+  arguments:
+    - "kill"
+  message: "This pattern can mass-kill processes. Verify the process list first."
+  confidence: 0.80

shellmate/rules/definitions/system_destruction.yaml

@@ -0,0 +1,67 @@
+- id: "dd_of_dev_sda"
+  category: "system_destruction"
+  severity: "CRITICAL"
+  description: "Write directly to disk device"
+  program: "dd"
+  arguments:
+    - "of=/?dev/sd"
+    - "of=/?dev/nvme"
+    - "of=/?dev/vd"
+  message: "Writing directly to a disk device will destroy the partition table and all data."
+  confidence: 0.99
+
+- id: "fork_bomb"
+  category: "system_destruction"
+  severity: "CRITICAL"
+  description: "Fork bomb pattern detected"
+  program: ":(){"
+  message: "This is a fork bomb that will crash your system by exhausting all processes."
+  confidence: 0.99
+
+- id: "reboot_command"
+  category: "system_destruction"
+  severity: "HIGH"
+  description: "System reboot"
+  program: "reboot"
+  message: "This will reboot the system. Ensure all work is saved."
+  confidence: 0.90
+
+- id: "shutdown_now"
+  category: "system_destruction"
+  severity: "HIGH"
+  description: "Immediate system shutdown"
+  program: "shutdown"
+  flags:
+    - "-h"
+    - "-r"
+    - "-P"
+  arguments:
+    - "^now$"
+  message: "This will shut down the system immediately."
+  confidence: 0.90
+
+- id: "poweroff"
+  category: "system_destruction"
+  severity: "HIGH"
+  description: "Power off system"
+  program: "poweroff"
+  message: "This will power off the system."
+  confidence: 0.90
+
+- id: "halt_command"
+  category: "system_destruction"
+  severity: "HIGH"
+  description: "Halt the system"
+  program: "halt"
+  message: "This will halt the system."
+  confidence: 0.85
+
+- id: "passwd_root"
+  category: "system_destruction"
+  severity: "HIGH"
+  description: "Change root password"
+  program: "passwd"
+  arguments:
+    - "^root$"
+  message: "Changing the root password can lock you out of the system if not done carefully."
+  confidence: 0.80