yes-claudio 0.1.0__tar.gz

yes_claudio-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: yes-claudio
+Version: 0.1.0
+Summary: Auto-approve Claude Code permission prompts with a denylist and daily limits
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pystray>=0.19
+Requires-Dist: Pillow>=10.0
+
+# yes-claudio
+
+Auto-approve Claude Code permission prompts with a denylist and daily limits.
+
+## Install
+
+```bash
+pip install yes-claudio
+```
+
+## Usage
+
+```bash
+# Activate the hook in Claude Code
+yes-claudio
+
+# Activate a paid license (unlimited approvals)
+yes-claudio activate YOUR-SERIAL-KEY
+
+# Run the hook manually (called by Claude Code automatically)
+yes-claudio hook
+```
+
+## How it works
+
+- **Free tier:** 10 auto-approvals per day
+- **Paid tier ($2):** unlimited approvals — get your key at [gumroad.com](https://bravoevert.gumroad.com/l/yes-claudio)
+
+Installs a `PreToolUse` hook in `~/.claude/settings.json`. Dangerous commands (`rm -rf`, force push, `DROP TABLE`, `sudo`, etc.) are always sent back to you for review.
+
+## License
+
+MIT

yes_claudio-0.1.0/README.md

@@ -0,0 +1,33 @@
+# yes-claudio
+
+Auto-approve Claude Code permission prompts with a denylist and daily limits.
+
+## Install
+
+```bash
+pip install yes-claudio
+```
+
+## Usage
+
+```bash
+# Activate the hook in Claude Code
+yes-claudio
+
+# Activate a paid license (unlimited approvals)
+yes-claudio activate YOUR-SERIAL-KEY
+
+# Run the hook manually (called by Claude Code automatically)
+yes-claudio hook
+```
+
+## How it works
+
+- **Free tier:** 10 auto-approvals per day
+- **Paid tier ($2):** unlimited approvals — get your key at [gumroad.com](https://bravoevert.gumroad.com/l/yes-claudio)
+
+Installs a `PreToolUse` hook in `~/.claude/settings.json`. Dangerous commands (`rm -rf`, force push, `DROP TABLE`, `sudo`, etc.) are always sent back to you for review.
+
+## License
+
+MIT

yes_claudio-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yes-claudio"
+version = "0.1.0"
+description = "Auto-approve Claude Code permission prompts with a denylist and daily limits"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+dependencies = [
+    "pystray>=0.19",
+    "Pillow>=10.0",
+]
+
+[project.scripts]
+yes-claudio = "autoconfirm.main:main"
+
+[tool.setuptools]
+packages = ["autoconfirm", "autoconfirm.gui"]
+
+[tool.setuptools.package-dir]
+"autoconfirm" = "src"
+"autoconfirm.gui" = "src/gui"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

yes_claudio-0.1.0/setup.cfg

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

yes_claudio-0.1.0/src/denylist.py

@@ -0,0 +1,80 @@
+import logging
+import re
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# (padrão, motivo legível)
+BASH_PATTERNS: list[tuple[str, str]] = [
+    (r"\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r)\b", "remoção recursiva (rm -rf)"),
+    (r"\brm\s+.*--force\b.*-r\b", "remoção recursiva com --force"),
+    (r"\bgit\s+push\s+.*(-f\b|--force\b)", "git push --force"),
+    (r"\bgit\s+reset\s+--hard\b", "git reset --hard"),
+    (r"\bgit\s+clean\s+.*-f\b", "git clean -f"),
+    (r"\bDROP\s+(TABLE|DATABASE|SCHEMA|INDEX)\b", "DROP SQL destrutivo"),
+    (r"\bTRUNCATE\b", "TRUNCATE SQL"),
+    (r"\bsudo\b", "escalada de privilégio (sudo)"),
+    (r"\bdd\s+if=", "escrita direta em disco (dd)"),
+    (r"\bmkfs\b", "formatação de disco (mkfs)"),
+    (r"\bfdisk\b", "particionamento de disco (fdisk)"),
+    (r">\s*/dev/(sd[a-z]|hd[a-z]|nvme)", "redirecionamento para dispositivo de bloco"),
+    (r"\bshutdown\b", "desligamento do sistema"),
+    (r"\breboot\b", "reinicialização do sistema"),
+    (r"\bhalt\b", "parada do sistema"),
+    (r"\bpoweroff\b", "desligamento do sistema"),
+    (r":\(\)\s*\{", "fork bomb"),
+    (r"(curl|wget)\b.*\|\s*(ba|da|z|fi)?sh\b", "download e execução direta de script"),
+    (r"\bshred\b", "wipe seguro de arquivo (shred)"),
+    (r"\bchmod\s+.*777\s+(/|/home|/etc)", "chmod 777 em diretório de sistema"),
+]
+
+FILE_PATH_PATTERNS: list[tuple[str, str]] = [
+    (r"^/etc/", "diretório de configuração do sistema (/etc)"),
+    (r"^/usr/", "diretório de sistema (/usr)"),
+    (r"^/bin/", "diretório de binários do sistema (/bin)"),
+    (r"^/sbin/", "diretório de binários de sistema (/sbin)"),
+    (r"^/boot/", "diretório de boot (/boot)"),
+    (r"^/sys/", "sistema de arquivos virtual (/sys)"),
+    (r"^/proc/", "sistema de arquivos virtual (/proc)"),
+    (r"^/dev/", "diretório de dispositivos (/dev)"),
+]
+
+_bash_compiled = [(re.compile(p, re.IGNORECASE), reason) for p, reason in BASH_PATTERNS]
+_path_compiled = [(re.compile(p), reason) for p, reason in FILE_PATH_PATTERNS]
+
+
+def _load_custom_compiled() -> list[tuple[re.Pattern, str]]:
+    from .storage import load_custom_denylist
+    result = []
+    for raw in load_custom_denylist():
+        try:
+            result.append((re.compile(raw, re.IGNORECASE), f"padrão customizado: {raw}"))
+        except re.error:
+            logger.warning("Padrão inválido ignorado: %r", raw)
+    return result
+
+
+def check_bash(command: str) -> Optional[str]:
+    for pattern, reason in _bash_compiled:
+        if pattern.search(command):
+            return reason
+    for pattern, reason in _load_custom_compiled():
+        if pattern.search(command):
+            return reason
+    return None
+
+
+def check_file_path(path: str) -> Optional[str]:
+    for pattern, reason in _path_compiled:
+        if pattern.match(path):
+            return reason
+    return None
+
+
+def is_dangerous(tool_name: str, tool_input: dict) -> Optional[str]:
+    """Retorna motivo legível se perigoso, None se seguro."""
+    if tool_name == "Bash":
+        return check_bash(tool_input.get("command", ""))
+    if tool_name in ("Edit", "Write"):
+        return check_file_path(tool_input.get("file_path", ""))
+    return None

yes_claudio-0.1.0/src/gui/hook_config.py

@@ -0,0 +1,83 @@
+import json
+import shutil
+import sys
+from pathlib import Path
+
+CLAUDE_SETTINGS = Path.home() / ".claude" / "settings.json"
+HOOK_TAG = "autoconfirm-hook"
+
+
+def _binary_command() -> str:
+    if getattr(sys, "frozen", False):
+        return f'"{sys.executable}" hook'
+    entry = shutil.which("yes-claudio")
+    if entry:
+        return f'"{entry}" hook'
+    return f'"{sys.executable}" -m src.main hook'
+
+
+def _load() -> dict:
+    if not CLAUDE_SETTINGS.exists():
+        return {}
+    try:
+        return json.loads(CLAUDE_SETTINGS.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _save(data: dict) -> None:
+    CLAUDE_SETTINGS.parent.mkdir(parents=True, exist_ok=True)
+    CLAUDE_SETTINGS.write_text(
+        json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8"
+    )
+
+
+def _our_entries(pre_tool: list) -> list:
+    return [
+        e for e in pre_tool
+        if any(h.get("_tag") == HOOK_TAG for h in e.get("hooks", []))
+    ]
+
+
+def _other_entries(pre_tool: list) -> list:
+    return [
+        e for e in pre_tool
+        if not any(h.get("_tag") == HOOK_TAG for h in e.get("hooks", []))
+    ]
+
+
+def is_hook_active() -> bool:
+    pre_tool = _load().get("hooks", {}).get("PreToolUse", [])
+    return bool(_our_entries(pre_tool))
+
+
+def enable_hook() -> None:
+    data = _load()
+    pre_tool = data.setdefault("hooks", {}).get("PreToolUse", [])
+    updated = _other_entries(pre_tool) + [{
+        "matcher": "",
+        "hooks": [{
+            "type": "command",
+            "command": _binary_command(),
+            "timeout": 10,
+            "_tag": HOOK_TAG,
+        }]
+    }]
+    data["hooks"]["PreToolUse"] = updated
+    _save(data)
+
+
+def disable_hook() -> None:
+    if not CLAUDE_SETTINGS.exists():
+        return
+    data = _load()
+    pre_tool = data.get("hooks", {}).get("PreToolUse", [])
+    remaining = _other_entries(pre_tool)
+
+    if remaining:
+        data["hooks"]["PreToolUse"] = remaining
+    else:
+        data.get("hooks", {}).pop("PreToolUse", None)
+        if not data.get("hooks"):
+            data.pop("hooks", None)
+    _save(data)

yes_claudio-0.1.0/src/gui/panel.py

@@ -0,0 +1,195 @@
+import re
+import tkinter as tk
+from tkinter import messagebox, ttk
+
+from ..denylist import BASH_PATTERNS
+from ..license import activate, check_local
+from ..storage import CONFIG_DIR, FREE_LIMIT, LICENSE_FILE, get_today_count, load_custom_denylist, save_custom_denylist
+from .hook_config import disable_hook, enable_hook, is_hook_active
+
+
+class Panel:
+    def __init__(self):
+        self.root = tk.Tk()
+        self.root.title("Auto-Confirm — Claude Code")
+        self.root.geometry("380x280")
+        self.root.resizable(False, False)
+        self._build()
+        self._refresh()
+
+    def _build(self):
+        pad = {"padx": 12, "pady": 6}
+
+        # --- Status ---
+        status = ttk.LabelFrame(self.root, text="Status")
+        status.pack(fill="x", **pad)
+
+        self.lbl_count = ttk.Label(status, text="")
+        self.lbl_count.pack(anchor="w", padx=8, pady=2)
+
+        self.lbl_license = ttk.Label(status, text="")
+        self.lbl_license.pack(anchor="w", padx=8, pady=2)
+
+        self.hook_var = tk.BooleanVar()
+        ttk.Checkbutton(
+            status,
+            text="Hook ativo (aprovação automática ligada)",
+            variable=self.hook_var,
+            command=self._toggle_hook,
+        ).pack(anchor="w", padx=8, pady=4)
+
+        # --- Licença ---
+        lic = ttk.LabelFrame(self.root, text="Ativar Licença")
+        lic.pack(fill="x", **pad)
+
+        self.serial_var = tk.StringVar()
+        row = ttk.Frame(lic)
+        row.pack(fill="x", padx=8, pady=6)
+        ttk.Entry(row, textvariable=self.serial_var, width=28).pack(side="left")
+        ttk.Button(row, text="Ativar", command=self._activate).pack(side="left", padx=6)
+
+        btn_row = ttk.Frame(self.root)
+        btn_row.pack(pady=4)
+        ttk.Button(btn_row, text="Atualizar", command=self._refresh).pack(side="left", padx=4)
+        ttk.Button(btn_row, text="Editar Denylist", command=self._open_denylist).pack(side="left", padx=4)
+
+    def _refresh(self):
+        count = get_today_count()
+        paid = check_local(LICENSE_FILE)
+
+        if paid:
+            self.lbl_count.config(text=f"Aprovações hoje: {count}  (ilimitado)")
+            self.lbl_license.config(text="Licença: Paga ✓", foreground="green")
+        else:
+            remaining = max(0, FREE_LIMIT - count)
+            self.lbl_count.config(
+                text=f"Aprovações hoje: {count}/{FREE_LIMIT}  ({remaining} restantes)"
+            )
+            self.lbl_license.config(text="Licença: Gratuita", foreground="#888888")
+
+        self.hook_var.set(is_hook_active())
+
+    def _toggle_hook(self):
+        if self.hook_var.get():
+            enable_hook()
+        else:
+            disable_hook()
+
+    def _activate(self):
+        key = self.serial_var.get().strip()
+        if not key:
+            messagebox.showwarning("Serial vazia", "Cole a serial recebida por email.")
+            return
+        ok, msg = activate(key, CONFIG_DIR)
+        if ok:
+            messagebox.showinfo("Licença ativada", msg)
+            self.serial_var.set("")
+        else:
+            messagebox.showerror("Erro na ativação", msg)
+        self._refresh()
+
+    def _open_denylist(self):
+        DenylistEditor(self.root)
+
+    def run(self):
+        self.root.mainloop()
+
+
+class DenylistEditor(tk.Toplevel):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.title("Editar Denylist")
+        self.geometry("540x420")
+        self.resizable(False, False)
+        self.grab_set()
+        self._build()
+        self._populate()
+
+    def _build(self):
+        pad = {"padx": 10, "pady": 6}
+
+        # --- Lista de padrões ---
+        frame_list = ttk.LabelFrame(self, text="Padrões ativos")
+        frame_list.pack(fill="both", expand=True, **pad)
+
+        scroll = ttk.Scrollbar(frame_list)
+        scroll.pack(side="right", fill="y")
+        self.listbox = tk.Listbox(frame_list, yscrollcommand=scroll.set, width=60, height=12, selectmode="single")
+        self.listbox.pack(side="left", fill="both", expand=True, padx=(4, 0), pady=4)
+        scroll.config(command=self.listbox.yview)
+
+        ttk.Button(frame_list, text="Remover selecionado", command=self._remove).pack(pady=(0, 4))
+
+        # --- Adicionar padrão ---
+        frame_add = ttk.LabelFrame(self, text="Adicionar padrão (regex)")
+        frame_add.pack(fill="x", **pad)
+
+        self.new_pattern_var = tk.StringVar()
+        row = ttk.Frame(frame_add)
+        row.pack(fill="x", padx=8, pady=6)
+        ttk.Entry(row, textvariable=self.new_pattern_var, width=38).pack(side="left")
+        ttk.Button(row, text="Adicionar", command=self._add).pack(side="left", padx=6)
+
+        # --- Testar padrão ---
+        frame_test = ttk.LabelFrame(self, text="Testar contra comando")
+        frame_test.pack(fill="x", **pad)
+
+        self.test_cmd_var = tk.StringVar()
+        row2 = ttk.Frame(frame_test)
+        row2.pack(fill="x", padx=8, pady=6)
+        ttk.Entry(row2, textvariable=self.test_cmd_var, width=38).pack(side="left")
+        ttk.Button(row2, text="Testar", command=self._test).pack(side="left", padx=6)
+
+        # --- Salvar ---
+        ttk.Button(self, text="Salvar", command=self._save).pack(pady=6)
+
+    def _populate(self):
+        self.listbox.delete(0, tk.END)
+        for _, reason in BASH_PATTERNS:
+            self.listbox.insert(tk.END, f"[builtin] {reason}")
+        self._custom = load_custom_denylist()
+        for p in self._custom:
+            self.listbox.insert(tk.END, p)
+        self._builtin_count = len(BASH_PATTERNS)
+
+    def _add(self):
+        raw = self.new_pattern_var.get().strip()
+        if not raw:
+            return
+        try:
+            re.compile(raw)
+        except re.error as e:
+            messagebox.showerror("Regex inválido", f"Padrão não compila:\n{e}", parent=self)
+            return
+        self._custom.append(raw)
+        self.listbox.insert(tk.END, raw)
+        self.new_pattern_var.set("")
+
+    def _remove(self):
+        idx = self.listbox.curselection()
+        if not idx:
+            return
+        i = idx[0]
+        if i < self._builtin_count:
+            messagebox.showwarning("Padrão builtin", "Padrões builtin não podem ser removidos.", parent=self)
+            return
+        custom_idx = i - self._builtin_count
+        self._custom.pop(custom_idx)
+        self.listbox.delete(i)
+
+    def _test(self):
+        cmd = self.test_cmd_var.get()
+        if not cmd:
+            return
+        # testa todos os padrões (builtin + custom)
+        from ..denylist import check_bash
+        reason = check_bash(cmd)
+        if reason:
+            messagebox.showinfo("Bloqueado", f"Comando seria bloqueado:\n{reason}", parent=self)
+        else:
+            messagebox.showinfo("Permitido", "Comando seria aprovado (nenhum padrão bateu).", parent=self)
+
+    def _save(self):
+        save_custom_denylist(self._custom)
+        messagebox.showinfo("Salvo", f"{len(self._custom)} padrão(ões) custom salvos.", parent=self)
+        self.destroy()

yes_claudio-0.1.0/src/gui/tray.py

@@ -0,0 +1,51 @@
+import subprocess
+import sys
+
+import pystray
+from PIL import Image, ImageDraw
+
+from .hook_config import disable_hook, enable_hook, is_hook_active
+
+
+def _icon_image(active: bool) -> Image.Image:
+    size = 64
+    img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    fill = (34, 197, 94) if active else (107, 114, 128)
+    draw.ellipse([4, 4, size - 4, size - 4], fill=fill)
+    return img
+
+
+def _panel_cmd() -> list[str]:
+    if getattr(sys, "frozen", False):
+        return [sys.executable, "panel"]
+    return [sys.executable, "-m", "src.main", "panel"]
+
+
+def run_tray() -> None:
+    def open_panel(icon, item):
+        subprocess.Popen(_panel_cmd())
+
+    def toggle(icon, item):
+        if is_hook_active():
+            disable_hook()
+        else:
+            enable_hook()
+        icon.icon = _icon_image(is_hook_active())
+
+    def quit_app(icon, item):
+        icon.stop()
+
+    menu = pystray.Menu(
+        pystray.MenuItem("Abrir Painel", open_panel, default=True),
+        pystray.MenuItem("Ativar / Desativar Hook", toggle),
+        pystray.Menu.SEPARATOR,
+        pystray.MenuItem("Sair", quit_app),
+    )
+
+    pystray.Icon(
+        name="autoconfirm",
+        icon=_icon_image(is_hook_active()),
+        title="Auto-Confirm",
+        menu=menu,
+    ).run()

yes_claudio-0.1.0/src/handler.py

@@ -0,0 +1,54 @@
+import json
+import sys
+from typing import Any
+
+from .denylist import is_dangerous
+from .storage import FREE_LIMIT, get_today_count, increment, is_paid
+
+
+def _respond(decision: str, reason: str = "") -> None:
+    out: dict[str, Any] = {
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": decision,
+        }
+    }
+    if reason:
+        out["hookSpecificOutput"]["permissionDecisionReason"] = reason
+    print(json.dumps(out), flush=True)
+
+
+def run() -> int:
+    try:
+        payload = json.loads(sys.stdin.read())
+        tool_name: str = payload.get("tool_name", "")
+        tool_input: dict = payload.get("tool_input", {})
+
+        # 1. Denylist — devolve ao humano sem contar
+        danger = is_dangerous(tool_name, tool_input)
+        if danger:
+            _respond("ask", f"Bloqueado pela denylist: {danger}")
+            return 0
+
+        # 2. Licença paga → ilimitado
+        if is_paid():
+            increment(tool_name, tool_input)
+            _respond("allow")
+            return 0
+
+        # 3. Free: cap de 10/dia
+        if get_today_count() >= FREE_LIMIT:
+            _respond(
+                "ask",
+                f"Limite diário de {FREE_LIMIT} aprovações atingido. "
+                "Ative a licença para aprovar sem limite.",
+            )
+            return 0
+
+        increment(tool_name, tool_input)
+        _respond("allow")
+        return 0
+
+    except Exception as exc:  # noqa: BLE001 — fail-safe: qualquer erro → ask
+        _respond("ask", f"Erro interno no handler: {exc}")
+        return 0