ezshell 0.2.0__py3-none-any.whl

src/core/proxy_client.py

@@ -0,0 +1,166 @@
+"""Client du proxy ezShell (DEVELOPMENT.md §6, M2) : le CLI ne voit jamais de clé Groq.
+
+* Premier appel : ``POST /api/v1/device/register`` -> jeton d'appareil, stocké en 0600.
+* Ensuite : ``POST /api/v1/ask`` avec ``Authorization: Bearer <jeton>``.
+* Stdlib uniquement (urllib) : pas d'import lourd, le démarrage reste rapide.
+* Jeton invalide (401) : on se ré-enregistre UNE fois, puis on abandonne.
+* HTTPS obligatoire, sauf boucle locale (développement).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Optional, Tuple
+
+from src.core.provider import (
+    AskRequest,
+    LLMProvider,
+    ProviderError,
+    ProviderOffline,
+    QuotaExceeded,
+    UpdateRequired,
+)
+
+# À renseigner après le déploiement (ex. "https://ezshell.vercel.app"). Surchargé par EZSH_API_URL.
+DEFAULT_API_URL = "https://ezshell.vercel.app"
+TIMEOUT_S = 12.0
+_LOOPBACK = {"localhost", "127.0.0.1", "::1"}
+
+
+def api_url() -> str:
+    return (os.environ.get("EZSH_API_URL") or DEFAULT_API_URL).rstrip("/")
+
+
+def _client_version() -> str:
+    from src import __version__
+
+    return __version__
+
+
+class TokenStore:
+    """Jeton d'appareil dans ``$XDG_CONFIG_HOME/ezshell/device.json`` (0600). Trousseau : M3."""
+
+    def __init__(self, path: Optional[Path] = None):
+        if path is None:
+            base = os.environ.get("XDG_CONFIG_HOME") or str(Path.home() / ".config")
+            path = Path(base) / "ezshell" / "device.json"
+        self.path = path
+
+    def load(self, base_url: str) -> Optional[str]:
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            return None
+        # Un jeton n'est valable que pour le serveur qui l'a émis.
+        return data.get("token") if data.get("api_url") == base_url else None
+
+    def save(self, base_url: str, token: str) -> None:
+        self.path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        tmp = self.path.with_suffix(".tmp")
+        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            json.dump({"api_url": base_url, "token": token}, fh)
+        os.replace(tmp, self.path)
+
+    def clear(self) -> None:
+        try:
+            self.path.unlink()
+        except OSError:
+            pass
+
+
+class ProxyProvider(LLMProvider):
+    def __init__(self, base_url: Optional[str] = None, store: Optional[TokenStore] = None):
+        self.base_url = (base_url or api_url()).rstrip("/")
+        self.store = store or TokenStore()
+        self.last_headers: dict = {}  # en-têtes (minuscules) de la dernière réponse
+
+    # -- HTTP ---------------------------------------------------------------
+    def _check_url(self) -> None:
+        parsed = urllib.parse.urlparse(self.base_url)
+        if parsed.scheme == "https" or (parsed.scheme == "http" and parsed.hostname in _LOOPBACK):
+            return
+        raise ProviderError("URL de l'API invalide (HTTPS requis)")
+
+    def _post(self, path: str, payload: dict, token: Optional[str]) -> Tuple[int, str, dict]:
+        headers = {"content-type": "application/json", "user-agent": f"ezshell/{_client_version()}"}
+        if token:
+            headers["authorization"] = f"Bearer {token}"
+        request = urllib.request.Request(
+            self.base_url + path, data=json.dumps(payload).encode(), headers=headers, method="POST"
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=TIMEOUT_S) as resp:
+                status, text = resp.status, resp.read().decode("utf-8", errors="replace")
+                self.last_headers = {k.lower(): v for k, v in resp.headers.items()}
+        except urllib.error.HTTPError as exc:
+            status, text = exc.code, exc.read().decode("utf-8", errors="replace")
+            self.last_headers = {k.lower(): v for k, v in exc.headers.items()}
+        except (urllib.error.URLError, TimeoutError, ConnectionError, OSError) as exc:
+            raise ProviderOffline(type(exc).__name__) from exc
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError:
+            data = {}
+        return status, text, data if isinstance(data, dict) else {}
+
+    def health(self) -> bool:
+        """True si ``GET /api/v1/health`` répond 200 (aucun jeton nécessaire)."""
+        try:
+            self._check_url()
+            with urllib.request.urlopen(self.base_url + "/api/v1/health", timeout=TIMEOUT_S) as r:
+                return r.status == 200
+        except (ProviderError, urllib.error.URLError, OSError):
+            return False
+
+    # -- Jeton ----------------------------------------------------------------
+    def _register(self) -> str:
+        status, _, data = self._post("/api/v1/device/register", {}, None)
+        if status == 429:
+            raise QuotaExceeded(str(data.get("scope", "register")), data.get("reset_at"))
+        token = data.get("device_token")
+        if status != 201 or not isinstance(token, str):
+            raise ProviderError(f"enregistrement refusé ({status})")
+        self.store.save(self.base_url, token)
+        return token
+
+    # -- LLMProvider ----------------------------------------------------------
+    def ask(self, req: AskRequest) -> str:
+        self._check_url()
+        payload = {
+            "mode": req.mode,
+            "query": req.query,
+            "lang": req.lang if req.lang in ("fr", "en") else "en",
+            "client_version": _client_version(),
+            "context": {
+                "os": req.os_name,
+                "shell": req.shell,
+                "cwd": req.cwd,
+                "last_command": req.last_command,
+                "exit_code": req.exit_code,
+                "stderr_tail": req.stderr_tail,
+            },
+        }
+        token = self.store.load(self.base_url) or self._register()
+        status, text, data = self._post("/api/v1/ask", payload, token)
+        if status == 401:  # jeton révoqué ou base réinitialisée : un seul ré-enregistrement
+            self.store.clear()
+            status, text, data = self._post("/api/v1/ask", payload, self._register())
+
+        # Rappel de mise à jour : la dernière version publiée voyage dans un en-tête.
+        from src.core.updater import note_latest
+
+        note_latest(self.last_headers.get("x-ezsh-latest"))
+
+        if status == 200:
+            return text
+        if status == 426:
+            raise UpdateRequired(str(data.get("min_supported", "")), str(data.get("latest", "")))
+        if status == 429:
+            raise QuotaExceeded(str(data.get("scope", "free")), data.get("reset_at"))
+        raise ProviderError(f"{status} {data.get('error', '')}".strip())

