bps-kit 1.0.1 → 1.0.2

package/templates/vault/claude-monitor/scripts/api_bench.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+Claude Monitor — Benchmark de Conectividade API
+
+Testa latência e conectividade com a API do Claude.
+Não faz chamadas à API (não precisa de API key).
+Apenas verifica se a rede está funcionando e se o endpoint responde.
+
+Uso:
+    python api_bench.py              # 5 testes de latência
+    python api_bench.py --samples 10 # 10 testes
+    python api_bench.py --json       # Output JSON
+"""
+
+import json
+import socket
+import ssl
+import subprocess
+import sys
+import time
+from datetime import datetime
+
+try:
+    import psutil
+except ImportError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "psutil", "--quiet"])
+    import psutil
+
+
+ENDPOINTS = [
+    {"name": "Claude API", "host": "api.anthropic.com", "port": 443},
+    {"name": "Anthropic CDN", "host": "cdn.anthropic.com", "port": 443},
+    {"name": "Google DNS", "host": "8.8.8.8", "port": 53},
+]
+
+
+def test_tcp_latency(host, port, timeout=5):
+    """Testa latência TCP para um host:port."""
+    try:
+        start = time.time()
+        sock = socket.create_connection((host, port), timeout=timeout)
+        latency = (time.time() - start) * 1000  # ms
+        sock.close()
+        return {"reachable": True, "latency_ms": round(latency, 1)}
+    except (socket.timeout, socket.error, OSError) as e:
+        return {"reachable": False, "latency_ms": None, "error": str(e)}
+
+
+def test_tls_handshake(host, port=443, timeout=5):
+    """Testa tempo do handshake TLS."""
+    try:
+        context = ssl.create_default_context()
+        start = time.time()
+        with socket.create_connection((host, port), timeout=timeout) as sock:
+            with context.wrap_socket(sock, server_hostname=host) as ssock:
+                handshake_time = (time.time() - start) * 1000
+                return {
+                    "success": True,
+                    "handshake_ms": round(handshake_time, 1),
+                    "tls_version": ssock.version(),
+                }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def test_dns(hostname):
+    """Testa resolução DNS."""
+    try:
+        start = time.time()
+        ip = socket.gethostbyname(hostname)
+        dns_time = (time.time() - start) * 1000
+        return {"resolved": True, "ip": ip, "dns_ms": round(dns_time, 1)}
+    except socket.gaierror as e:
+        return {"resolved": False, "error": str(e)}
+
+
+def check_network_interfaces():
+    """Verifica interfaces de rede ativas."""
+    stats = psutil.net_if_stats()
+    active = []
+    for name, info in stats.items():
+        if info.isup and info.speed > 0:
+            active.append({
+                "name": name,
+                "speed_mbps": info.speed,
+                "mtu": info.mtu,
+            })
+    return active
+
+
+def run_benchmark(samples=5):
+    """Roda o benchmark completo."""
+    results = {
+        "timestamp": datetime.now().isoformat(),
+        "samples": samples,
+        "endpoints": [],
+        "dns": None,
+        "tls": None,
+        "network_interfaces": check_network_interfaces(),
+    }
+
+    # DNS
+    results["dns"] = test_dns("api.anthropic.com")
+
+    # TLS handshake
+    results["tls"] = test_tls_handshake("api.anthropic.com")
+
+    # Latência por endpoint
+    for ep in ENDPOINTS:
+        latencies = []
+        for _ in range(samples):
+            result = test_tcp_latency(ep["host"], ep["port"])
+            latencies.append(result)
+            time.sleep(0.2)
+
+        valid = [r["latency_ms"] for r in latencies if r["reachable"] and r["latency_ms"]]
+
+        ep_result = {
+            "name": ep["name"],
+            "host": ep["host"],
+            "port": ep["port"],
+            "tests": latencies,
+        }
+
+        if valid:
+            ep_result["avg_ms"] = round(sum(valid) / len(valid), 1)
+            ep_result["min_ms"] = round(min(valid), 1)
+            ep_result["max_ms"] = round(max(valid), 1)
+            ep_result["success_rate"] = round(len(valid) / samples * 100, 0)
+        else:
+            ep_result["avg_ms"] = None
+            ep_result["success_rate"] = 0
+
+        results["endpoints"].append(ep_result)
+
+    # Diagnóstico
+    api_ep = results["endpoints"][0]
+    if api_ep.get("avg_ms") is None:
+        results["diagnosis"] = {
+            "status": "critical",
+            "message": "API do Claude INACESSIVEL. Verifique sua conexao de internet.",
+        }
+    elif api_ep["avg_ms"] > 500:
+        results["diagnosis"] = {
+            "status": "warning",
+            "message": (
+                f"Latencia alta para API ({api_ep['avg_ms']}ms). "
+                f"Conexao lenta pode causar atrasos no Claude Code."
+            ),
+        }
+    elif api_ep["avg_ms"] > 200:
+        results["diagnosis"] = {
+            "status": "ok",
+            "message": (
+                f"Latencia moderada ({api_ep['avg_ms']}ms). "
+                f"Dentro do aceitavel mas pode ser melhor."
+            ),
+        }
+    else:
+        results["diagnosis"] = {
+            "status": "ok",
+            "message": (
+                f"Conexao excelente ({api_ep['avg_ms']}ms). "
+                f"A rede NAO e o gargalo."
+            ),
+        }
+
+    return results
+
+
+def format_results(results):
+    """Formata resultados para exibição."""
+    lines = ["## Benchmark de Conectividade\n"]
+
+    # DNS
+    dns = results["dns"]
+    if dns.get("resolved"):
+        lines.append(f"- DNS: api.anthropic.com -> {dns['ip']} ({dns['dns_ms']}ms)")
+    else:
+        lines.append(f"- DNS: FALHOU ({dns.get('error', 'desconhecido')})")
+
+    # TLS
+    tls = results["tls"]
+    if tls.get("success"):
+        lines.append(f"- TLS: {tls['tls_version']} handshake em {tls['handshake_ms']}ms")
+    else:
+        lines.append(f"- TLS: FALHOU ({tls.get('error', 'desconhecido')})")
+
+    lines.append("")
+
+    # Endpoints
+    lines.append("### Latencia por Endpoint")
+    for ep in results["endpoints"]:
+        if ep.get("avg_ms"):
+            lines.append(
+                f"- **{ep['name']}**: {ep['avg_ms']}ms avg "
+                f"(min {ep['min_ms']}ms, max {ep['max_ms']}ms) "
+                f"[{ep['success_rate']:.0f}% sucesso]"
+            )
+        else:
+            lines.append(f"- **{ep['name']}**: INACESSIVEL")
+
+    # Interfaces
+    lines.append("\n### Interfaces de Rede")
+    for iface in results["network_interfaces"]:
+        speed = iface["speed_mbps"]
+        if speed >= 1000:
+            speed_str = f"{speed/1000:.0f} Gbps"
+        else:
+            speed_str = f"{speed} Mbps"
+        lines.append(f"- {iface['name']}: {speed_str}")
+
+    # Diagnóstico
+    lines.append(f"\n### Diagnostico")
+    diag = results["diagnosis"]
+    status_map = {"critical": "[!!!]", "warning": "[!]", "ok": "[OK]"}
+    lines.append(f"{status_map[diag['status']]} {diag['message']}")
+
+    return "\n".join(lines)
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Claude Monitor - Benchmark de Conectividade")
+    parser.add_argument("--samples", type=int, default=5, help="Numero de testes por endpoint")
+    parser.add_argument("--json", action="store_true", help="Output JSON")
+    args = parser.parse_args()
+
+    print(f"Testando conectividade ({args.samples} amostras por endpoint)...\n")
+    results = run_benchmark(args.samples)
+
+    if args.json:
+        print(json.dumps(results, indent=2, ensure_ascii=False))
+    else:
+        print(format_results(results))
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/claude-monitor/scripts/config.py

@@ -0,0 +1,69 @@
+"""
+Configurações e thresholds para o Claude Monitor.
+"""
+
+# Thresholds de alerta
+THRESHOLDS = {
+    "cpu": {
+        "ok": 60,
+        "warning": 85,
+        # acima de warning = critical
+    },
+    "ram_percent": {
+        "ok": 70,
+        "warning": 85,
+    },
+    "browsers_ram_gb": {
+        "ok": 3.0,
+        "warning": 6.0,
+    },
+    "browsers_processes": {
+        "ok": 30,
+        "warning": 60,
+    },
+    "disk_free_percent": {
+        "critical_below": 10,
+        "warning_below": 15,
+    },
+    "network_latency_ms": {
+        "ok": 200,
+        "warning": 500,
+    },
+}
+
+# Nomes de processos de browser conhecidos
+BROWSER_NAMES = ["chrome", "msedge", "firefox", "brave", "opera", "vivaldi"]
+
+# Nomes de processos do Claude Code
+CLAUDE_NAMES = ["claude"]
+
+# Endpoint para teste de latência
+API_ENDPOINT = "api.anthropic.com"
+
+# Monitor defaults
+MONITOR_DEFAULTS = {
+    "interval": 30,
+    "duration": 300,
+    "alert_cpu": 80,
+    "alert_ram": 85,
+}
+
+
+def classify(value, metric_name):
+    """Classifica um valor como 'ok', 'warning' ou 'critical'."""
+    t = THRESHOLDS.get(metric_name, {})
+
+    # Métricas onde "abaixo" é ruim (disco livre)
+    if "critical_below" in t:
+        if value < t["critical_below"]:
+            return "critical"
+        elif value < t["warning_below"]:
+            return "warning"
+        return "ok"
+
+    # Métricas onde "acima" é ruim (CPU, RAM, latência)
+    if value <= t.get("ok", 999999):
+        return "ok"
+    elif value <= t.get("warning", 999999):
+        return "warning"
+    return "critical"

package/templates/vault/claude-monitor/scripts/health_check.py

@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+"""
+Claude Monitor — Diagnóstico Rápido de Performance
+
+Analisa CPU, RAM, browsers, disco e rede em ~3 segundos.
+Identifica o gargalo principal e sugere ações corretivas.
+
+Uso:
+    python health_check.py                  # Diagnóstico completo
+    python health_check.py --browsers-detail  # Detalhe de browsers
+    python health_check.py --json            # Output JSON puro
+    python health_check.py --quick           # Só resumo (sem teste de rede)
+"""
+
+import json
+import os
+import socket
+import subprocess
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+# Garante que psutil está disponível
+try:
+    import psutil
+except ImportError:
+    print("Instalando psutil...")
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "psutil", "--quiet"])
+    import psutil
+
+# Importa config do mesmo diretório
+sys.path.insert(0, str(Path(__file__).parent))
+from config import (
+    BROWSER_NAMES, CLAUDE_NAMES, API_ENDPOINT,
+    THRESHOLDS, classify
+)
+
+
+def check_cpu():
+    """Verifica uso de CPU."""
+    cpu_percent = psutil.cpu_percent(interval=1)
+    cpu_count = psutil.cpu_count()
+    per_cpu = psutil.cpu_percent(interval=0, percpu=True)
+
+    return {
+        "percent": cpu_percent,
+        "cores": cpu_count,
+        "per_core": per_cpu,
+        "status": classify(cpu_percent, "cpu"),
+    }
+
+
+def check_ram():
+    """Verifica uso de RAM."""
+    ram = psutil.virtual_memory()
+    swap = psutil.swap_memory()
+
+    return {
+        "total_gb": round(ram.total / 1024**3, 1),
+        "used_gb": round(ram.used / 1024**3, 1),
+        "available_gb": round(ram.available / 1024**3, 1),
+        "percent": ram.percent,
+        "swap_used_gb": round(swap.used / 1024**3, 1),
+        "swap_percent": swap.percent,
+        "status": classify(ram.percent, "ram_percent"),
+    }
+
+
+def check_browsers(detail=False):
+    """Verifica processos de browser e consumo de RAM."""
+    browsers = {}
+    all_procs = []
+
+    for proc in psutil.process_iter(["pid", "name", "memory_info"]):
+        try:
+            info = proc.info
+            name_lower = info["name"].lower()
+            ram_mb = info["memory_info"].rss / 1024**2
+
+            for bname in BROWSER_NAMES:
+                if bname in name_lower:
+                    if bname not in browsers:
+                        browsers[bname] = {"count": 0, "ram_mb": 0, "pids": []}
+                    browsers[bname]["count"] += 1
+                    browsers[bname]["ram_mb"] += ram_mb
+                    if detail:
+                        browsers[bname]["pids"].append({
+                            "pid": info["pid"],
+                            "ram_mb": round(ram_mb, 0)
+                        })
+                    break
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+
+    total_ram_gb = sum(b["ram_mb"] for b in browsers.values()) / 1024
+    total_procs = sum(b["count"] for b in browsers.values())
+
+    # Formata para output
+    for bname in browsers:
+        browsers[bname]["ram_mb"] = round(browsers[bname]["ram_mb"], 0)
+
+    return {
+        "browsers": browsers,
+        "total_ram_gb": round(total_ram_gb, 1),
+        "total_processes": total_procs,
+        "ram_status": classify(total_ram_gb, "browsers_ram_gb"),
+        "process_status": classify(total_procs, "browsers_processes"),
+    }
+
+
+def check_claude_processes():
+    """Verifica processos do Claude Code."""
+    claude_procs = []
+    total_ram = 0
+
+    for proc in psutil.process_iter(["pid", "name", "memory_info", "cpu_percent"]):
+        try:
+            info = proc.info
+            name_lower = info["name"].lower()
+
+            for cname in CLAUDE_NAMES:
+                if cname in name_lower:
+                    ram_mb = info["memory_info"].rss / 1024**2
+                    claude_procs.append({
+                        "pid": info["pid"],
+                        "name": info["name"],
+                        "ram_mb": round(ram_mb, 0),
+                    })
+                    total_ram += ram_mb
+                    break
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+
+    claude_procs.sort(key=lambda x: x["ram_mb"], reverse=True)
+
+    return {
+        "count": len(claude_procs),
+        "total_ram_gb": round(total_ram / 1024, 1),
+        "processes": claude_procs[:10],  # Top 10
+    }
+
+
+def check_disk():
+    """Verifica espaço em disco."""
+    disk = psutil.disk_usage("C:/")
+    free_percent = 100 - disk.percent
+
+    return {
+        "total_gb": round(disk.total / 1024**3, 0),
+        "used_gb": round(disk.used / 1024**3, 0),
+        "free_gb": round(disk.free / 1024**3, 0),
+        "used_percent": disk.percent,
+        "free_percent": round(free_percent, 1),
+        "status": classify(free_percent, "disk_free_percent"),
+    }
+
+
+def check_network():
+    """Testa latência até a API do Claude."""
+    try:
+        start = time.time()
+        sock = socket.create_connection((API_ENDPOINT, 443), timeout=5)
+        latency_ms = round((time.time() - start) * 1000, 0)
+        sock.close()
+
+        return {
+            "latency_ms": latency_ms,
+            "endpoint": API_ENDPOINT,
+            "reachable": True,
+            "status": classify(latency_ms, "network_latency_ms"),
+        }
+    except (socket.timeout, socket.error, OSError) as e:
+        return {
+            "latency_ms": None,
+            "endpoint": API_ENDPOINT,
+            "reachable": False,
+            "status": "critical",
+            "error": str(e),
+        }
+
+
+def check_top_processes(n=10):
+    """Lista os N processos que mais consomem RAM."""
+    procs = []
+    for proc in psutil.process_iter(["pid", "name", "memory_info"]):
+        try:
+            info = proc.info
+            procs.append({
+                "name": info["name"],
+                "ram_mb": round(info["memory_info"].rss / 1024**2, 0),
+                "pid": info["pid"],
+            })
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+
+    procs.sort(key=lambda x: x["ram_mb"], reverse=True)
+    return procs[:n]
+
+
+def diagnose(results):
+    """Analisa os resultados e gera diagnóstico."""
+    issues = []
+    suggestions = []
+    bottleneck = "ok"
+    severity = "ok"
+
+    cpu = results["cpu"]
+    ram = results["ram"]
+    browsers = results["browsers"]
+    disk = results["disk"]
+    network = results.get("network", {})
+    claude = results["claude"]
+
+    # CPU
+    if cpu["status"] == "critical":
+        issues.append(f"CPU a {cpu['percent']}% (CRITICO)")
+        suggestions.append("Fechar aplicativos pesados ou abas de browser desnecessarias")
+        suggestions.append("Verificar se Windows Update ou antivirus esta rodando em background")
+        bottleneck = "cpu"
+        severity = "critical"
+    elif cpu["status"] == "warning":
+        issues.append(f"CPU a {cpu['percent']}% (elevada)")
+        suggestions.append("Considerar fechar algumas abas de browser")
+        if severity != "critical":
+            bottleneck = "cpu"
+            severity = "warning"
+
+    # RAM
+    if ram["status"] == "critical":
+        issues.append(f"RAM a {ram['percent']}% ({ram['used_gb']} de {ram['total_gb']} GB)")
+        suggestions.append("Fechar browsers ou aplicativos para liberar memoria")
+        if severity != "critical":
+            bottleneck = "ram"
+            severity = "critical"
+    elif ram["status"] == "warning":
+        issues.append(f"RAM a {ram['percent']}% (monitorar)")
+
+    # Browsers
+    if browsers["ram_status"] == "critical":
+        issues.append(f"Browsers consumindo {browsers['total_ram_gb']} GB ({browsers['total_processes']} processos)")
+        suggestions.append("Fechar abas desnecessarias nos browsers")
+        browser_detail = []
+        for bname, info in browsers["browsers"].items():
+            browser_detail.append(f"  - {bname}: {info['count']} processos, {info['ram_mb']:.0f} MB")
+        suggestions.append("Detalhamento:\n" + "\n".join(browser_detail))
+        if bottleneck == "ok":
+            bottleneck = "browsers"
+            if severity == "ok":
+                severity = "warning"
+    elif browsers["ram_status"] == "warning":
+        issues.append(f"Browsers usando {browsers['total_ram_gb']} GB (moderado)")
+
+    # Disco
+    if disk["status"] == "critical":
+        issues.append(f"Disco quase cheio: apenas {disk['free_gb']:.0f} GB livres ({disk['free_percent']}%)")
+        suggestions.append("Limpar arquivos temporarios, cache e lixeira")
+        suggestions.append("Verificar pasta Downloads e Temp por arquivos grandes")
+        if bottleneck == "ok":
+            bottleneck = "disk"
+            severity = "warning"
+    elif disk["status"] == "warning":
+        issues.append(f"Disco com {disk['free_gb']:.0f} GB livres ({disk['free_percent']}%)")
+
+    # Rede
+    if network.get("status") == "critical":
+        if not network.get("reachable"):
+            issues.append("API do Claude INACESSIVEL")
+            suggestions.append("Verificar conexao com internet")
+            suggestions.append("Verificar se VPN ou proxy esta bloqueando")
+            bottleneck = "network"
+            severity = "critical"
+        else:
+            issues.append(f"Latencia alta para API: {network['latency_ms']}ms")
+            suggestions.append("Verificar qualidade da conexao WiFi/cabo")
+            if bottleneck == "ok":
+                bottleneck = "network"
+                severity = "warning"
+
+    # Claude Code RAM
+    if claude["total_ram_gb"] > 8:
+        issues.append(f"Claude Code usando {claude['total_ram_gb']} GB ({claude['count']} processos)")
+        suggestions.append("Considerar fechar sessoes de conversa antigas no Claude Code")
+
+    # Tudo ok
+    if not issues:
+        issues.append("Sistema saudavel, sem gargalos detectados")
+        suggestions.append("A lentidao pode ser temporaria (pico na API do Claude)")
+        suggestions.append("Tente trocar de sessao novamente em alguns segundos")
+
+    # Gerar resumo em PT-BR
+    summary_lines = ["## Diagnostico de Performance\n"]
+
+    status_emoji = {"critical": "[!!!]", "warning": "[!]", "ok": "[OK]"}
+    summary_lines.append(f"**Status geral: {status_emoji[severity]} {severity.upper()}**\n")
+
+    if bottleneck != "ok":
+        summary_lines.append(f"**Gargalo principal: {bottleneck.upper()}**\n")
+
+    summary_lines.append("### Problemas detectados:")
+    for issue in issues:
+        summary_lines.append(f"- {issue}")
+
+    summary_lines.append("\n### Acoes recomendadas:")
+    for i, sug in enumerate(suggestions, 1):
+        if "\n" in sug:
+            summary_lines.append(f"{i}. {sug}")
+        else:
+            summary_lines.append(f"{i}. {sug}")
+
+    summary_lines.append(f"\n### Numeros-chave:")
+    summary_lines.append(f"- CPU: {cpu['percent']}% | RAM: {ram['percent']}% ({ram['used_gb']}/{ram['total_gb']} GB)")
+    summary_lines.append(f"- Browsers: {browsers['total_processes']} processos, {browsers['total_ram_gb']} GB")
+    summary_lines.append(f"- Claude Code: {claude['count']} processos, {claude['total_ram_gb']} GB")
+    summary_lines.append(f"- Disco C: {disk['free_gb']:.0f} GB livres ({disk['free_percent']}%)")
+    if network.get("latency_ms"):
+        summary_lines.append(f"- Latencia API: {network['latency_ms']}ms")
+
+    return {
+        "bottleneck": bottleneck,
+        "severity": severity,
+        "issues": issues,
+        "suggestions": suggestions,
+        "summary": "\n".join(summary_lines),
+    }
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Claude Monitor - Diagnostico Rapido")
+    parser.add_argument("--browsers-detail", action="store_true", help="Mostra detalhes por browser")
+    parser.add_argument("--json", action="store_true", help="Output em JSON puro")
+    parser.add_argument("--quick", action="store_true", help="Pula teste de rede")
+    args = parser.parse_args()
+
+    results = {}
+
+    # Coleta dados
+    results["timestamp"] = datetime.now().isoformat()
+    results["cpu"] = check_cpu()
+    results["ram"] = check_ram()
+    results["browsers"] = check_browsers(detail=args.browsers_detail)
+    results["claude"] = check_claude_processes()
+    results["disk"] = check_disk()
+    results["top_processes"] = check_top_processes(15)
+
+    if not args.quick:
+        results["network"] = check_network()
+
+    # Diagnóstico
+    results["diagnosis"] = diagnose(results)
+
+    if args.json:
+        print(json.dumps(results, indent=2, ensure_ascii=False))
+    else:
+        print(results["diagnosis"]["summary"])
+        print(f"\n(Para output completo em JSON, use: python health_check.py --json)")
+
+
+if __name__ == "__main__":
+    main()