passe1 0.2.3__py3-none-any.whl

passe1-0.2.3.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: passe1
+Version: 0.2.3
+Summary: CLI do Passe1: seu passe de IA no terminal.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+
+# CLI do Passe1 (fatia 2)
+
+Seu passe de IA no terminal: valida a chave, conversa com streaming,
+lista modelos e skills, e aponta seus harnesses para o gateway.
+
+## Instalacao
+
+```sh
+curl -fsSL https://passe.dehor.com.br/cli/install.sh | sh
+
+# depois use direto, de qualquer pasta:
+passe1 login
+passe1 chat "explique closures em 3 linhas"
+```
+
+Desenvolvedores (dentro do repo): `pip install ./cli`, ou rode sem
+instalar com `python cli/passe1.py ...`.
+
+## Uso
+
+```sh
+# entrar uma vez (a chave fica em ~/.config/passe1/key, modo 600)
+passe1 login
+passe1 login sk-passe1-...
+
+# conversar (uma pergunta, stdin ou REPL; /sair encerra, /limpar zera)
+passe1 chat "explique closures em 3 linhas"
+passe1 chat
+passe1 chat --model mimo-v2.5 "oi"
+echo "resuma isto" | passe1 chat
+
+# skills locais (SKILL.md do Claude/Codex ou de ~/.config/passe1/skills)
+passe1 skills
+passe1 chat --skill revisor "revise este texto"
+# no REPL: /skill NOME ativa, /skill mostra a ativa, /skill off desativa
+# (a ativa fica salva e vale para as proximas sessoes)
+# /model mostra o atual, /model ID troca sem sair do chat
+
+# modelos (com visao e janela) e status (passe, validade, uso)
+passe1 models
+passe1 status
+passe1 models --json   # saida maquina para scripts
+passe1 status --json
+passe1 logout
+
+# apontar um harness para o Passe1 (faz backup do config atual)
+passe1 setup claude
+passe1 setup codex
+passe1 setup verboo   # gera ~/.config/passe1/verboo.sh, importe com source
+```
+
+Opções globais: `--base-url` (aponta para outro gateway, ex. o local) e
+`--versao`. A variável `PASSE1_MODEL` troca o modelo padrão do chat.
+
+## Testes
+
+```sh
+pytest cli/tests -q   # sem rede (httpx MockTransport)
+```
+
+## Notas
+
+- A chave nunca aparece em log nem em erro: só os 4 últimos caracteres.
+- O chat usa streaming (SSE); se o gateway responder JSON simples, a CLI
+  entende mesmo assim.
+- O REPL guarda historico em ~/.config/passe1/history (setas funcionam).
+- `setup codex` pede `export PASSE1_API_KEY=$(cat ~/.config/passe1/key)` no
+  terminal; `setup verboo` gera snippet para `source` (o Verboo CLI lê
+  provedor por variável de ambiente).

passe1-0.2.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+passe1.py,sha256=Cqlh1dPdfAImz8et5MoA78s8gVYtv7TsXk6kTdE2uEQ,26475
+passe1-0.2.3.dist-info/METADATA,sha256=-oZXBwZ_Qdt0JSvsNJzK6hFJcSXRTHyCzLbT5tFfXP8,2312
+passe1-0.2.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+passe1-0.2.3.dist-info/entry_points.txt,sha256=XRLEilahXJJNdCRnfXN9zXAhENGfH4yEElBdoJubYvU,39
+passe1-0.2.3.dist-info/top_level.txt,sha256=1aqH2GHCqGly_tCRAMyE8p1A4rS7SjtmT4AUHE-JTgA,7
+passe1-0.2.3.dist-info/RECORD,,

passe1-0.2.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

passe1-0.2.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+passe1 = passe1:main

passe1-0.2.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+passe1

passe1.py