src/core/pty_shell.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+import os
+import re
+import select
+import subprocess
+import sys
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+try:
+    import fcntl
+    import pty
+    import struct
+    import termios
+    HAS_PTY = True
+except ImportError:
+    HAS_PTY = False
+
+try:
+    import pyte
+    HAS_PYTE = True
+except ImportError:
+    HAS_PYTE = False
+
+
+@dataclass
+class CommandResult:
+    command: str
+    exit_code: int
+    stdout: str
+    stderr: str
+    clean_output: str
+
+
+# Regex fallback for stripping ANSI escapes when pyte is not installed or for quick cleanup
+ANSI_ESCAPE_RE = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+def clean_ansi_escapes(raw_text: str) -> str:
+    """Cleans ANSI escape sequences from text using pyte if available, or regex fallback."""
+    if not raw_text:
+        return ""
+
+    if HAS_PYTE:
+        try:
+            screen = pyte.HistoryScreen(120, 50, history=500)
+            stream = pyte.ByteStream(screen)
+            stream.feed(raw_text.encode("utf-8", errors="replace"))
+
+            lines = []
+            for hist_line in screen.history.top:
+                line_str = "".join(char.data for char in hist_line.values()).rstrip()
+                if line_str:
+                    lines.append(line_str)
+            for screen_line in screen.display:
+                line_str = screen_line.rstrip()
+                if line_str:
+                    lines.append(line_str)
+
+            if lines:
+                return "\n".join(lines)
+        except Exception:
+            pass
+
+    # Regex fallback
+    clean = ANSI_ESCAPE_RE.sub("", raw_text)
+    # Normalize carriage returns and newlines
+    clean = clean.replace("\r\n", "\n").replace("\r", "\n")
+    # Remove excessive blank lines
+    return "\n".join(line.rstrip() for line in clean.splitlines() if line.strip())
+
+
+class PTYExecutor:
+    """Executes commands using pseudo-terminals to preserve TTY behavior and capture output."""
+
+    @staticmethod
+    def _sync_window_size(master_fd: int):
+        """Propagate current host terminal dimensions to the PTY."""
+        if not HAS_PTY:
+            return
+        try:
+            s = struct.pack("HHHH", 0, 0, 0, 0)
+            size = fcntl.ioctl(sys.stdin.fileno(), termios.TIOCGWINSZ, s)
+            fcntl.ioctl(master_fd, termios.TIOCSWINSZ, size)
+        except Exception:
+            pass
+
+    @classmethod
+    def execute(
+        cls,
+        command: str,
+        env: Optional[Dict[str, str]] = None,
+        cwd: Optional[str] = None,
+        forward_output: bool = True,
+    ) -> CommandResult:
+        """Executes a command with stdout on a PTY and stderr captured."""
+        run_env = os.environ.copy()
+        if env:
+            run_env.update(env)
+
+        working_dir = cwd or os.getcwd()
+
+        if not HAS_PTY:
+            # Fallback for Windows or systems without pty
+            return cls._execute_subprocess(command, run_env, working_dir, forward_output)
+
+        master_fd, slave_fd = pty.openpty()
+        cls._sync_window_size(master_fd)
+
+        shell_path = run_env.get("SHELL", "/bin/bash")
+
+        try:
+            proc = subprocess.Popen(
+                [shell_path, "-c", command],
+                stdin=slave_fd,
+                stdout=slave_fd,
+                stderr=subprocess.PIPE,
+                close_fds=True,
+                env=run_env,
+                cwd=working_dir,
+                preexec_fn=os.setsid,
+            )
+        except Exception as e:
+            os.close(slave_fd)
+            os.close(master_fd)
+            return CommandResult(
+                command=command,
+                exit_code=1,
+                stdout="",
+                stderr=str(e),
+                clean_output=str(e),
+            )
+
+        # Close slave in parent process immediately
+        os.close(slave_fd)
+
+        stdout_chunks = []
+        try:
+            os.set_blocking(master_fd, False)
+        except Exception:
+            pass
+
+        while proc.poll() is None:
+            rlist, _, _ = select.select([master_fd], [], [], 0.05)
+            if master_fd in rlist:
+                try:
+                    data = os.read(master_fd, 4096)
+                    if data:
+                        stdout_chunks.append(data)
+                        if forward_output:
+                            if hasattr(sys.stdout, "buffer"):
+                                sys.stdout.buffer.write(data)
+                                sys.stdout.buffer.flush()
+                            else:
+                                sys.stdout.write(data.decode("utf-8", "replace"))
+                                sys.stdout.flush()
+                except OSError:
+                    break
+
+        # Drain any remaining bytes from master
+        while True:
+            try:
+                data = os.read(master_fd, 4096)
+                if not data:
+                    break
+                stdout_chunks.append(data)
+                if forward_output:
+                    if hasattr(sys.stdout, "buffer"):
+                        sys.stdout.buffer.write(data)
+                        sys.stdout.buffer.flush()
+                    else:
+                        sys.stdout.write(data.decode("utf-8", "replace"))
+                        sys.stdout.flush()
+            except OSError:
+                break
+
+        try:
+            os.close(master_fd)
+        except OSError:
+            pass
+
+        # Capture stderr and returncode
+        stderr_bytes = b""
+        if proc.stderr:
+            try:
+                stderr_bytes = proc.stderr.read()
+            except Exception:
+                pass
+
+        exit_code = proc.wait()
+
+        stdout_str = b"".join(stdout_chunks).decode("utf-8", errors="replace")
+        stderr_str = stderr_bytes.decode("utf-8", errors="replace")
+
+        # Composite output for error diagnosis
+        combined = f"{stdout_str}\n{stderr_str}".strip() if stderr_str else stdout_str.strip()
+        clean = clean_ansi_escapes(stderr_str if stderr_str.strip() else combined)
+
+        return CommandResult(
+            command=command,
+            exit_code=exit_code,
+            stdout=stdout_str,
+            stderr=stderr_str,
+            clean_output=clean,
+        )
+
+    @classmethod
+    def _execute_subprocess(
+        cls,
+        command: str,
+        env: Dict[str, str],
+        cwd: str,
+        forward_output: bool,
+    ) -> CommandResult:
+        """Exécution sans PTY (Windows notamment).
+
+        Sous Windows, les suggestions sont en syntaxe PowerShell : on les lance donc dans
+        PowerShell, pas dans cmd.exe. stdin est fermé pour qu'une commande interactive
+        échoue au lieu de bloquer l'interface.
+        """
+        if os.name == "nt":
+            import shutil
+
+            exe = shutil.which("pwsh") or shutil.which("powershell") or "powershell"
+            args = [exe, "-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command]
+            proc = subprocess.Popen(
+                args,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                cwd=cwd,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+            )
+        else:
+            proc = subprocess.Popen(
+                command,
+                shell=True,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                cwd=cwd,
+                text=True,
+                errors="replace",
+            )
+
+        # Read output
+        stdout_str, stderr_str = proc.communicate()
+        exit_code = proc.returncode
+
+        if forward_output:
+            if stdout_str:
+                sys.stdout.write(stdout_str)
+                sys.stdout.flush()
+            if stderr_str:
+                sys.stderr.write(stderr_str)
+                sys.stderr.flush()
+
+        combined = f"{stdout_str}\n{stderr_str}".strip() if stderr_str else stdout_str.strip()
+        clean = clean_ansi_escapes(stderr_str if stderr_str.strip() else combined)
+
+        return CommandResult(
+            command=command,
+            exit_code=exit_code,
+            stdout=stdout_str,
+            stderr=stderr_str,
+            clean_output=clean,
+        )
+

src/core/redact.py

@@ -0,0 +1,95 @@
+"""
+ezShell Secret Redaction Module
+===============================
+
+Masks sensitive patterns (API keys, tokens, passwords, private keys) before
+sending terminal context, failed commands, or stderr outputs to LLM providers.
+
+---
+
+Module de masquage des secrets d'ezShell
+========================================
+
+Masque les chaînes sensibles (clés d'API, jetons d'accès, mots de passe) avant
+l'envoi du contexte de terminal ou des sorties d'erreurs aux modèles d'IA.
+"""
+from __future__ import annotations
+
+import re
+from typing import List, Pattern, Tuple
+
+# Patterns identifying sensitive credentials. L'ordre compte : les motifs spécifiques
+# passent avant les motifs génériques (affectations), pour garder un libellé précis.
+_PEM = r"(?:RSA |EC |DSA |OPENSSH |ENCRYPTED |PGP )?PRIVATE KEY(?: BLOCK)?"
+
+SECRET_PATTERNS: List[Tuple[Pattern, str]] = [
+    # Clés privées PEM complètes, puis fin de clé tronquée (stderr coupé à 4 Ko)
+    (re.compile(rf"-----BEGIN {_PEM}-----[\s\S]*?(?:-----END {_PEM}-----|$)"), "[REDACTED_PRIVATE_KEY]"),
+    (re.compile(rf"\A[A-Za-z0-9+/=\s]{{40,}}-----END {_PEM}-----"), "[REDACTED_PRIVATE_KEY]"),
+    # Identifiants dans une URL de connexion : postgresql://user:motdepasse@hote/db
+    (
+        re.compile(r"\b([a-z][a-z0-9+.-]*://)[^\s:@/]+:[^\s@/]+@", re.IGNORECASE),
+        r"\1[REDACTED_CREDENTIALS]@",
+    ),
+    # En-têtes d'authentification (Bearer, Basic, Token)
+    (
+        re.compile(r"(?i)\b(authorization\s*[:=]\s*(?:basic|token|digest))\s+\S+"),
+        r"\1 [REDACTED_TOKEN]",
+    ),
+    (re.compile(r"(?i)\bBearer\s+[A-Za-z0-9_\-.~+/=]{16,}"), "Bearer [REDACTED_TOKEN]"),
+    # Fournisseurs connus
+    (re.compile(r"\bgsk_[A-Za-z0-9]{20,}"), "[REDACTED_GROQ_KEY]"),
+    (re.compile(r"\bsk-ant-[A-Za-z0-9_-]{20,}"), "[REDACTED_ANTHROPIC_KEY]"),
+    (re.compile(r"\bsk-(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{20,}"), "[REDACTED_OPENAI_KEY]"),
+    (re.compile(r"\b(?:github_pat_[A-Za-z0-9_]{20,}|gh[pousr]_[A-Za-z0-9]{20,})"), "[REDACTED_GITHUB_TOKEN]"),
+    (re.compile(r"\bglpat-[A-Za-z0-9_-]{20,}"), "[REDACTED_GITLAB_TOKEN]"),
+    (re.compile(r"\bxox[abprs]-[A-Za-z0-9-]{10,}"), "[REDACTED_SLACK_TOKEN]"),
+    (re.compile(r"\b(?:sk|rk|pk)_(?:live|test)_[A-Za-z0-9]{16,}"), "[REDACTED_STRIPE_KEY]"),
+    (re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b"), "[REDACTED_AWS_KEY]"),
+    (re.compile(r"\bAIza[0-9A-Za-z_-]{35}"), "[REDACTED_GOOGLE_KEY]"),
+    (re.compile(r"\bnpm_[A-Za-z0-9]{36}"), "[REDACTED_NPM_TOKEN]"),
+    (re.compile(r"\bhf_[A-Za-z0-9]{30,}"), "[REDACTED_HF_TOKEN]"),
+    (re.compile(r"\bez[du]_[A-Za-z0-9_-]{20,}"), "[REDACTED_EZSHELL_TOKEN]"),
+    (re.compile(r"\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}"), "[REDACTED_JWT]"),
+    # Mots de passe en option de ligne de commande : mysql -pSECRET, --password=x, sshpass -p x, curl -u u:p
+    (re.compile(r"(\b(?:mysql|mysqldump|mariadb)\b[^\n]*?\s-p)(?!\s)\S+"), r"\1[REDACTED]"),
+    (re.compile(r"(?i)(--(?:password|passwd|pass|token|secret|api-key)[= ])(['\"]?)[^\s'\"]+\2"), r"\1[REDACTED]"),
+    (re.compile(r"(\b(?:sshpass|docker\s+login|podman\s+login)\b[^\n]*?\s-p\s+)\S+"), r"\1[REDACTED]"),
+    (re.compile(r"(\bcurl\b[^\n]*?\s(?:-u|--user)\s+[^\s:]+:)\S+"), r"\1[REDACTED]"),
+    # Affectations génériques : password=..., AWS_SECRET_ACCESS_KEY=..., DB_PASS: "a b c"
+    (
+        re.compile(
+            r"(?i)\b([A-Za-z0-9_.-]*(?:password|passwd|passphrase|pwd|secret|token|api_?key"
+            r"|access_?key|private_?key|client_?secret|credentials?|_pass)[A-Za-z0-9_]*)"
+            r"(\s*[:=]\s*)(?:\"[^\"\n]{1,}\"|'[^'\n]{1,}'|[^\s'\",;]{4,})"
+        ),
+        r"\1\2[REDACTED]",
+    ),
+]
+
+
+def redact_secrets(text: str) -> str:
+    """Masks secrets and sensitive tokens within the given text.
+
+    Args:
+        text (str): Raw string that may contain secrets.
+
+    Returns:
+        str: Sanitized string safe to send to LLM APIs or logs.
+
+    ---
+
+    Masque les secrets et tokens sensibles dans le texte fourni.
+    """
+    if not text:
+        return ""
+
+    sanitized = text
+    for pattern, replacement in SECRET_PATTERNS:
+        sanitized = pattern.sub(replacement, sanitized)
+
+    return sanitized
+
+
+__all__ = ["SECRET_PATTERNS", "redact_secrets"]
+