@@ -0,0 +1,778 @@
+#!/usr/bin/env python3
+"""CLI do Passe1: login, chat no terminal, setup de harnesses e status.
+
+Fatia 1: o essencial para o cliente usar o passe fora do navegador.
+Fatia 2: models, status rico (/v1/me), chat com streaming, historico
+do terminal e skills locais (SKILL.md).
+Toda conversa com o gateway usa o formato OpenAI em ``/v1``.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime
+import getpass
+import json
+import os
+import shlex
+import shutil
+import sys
+from pathlib import Path
+from typing import Callable
+
+import httpx
+
+VERSAO = "0.2.3"
+SISTEMA_PADRAO = "Você é o assistente do Passe1. Responda SEMPRE em português do Brasil, de forma clara e direta. Nunca misture idiomas na mesma resposta. Só use outro idioma se a pessoa pedir explicitamente."
+BASE_URL_PADRAO = "https://passe.dehor.com.br/v1"
+PREFIXO_CHAVE = "sk-passe1-"
+MODELO_PADRAO = "deepseek-v4-flash"
+TIMEOUT_MODELOS = 15.0
+TIMEOUT_CHAT = 60.0
+
+# Transporte injetavel: os testes trocam por httpx.MockTransport para
+# nunca tocar a rede. Em uso normal fica None (rede de verdade).
+_transporte = None
+
+
+def _hoje() -> Path:
+    """Home do usuario; PASSE1_HOME existe so para os testes isolarem."""
+    return Path(os.environ.get("PASSE1_HOME") or Path.home())
+
+
+def _dir_config() -> Path:
+    return Path(os.environ.get("PASSE1_CONFIG_DIR") or _hoje() / ".config" / "passe1")
+
+
+def _arquivo_chave() -> Path:
+    return _dir_config() / "key"
+
+
+def _base_url(args_base: str | None = None) -> str:
+    return (args_base or os.environ.get("PASSE1_BASE_URL") or BASE_URL_PADRAO).rstrip("/")
+
+
+def _cliente(base_url: str, timeout: float) -> httpx.Client:
+    return httpx.Client(base_url=base_url, timeout=timeout, transport=_transporte)
+
+
+def _ler_chave() -> str | None:
+    try:
+        texto = _arquivo_chave().read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+    return texto or None
+
+
+def _guardar_chave(chave: str) -> None:
+    destino = _arquivo_chave()
+    destino.parent.mkdir(parents=True, exist_ok=True)
+    os.chmod(destino.parent, 0o700)
+    fd = os.open(destino, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    try:
+        os.write(fd, (chave.strip() + "\n").encode("utf-8"))
+    finally:
+        os.close(fd)
+    os.chmod(destino, 0o600)
+
+
+def _codigo_erro(resp: httpx.Response) -> tuple[str, str]:
+    """Extrai (code, message) do envelope de erro do gateway, com fallback."""
+    try:
+        erro = resp.json().get("error", {})
+    except ValueError:
+        return "", f"o gateway respondeu HTTP {resp.status_code} sem JSON."
+    if not isinstance(erro, dict):
+        return "", f"o gateway respondeu HTTP {resp.status_code}."
+    return str(erro.get("code", "")), str(erro.get("message", ""))
+
+
+def _msg_401(codigo: str, detalhe: str) -> str:
+    if codigo == "pass_expired":
+        return "Passe expirado. Renove em https://passe.dehor.com.br/comprar."
+    if codigo == "api_key_revoked":
+        return "Essa chave foi revogada. Gere outra no painel e faca login de novo."
+    if codigo == "invalid_api_key":
+        return "Chave desconhecida. Confira se voce copiou a chave inteira."
+    return detalhe or "Chave rejeitada pelo gateway (HTTP 401)."
+
+
+def _sem_login() -> int:
+    print("Voce ainda nao fez login. Rode: passe1 login")
+    return 1
+
+
+def _plural(n: int, um: str, varios: str) -> str:
+    return f"{n} {um if n == 1 else varios}"
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    chave = args.chave or getpass.getpass("Cole sua chave (sk-passe1-...): ")
+    chave = chave.strip()
+    if not chave.startswith(PREFIXO_CHAVE):
+        print(f"Formato invalido: a chave precisa comecar com '{PREFIXO_CHAVE}'.")
+        return 1
+    base = _base_url(args.base_url)
+    try:
+        resp = _cliente(base, TIMEOUT_MODELOS).get(
+            "/models", headers={"Authorization": f"Bearer {chave}"}
+        )
+    except httpx.HTTPError as exc:
+        print(f"Nao consegui falar com o gateway ({exc.__class__.__name__}).")
+        print("Confira sua conexao e tente de novo.")
+        return 1
+    if resp.status_code == 200:
+        _guardar_chave(chave)
+        print("Login ok! Passe valido e chave guardada com seguranca.")
+        return 0
+    if resp.status_code == 401:
+        codigo, detalhe = _codigo_erro(resp)
+        print(_msg_401(codigo, detalhe))
+        return 1
+    codigo, detalhe = _codigo_erro(resp)
+    print(detalhe or f"O gateway respondeu HTTP {resp.status_code}.")
+    return 1
+
+
+def cmd_logout(args: argparse.Namespace) -> int:
+    _ = args
+    try:
+        _arquivo_chave().unlink()
+    except FileNotFoundError:
+        print("Voce ja estava deslogado.")
+        return 0
+    except OSError as exc:
+        print(f"Nao consegui apagar a chave guardada: {exc}.")
+        return 1
+    print("Logout ok! Chave apagada deste computador.")
+    return 0
+
+
+def cmd_models(args: argparse.Namespace) -> int:
+    chave = _ler_chave()
+    if chave is None:
+        return _sem_login()
+    base = _base_url(args.base_url)
+    try:
+        resp = _cliente(base, TIMEOUT_MODELOS).get(
+            "/models", headers={"Authorization": f"Bearer {chave}"}
+        )
+    except httpx.HTTPError as exc:
+        print(f"Nao consegui falar com o gateway ({exc.__class__.__name__}).")
+        return 1
+    if resp.status_code == 401:
+        codigo, detalhe = _codigo_erro(resp)
+        print(_msg_401(codigo, detalhe))
+        return 1
+    if resp.status_code != 200:
+        _, detalhe = _codigo_erro(resp)
+        print(detalhe or f"O gateway respondeu HTTP {resp.status_code}.")
+        return 1
+    try:
+        dados = resp.json().get("data", [])
+    except ValueError:
+        dados = []
+    if not isinstance(dados, list):
+        dados = []
+    if args.json:
+        print(json.dumps(dados, ensure_ascii=False))
+        return 0
+    print(f"Modelos disponiveis: {len(dados)}")
+    for modelo in dados:
+        if not isinstance(modelo, dict) or "id" not in modelo:
+            continue
+        partes = [f"  - {modelo['id']}"]
+        if modelo.get("vision") is True:
+            partes.append("[visao]")
+        janela = modelo.get("context_window")
+        if janela:
+            partes.append(f"(janela: {janela} tokens)")
+        print(" ".join(partes))
+    return 0
+
+
+def _linha_uso(rotulo: str, bloco) -> None:
+    try:
+        req = int(bloco["requisicoes"])
+        tok = int(bloco["tokens"])
+        err = int(bloco["erros"])
+    except (KeyError, TypeError, ValueError):
+        print(f"{rotulo}: dado indisponivel.")
+        return
+    print(
+        f"{rotulo}: {_plural(req, 'requisicao', 'requisicoes')}, "
+        f"{_plural(tok, 'token', 'tokens')}, {_plural(err, 'erro', 'erros')}."
+    )
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    chave = _ler_chave()
+    if chave is None:
+        return _sem_login()
+    base = _base_url(args.base_url)
+    try:
+        resp = _cliente(base, TIMEOUT_MODELOS).get(
+            "/me", headers={"Authorization": f"Bearer {chave}"}
+        )
+    except httpx.HTTPError as exc:
+        print(f"Nao consegui falar com o gateway ({exc.__class__.__name__}).")
+        return 1
+    if resp.status_code == 401:
+        codigo, detalhe = _codigo_erro(resp)
+        print(_msg_401(codigo, detalhe))
+        return 1
+    if resp.status_code != 200:
+        _, detalhe = _codigo_erro(resp)
+        print(detalhe or f"O gateway respondeu HTTP {resp.status_code}.")
+        return 1
+    try:
+        corpo = resp.json()
+    except ValueError:
+        corpo = None
+    if args.json:
+        if not isinstance(corpo, dict):
+            print("O gateway respondeu num formato que nao entendi.")
+            return 1
+        print(json.dumps(corpo, ensure_ascii=False))
+        return 0
+    try:
+        passe = corpo["passe"]
+        uso = corpo["uso"]
+        dia = uso["ultimas_24h"]
+        semana = uso["ultimos_7d"]
+    except (KeyError, TypeError):
+        print("O gateway respondeu num formato que nao entendi.")
+        return 1
+    print("Passe valido." if passe.get("ativo", True) else "Passe inativo.")
+    print(f"Plano: {passe.get('tier') or '-'}.")
+    dias = passe.get("dias_restantes")
+    expira = passe.get("expira_em")
+    data = ""
+    if expira:
+        try:
+            quando = datetime.datetime.fromtimestamp(float(expira))
+            data = f" (ate {quando.strftime('%d/%m/%Y')})"
+        except (ValueError, TypeError, OSError, OverflowError):
+            data = ""
+    if dias is not None:
+        try:
+            print(f"Valido por mais {_plural(int(dias), 'dia', 'dias')}{data}.")
+        except (TypeError, ValueError):
+            print("Sem data de expiracao.")
+    elif data:
+        print(f"Expira{data}.")
+    else:
+        print("Sem data de expiracao.")
+    _linha_uso("Uso nas ultimas 24h", dia)
+    _linha_uso("Uso nos ultimos 7 dias", semana)
+    return 0
+
+
+def _post_chat(base: str, chave: str, modelo: str, mensagens: list) -> httpx.Response:
+    return _cliente(base, TIMEOUT_CHAT).post(
+        "/chat/completions",
+        headers={"Authorization": f"Bearer {chave}"},
+        json={"model": modelo, "messages": mensagens, "stream": True},
+    )
+
+
+def _texto_resposta(resp: httpx.Response) -> tuple[str | None, str | None]:
+    """Retorna (texto, erro): um dos dois sempre vem preenchido."""
+    if resp.status_code == 401:
+        codigo, detalhe = _codigo_erro(resp)
+        return None, _msg_401(codigo, detalhe)
+    if resp.status_code == 429:
+        _, detalhe = _codigo_erro(resp)
+        return None, detalhe or "Limite atingido. Aguarde um pouco e tente de novo."
+    if resp.status_code != 200:
+        _, detalhe = _codigo_erro(resp)
+        return None, detalhe or f"O gateway respondeu HTTP {resp.status_code}."
+    try:
+        corpo = resp.json()
+        texto = corpo["choices"][0]["message"]["content"]
+    except (ValueError, KeyError, IndexError, TypeError):
+        return None, "O gateway respondeu num formato que nao entendi."
+    return str(texto), None
+
+
+def _imprimir_sse(texto: str, prefixo: str) -> str | None:
+    """Imprime os tokens de um corpo SSE conforme parseia.
+
+    Retorna o texto completo, ou None se o corpo nao for SSE (nesse
+    caso nada e impresso e o chamador tenta o JSON simples).
+    """
+    partes: list[str] = []
+    viu_sse = False
+    comecou = False
+    for linha in texto.splitlines():
+        linha = linha.strip()
+        if not linha.startswith("data:"):
+            continue
+        viu_sse = True
+        dado = linha[5:].strip()
+        if dado == "[DONE]":
+            break
+        try:
+            delta = json.loads(dado)["choices"][0]["delta"].get("content") or ""
+        except (ValueError, KeyError, IndexError, TypeError):
+            continue
+        if delta:
+            if not comecou:
+                print(prefixo, end="", flush=True)
+                comecou = True
+            print(delta, end="", flush=True)
+            partes.append(str(delta))
+    if not viu_sse:
+        return None
+    if comecou:
+        print()
+    else:
+        print(prefixo)
+    return "".join(partes)
+
+
+def _mostrar_resposta_chat(resp: httpx.Response, prefixo: str = "") -> tuple[str | None, str | None]:
+    """Imprime a resposta do chat e retorna (texto, erro).
+
+    Tenta o stream SSE primeiro; se o gateway mandou JSON simples,
+    cai no parse normal sem quebrar.
+    """
+    if resp.status_code != 200:
+        return _texto_resposta(resp)
+    texto = _imprimir_sse(resp.text, prefixo)
+    if texto is not None:
+        return texto, None
+    texto, erro = _texto_resposta(resp)
+    if texto is not None:
+        print(f"{prefixo}{texto}")
+    return texto, erro
+
+
+def _uma_pergunta(
+    base: str, chave: str, modelo: str, texto: str, sistema: str | None = None
+) -> int:
+    mensagens: list = []
+    if sistema:
+        mensagens.append({"role": "system", "content": sistema})
+    mensagens.append({"role": "user", "content": texto})
+    try:
+        resp = _post_chat(base, chave, modelo, mensagens)
+    except httpx.HTTPError as exc:
+        print(f"Nao consegui falar com o gateway ({exc.__class__.__name__}).")
+        return 1
+    _, erro = _mostrar_resposta_chat(resp)
+    if erro is not None:
+        print(erro)
+        return 1
+    return 0
+
+
+def _arquivo_historico() -> Path:
+    return _dir_config() / "history"
+
+
+def _configurar_historico() -> Callable[[], None] | None:
+    """Liga o historico do terminal (setas); None se readline nao existir."""
+    try:
+        import readline
+    except ImportError:
+        return None
+    try:
+        alvo = _arquivo_historico()
+        alvo.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            readline.read_history_file(str(alvo))
+        except OSError:
+            pass
+        try:
+            readline.set_history_length(500)
+        except (OSError, ValueError):
+            pass
+
+        def _salvar() -> None:
+            try:
+                readline.write_history_file(str(alvo))
+            except OSError:
+                pass
+
+        return _salvar
+    except OSError:
+        return None
+
+
+def _dirs_skills() -> list[Path]:
+    casa = _hoje()
+    return [
+        casa / ".claude" / "skills",
+        casa / ".codex" / "skills",
+        _dir_config() / "skills",
+    ]
+
+
+def _listar_skills() -> dict[str, Path]:
+    """Nome (nome do diretorio) para SKILL.md; o dir do passe1 ganha empates."""
+    achadas: dict[str, Path] = {}
+    for base in _dirs_skills():
+        try:
+            pastas = sorted(p for p in base.iterdir() if p.is_dir())
+        except OSError:
+            continue
+        for pasta in pastas:
+            alvo = pasta / "SKILL.md"
+            if alvo.is_file():
+                achadas[pasta.name] = alvo
+    return achadas
+
+
+def _ler_skill(nome: str) -> str | None:
+    alvo = _listar_skills().get(nome)
+    if alvo is None:
+        return None
+    try:
+        texto = alvo.read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+    return texto or None
+
+
+def _arquivo_skill_ativa() -> Path:
+    return _dir_config() / "skill"
+
+
+def _ler_skill_ativa() -> str | None:
+    try:
+        texto = _arquivo_skill_ativa().read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+    return texto or None
+
+
+def _guardar_skill_ativa(nome: str) -> None:
+    destino = _arquivo_skill_ativa()
+    destino.parent.mkdir(parents=True, exist_ok=True)
+    destino.write_text(nome.strip() + "\n", encoding="utf-8")
+
+
+def _limpar_skill_ativa() -> None:
+    try:
+        _arquivo_skill_ativa().unlink()
+    except OSError:
+        pass
+
+
+def cmd_skills(args: argparse.Namespace) -> int:
+    _ = args
+    achadas = _listar_skills()
+    if not achadas:
+        print("Nenhuma skill encontrada.")
+        print("Coloque um SKILL.md em ~/.config/passe1/skills/NOME/SKILL.md,")
+        print("ou reaproveite as de ~/.claude/skills e ~/.codex/skills.")
+        return 0
+    ativa = _ler_skill_ativa()
+    print(f"Skills disponiveis: {len(achadas)}")
+    for nome in sorted(achadas):
+        marca = " (ativa)" if nome == ativa else ""
+        print(f"  - {nome}{marca}")
+    return 0
+
+
+AJUDA_CHAT = (
+    "Conversa com o passe. Comandos: /sair termina, /limpar zera o contexto,"
+    " /skill NOME ativa uma skill, /model [ID] mostra ou troca o modelo."
+)
+
+
+def _msg_system(sistema: str | None) -> list:
+    if sistema:
+        return [{"role": "system", "content": sistema}]
+    return []
+
+
+def _trocar_skill_repl(
+    texto: str, nome_atual: str | None, sistema_atual: str | None, historico: list
+) -> tuple[str | None, str | None, list]:
+    """Trata o /skill no REPL; devolve (nome, sistema, historico)."""
+    partes = texto.split(None, 1)
+    if len(partes) == 1:
+        if nome_atual:
+            print(f"Skill ativa: {nome_atual}.")
+        else:
+            print("Nenhuma skill ativa. Use: /skill NOME (veja com: passe1 skills).")
+        return nome_atual, sistema_atual, historico
+    pedido = partes[1].strip()
+    if pedido == "off":
+        msg = {"role": "system", "content": SISTEMA_PADRAO}
+        if historico and historico[0].get("role") == "system":
+            historico[0] = msg
+        else:
+            historico.insert(0, msg)
+        _limpar_skill_ativa()
+        print("Skill desativada.")
+        return None, SISTEMA_PADRAO, historico
+    conteudo = _ler_skill(pedido)
+    if conteudo is None:
+        print(f"Skill '{pedido}' nao encontrada. Veja com: passe1 skills.")
+        return nome_atual, sistema_atual, historico
+    msg = {"role": "system", "content": conteudo}
+    if historico and historico[0].get("role") == "system":
+        historico[0] = msg
+    else:
+        historico.insert(0, msg)
+    _guardar_skill_ativa(pedido)
+    print(f"Skill '{pedido}' ativada.")
+    return pedido, conteudo, historico
+
+
+def _repl(
+    base: str,
+    chave: str,
+    modelo: str,
+    ler: Callable[[str], str],
+    skill: str | None = None,
+) -> int:
+    salvar_historico = _configurar_historico()
+    try:
+        print(AJUDA_CHAT)
+        nome_skill = skill or _ler_skill_ativa()
+        sistema = _ler_skill(nome_skill) if nome_skill else SISTEMA_PADRAO
+        if nome_skill is not None and sistema is None:
+            # So chega aqui pela skill salva: a do --skill o cmd_chat ja validou.
+            print(f"A skill salva '{nome_skill}' sumiu; seguindo sem skill.")
+            _limpar_skill_ativa()
+            nome_skill = None
+            sistema = SISTEMA_PADRAO
+        if skill is not None and nome_skill is not None:
+            _guardar_skill_ativa(nome_skill)
+        if nome_skill is not None:
+            print(f"Skill ativa: {nome_skill}.")
+        print(f"Modelo: {modelo}.")
+        historico: list = _msg_system(sistema)
+        while True:
+            try:
+                linha = ler("voce: ")
+            except (EOFError, KeyboardInterrupt):
+                print("\nAte logo!")
+                return 0
+            texto = linha.strip()
+            if not texto:
+                continue
+            if texto in ("/sair", "/quit", "/exit"):
+                print("Ate logo!")
+                return 0
+            if texto == "/limpar":
+                historico = _msg_system(sistema)
+                print("Contexto zerado. Pode comecar de novo.")
+                continue
+            if texto == "/skill" or texto.startswith("/skill "):
+                nome_skill, sistema, historico = _trocar_skill_repl(
+                    texto, nome_skill, sistema, historico
+                )
+                continue
+            if texto == "/model" or texto.startswith("/model "):
+                partes = texto.split(None, 1)
+                if len(partes) == 1:
+                    print(f"Modelo atual: {modelo}.")
+                else:
+                    modelo = partes[1].strip()
+                    print(f"Modelo agora: {modelo}.")
+                continue
+            historico.append({"role": "user", "content": texto})
+            try:
+                resp = _post_chat(base, chave, modelo, historico)
+            except httpx.HTTPError as exc:
+                historico.pop()
+                print(f"Nao consegui falar com o gateway ({exc.__class__.__name__}).")
+                continue
+            resposta, erro = _mostrar_resposta_chat(resp, prefixo="passe1: ")
+            if erro is not None:
+                historico.pop()
+                print(erro)
+                continue
+            historico.append({"role": "assistant", "content": resposta})
+    finally:
+        if salvar_historico is not None:
+            salvar_historico()
+
+
+def cmd_chat(args: argparse.Namespace) -> int:
+    chave = _ler_chave()
+    if chave is None:
+        return _sem_login()
+    modelo = args.model or os.environ.get("PASSE1_MODEL") or MODELO_PADRAO
+    base = _base_url(args.base_url)
+    sistema = SISTEMA_PADRAO
+    if args.skill:
+        sistema = _ler_skill(args.skill)
+        if sistema is None:
+            print(f"Skill '{args.skill}' nao encontrada. Veja com: passe1 skills.")
+            return 1
+    if args.mensagem:
+        return _uma_pergunta(base, chave, modelo, " ".join(args.mensagem), sistema)
+    if not sys.stdin.isatty():
+        texto = sys.stdin.read().strip()
+        if not texto:
+            print("Nada para enviar: passe a mensagem ou digite no terminal.")
+            return 1
+        return _uma_pergunta(base, chave, modelo, texto, sistema)
+    return _repl(base, chave, modelo, input, args.skill)
+
+
+def _backup(caminho: Path) -> Path:
+    copia = caminho.with_suffix(caminho.suffix + ".bak")
+    shutil.copy2(caminho, copia)
+    return copia
+
+
+BLOCO_CODEX = """\
+# gerenciado por "passe1 setup codex" (edite por sua conta e risco)
+model_provider = "passe1"
+
+[model_providers.passe1]
+name = "Passe1"
+base_url = "{base}"
+env_key = "PASSE1_API_KEY"
+"""
+
+
+def _setup_codex(base: str) -> int:
+    alvo = _hoje() / ".codex" / "config.toml"
+    if alvo.exists() and "model_providers.passe1" in alvo.read_text(encoding="utf-8"):
+        print("Codex ja aponta para o Passe1. Nada a fazer.")
+        return 0
+    alvo.parent.mkdir(parents=True, exist_ok=True)
+    if alvo.exists():
+        print(f"Backup do config atual em {_backup(alvo)}.")
+        with alvo.open("a", encoding="utf-8") as fh:
+            fh.write("\n" + BLOCO_CODEX.format(base=base))
+    else:
+        alvo.write_text(BLOCO_CODEX.format(base=base), encoding="utf-8")
+    print("Codex configurado para usar o Passe1.")
+    print("Falta exportar a chave no terminal:")
+    print("  export PASSE1_API_KEY=$(cat ~/.config/passe1/key)")
+    return 0
+
+
+def _setup_claude(base: str, chave: str) -> int:
+    # O Claude fala o formato Anthropic (/v1/messages), entao a base dele
+    # e a raiz do gateway, sem o sufixo /v1 do formato OpenAI.
+    base_anthropic = base[:-3] if base.endswith("/v1") else base
+    alvo = _hoje() / ".claude" / "settings.json"
+    alvo.parent.mkdir(parents=True, exist_ok=True)
+    atual: dict = {}
+    if alvo.exists():
+        print(f"Backup do config atual em {_backup(alvo)}.")
+        try:
+            atual = json.loads(alvo.read_text(encoding="utf-8"))
+        except ValueError:
+            print("O settings.json atual nao e JSON valido. Nada foi alterado,")
+            print("arrume o arquivo a mao e rode o setup de novo.")
+            return 1
+        if not isinstance(atual, dict):
+            print("O settings.json atual nao e um objeto. Nada foi alterado.")
+            return 1
+    env = atual.setdefault("env", {})
+    if not isinstance(env, dict):
+        print("O bloco 'env' do settings.json nao e um objeto. Nada foi alterado.")
+        return 1
+    env["ANTHROPIC_BASE_URL"] = base_anthropic
+    env["ANTHROPIC_AUTH_TOKEN"] = chave
+    alvo.write_text(json.dumps(atual, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print("Claude configurado para usar o Passe1.")
+    return 0
+
+
+def _setup_verboo(base: str, chave: str) -> int:
+    # O Verboo CLI aceita provedor OpenAI-compativel por variaveis de
+    # ambiente: geramos um snippet para importar no shell, com a chave
+    # guardada em arquivo 600 (nunca no .zshrc).
+    alvo = _hoje() / ".config" / "passe1" / "verboo.sh"
+    alvo.parent.mkdir(parents=True, exist_ok=True)
+    if alvo.exists():
+        print(f"Backup do snippet atual em {_backup(alvo)}.")
+    alvo.write_text(
+        "# gerado por 'passe1 setup verboo' (contem sua chave, nao compartilhe)\n"
+        "export CLAUDE_CODE_USE_OPENAI=1\n"
+        f"export OPENAI_API_KEY={shlex.quote(chave)}\n"
+        f"export OPENAI_BASE_URL={shlex.quote(base)}\n"
+        f"export OPENAI_MODEL={shlex.quote(MODELO_PADRAO)}\n",
+        encoding="utf-8",
+    )
+    os.chmod(alvo, 0o600)
+    print(f"Snippet escrito em {alvo}.")
+    print("Para usar nesta sessao:")
+    print(f"  source {alvo}")
+    print("Para valer sempre, adicione essa linha ao ~/.zshrc.")
+    return 0
+
+
+ALVOS_SETUP = {
+    "codex": _setup_codex,
+    "claude": _setup_claude,
+    "verboo": _setup_verboo,
+}
+
+
+def cmd_setup(args: argparse.Namespace) -> int:
+    chave = _ler_chave()
+    if chave is None:
+        return _sem_login()
+    base = _base_url(args.base_url)
+    alvo = (args.alvo or "").lower()
+    if alvo == "codex":
+        return _setup_codex(base)
+    if alvo == "claude":
+        return _setup_claude(base, chave)
+    if alvo == "verboo":
+        return _setup_verboo(base, chave)
+    print(f"Alvo desconhecido: '{args.alvo}'. Use: claude, codex ou verboo.")
+    return 1
+
+
+def montar_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="passe1", description="CLI do Passe1: seu passe de IA no terminal."
+    )
+    parser.add_argument("--versao", action="version", version=f"%(prog)s {VERSAO}")
+    parser.add_argument(
+        "--base-url",
+        default=None,
+        help=f"Base do gateway (padrao: {BASE_URL_PADRAO}).",
+    )
+    sub = parser.add_subparsers(dest="comando", required=True)
+
+    p_login = sub.add_parser("login", help="Validar a chave e guardar neste computador.")
+    p_login.add_argument("chave", nargs="?", help="Chave sk-passe1-... (ou digite a seguir).")
+    p_login.set_defaults(func=cmd_login)
+
+    p_chat = sub.add_parser("chat", help="Conversar no terminal.")
+    p_chat.add_argument("mensagem", nargs="*", help="Mensagem unica (sem ela, abre o chat).")
+    p_chat.add_argument("--model", default=None, help=f"Modelo (padrao: {MODELO_PADRAO}).")
+    p_chat.add_argument("--skill", default=None, help="Skill (SKILL.md) para guiar a conversa.")
+    p_chat.set_defaults(func=cmd_chat)
+
+    p_setup = sub.add_parser("setup", help="Apontar um harness para o Passe1.")
+    p_setup.add_argument("alvo", help="Harness a configurar: claude, codex ou verboo.")
+    p_setup.set_defaults(func=cmd_setup)
+
+    p_models = sub.add_parser("models", help="Listar os modelos disponiveis.")
+    p_models.add_argument("--json", action="store_true", help="Saida em JSON (para scripts).")
+    p_models.set_defaults(func=cmd_models)
+
+    p_skills = sub.add_parser("skills", help="Listar skills locais (SKILL.md).")
+    p_skills.set_defaults(func=cmd_skills)
+
+    p_status = sub.add_parser("status", help="Mostrar passe, validade e uso.")
+    p_status.add_argument("--json", action="store_true", help="Saida em JSON (para scripts).")
+    p_status.set_defaults(func=cmd_status)
+
+    p_logout = sub.add_parser("logout", help="Apagar a chave guardada.")
+    p_logout.set_defaults(func=cmd_logout)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = montar_parser().parse_args(argv)
+    return int(args.func(args))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())