| """openTARS 4.5 Endurance: onde o programa está rodando. |
| |
| Parte pura (sem rede, sem tela): diz se é WSL, se há interface gráfica, e |
| traduz caminhos do Windows. Quem usa é o tars.py (modo sem interface, abrir |
| links pelo Windows, achar o Ollama do Windows a partir do WSL). |
| |
| Três situações que importam: |
| * área de trabalho Linux (X11 ou Wayland): tudo como sempre; |
| * WSL com WSLg (o Windows 11 mostra janelas Linux): há DISPLAY, a janela |
| abre, mas não existe uma "área de trabalho" Linux pra controlar; |
| * sem interface (servidor, SSH, WSL sem WSLg, contêiner): só conversa no |
| terminal, comandos, arquivos e a IA; nada de mouse, teclado nem tela. |
| """ |
|
|
| import os |
| import re |
| from pathlib import Path |
|
|
| import tars_plataforma as plataforma |
|
|
|
|
| def _ler(caminho): |
| try: |
| return Path(caminho).read_text(encoding="utf-8", errors="replace") |
| except Exception: |
| return "" |
|
|
|
|
| def versao_wsl(env=None, ler=None): |
| """1 ou 2 dentro do WSL; None fora dele.""" |
| env = os.environ if env is None else env |
| ler = ler or _ler |
| release = ler("/proc/sys/kernel/osrelease").lower() |
| versao = ler("/proc/version").lower() |
| dentro = bool(env.get("WSL_DISTRO_NAME") or env.get("WSL_INTEROP")) or "microsoft" in release or "microsoft" in versao |
| if not dentro: |
| return None |
| return 2 if "wsl2" in release or "wsl2" in versao or env.get("WSL_INTEROP") else 1 |
|
|
|
|
| def e_wsl(env=None, ler=None): |
| return versao_wsl(env, ler) is not None |
|
|
|
|
| def tem_tela(env=None): |
| env = os.environ if env is None else env |
| |
| return plataforma.sistema() != "linux" or bool(env.get("DISPLAY") or env.get("WAYLAND_DISPLAY")) |
|
|
|
|
| def forcado_sem_interface(env=None): |
| """TARS_SEM_INTERFACE=1: trata a máquina como sem tela mesmo com DISPLAY |
| (servidor com X remoto, quem quer só o terminal).""" |
| env = os.environ if env is None else env |
| return str(env.get("TARS_SEM_INTERFACE", "")).lower() in ("1", "on", "sim", "yes", "true") |
|
|
|
|
| def detectar(env=None, ler=None): |
| """{'wsl': 1|2|None, 'wslg': bool, 'tela': bool, 'ssh': bool, 'sem_interface': bool, |
| 'tipo': 'desktop'|'wslg'|'sem_tela', 'rotulo': str (em inglês)}""" |
| env = os.environ if env is None else env |
| wsl = versao_wsl(env, ler) |
| sem = forcado_sem_interface(env) or not tem_tela(env) |
| ssh = bool(env.get("SSH_CONNECTION") or env.get("SSH_TTY")) |
| wslg = bool(wsl) and not sem and (bool(env.get("WAYLAND_DISPLAY")) or bool(env.get("DISPLAY"))) |
| tipo = "sem_tela" if sem else ("wslg" if wslg else "desktop") |
| if sem: |
| rotulo = f"WSL{wsl} (no graphical session)" if wsl else ("SSH (no graphical session)" if ssh else "no graphical session") |
| elif wslg: |
| rotulo = f"WSL{wsl} with WSLg" |
| else: |
| rotulo = "desktop" |
| return {"wsl": wsl, "wslg": wslg, "tela": not sem, "ssh": ssh, "sem_interface": sem, "tipo": tipo, "rotulo": rotulo} |
|
|
|
|
| |
| |
| |
|
|
| _UNIDADE = re.compile(r"^([A-Za-z]):[\\/]*(.*)$", re.DOTALL) |
| _REDE_WSL = re.compile(r"^[\\/]{2}(?:wsl\$|wsl\.localhost)[\\/]+[^\\/]+[\\/]*(.*)$", re.IGNORECASE | re.DOTALL) |
|
|
|
|
| def parece_caminho_windows(texto): |
| t = (texto or "").strip() |
| return bool(_UNIDADE.match(t) or _REDE_WSL.match(t)) |
|
|
|
|
| def caminho_do_windows(texto): |
| """'C:\\Users\\ana\\a b.txt' -> '/mnt/c/Users/ana/a b.txt'; |
| '\\\\wsl$\\Ubuntu\\home\\ana\\x' -> '/home/ana/x'. Texto que não parece |
| caminho do Windows volta como veio.""" |
| t = (texto or "").strip() |
| achado = _REDE_WSL.match(t) |
| if achado: |
| return "/" + achado.group(1).replace("\\", "/").strip("/") |
| achado = _UNIDADE.match(t) |
| if achado: |
| resto = achado.group(2).replace("\\", "/").strip("/") |
| base = f"/mnt/{achado.group(1).lower()}" |
| return f"{base}/{resto}" if resto else base |
| return t |
|
|
|
|
| |
| |
| |
|
|
| def gateway_padrao(texto_route): |
| """IP do gateway padrão a partir do conteúdo de /proc/net/route.""" |
| for linha in (texto_route or "").splitlines()[1:]: |
| campos = linha.split() |
| if len(campos) >= 3 and campos[1] == "00000000": |
| try: |
| n = int(campos[2], 16) |
| except ValueError: |
| continue |
| if n: |
| return ".".join(str((n >> (8 * i)) & 255) for i in range(4)) |
| return None |
|
|
|
|
| def servidor_dns(texto_resolv): |
| for linha in (texto_resolv or "").splitlines(): |
| partes = linha.split() |
| if len(partes) >= 2 and partes[0] == "nameserver" and re.fullmatch(r"\d+\.\d+\.\d+\.\d+", partes[1]): |
| return partes[1] |
| return None |
|
|
|
|
| def candidatos_ollama_wsl(porta=11434, ler=None): |
| """Endereços onde o Ollama do Windows pode estar, vistos do WSL2 (além |
| do 127.0.0.1 de sempre): o IP do Windows aparece como servidor DNS e |
| como gateway. Sem repetição, na ordem em que vale tentar.""" |
| ler = ler or _ler |
| achados = [] |
| for ip in (servidor_dns(ler("/etc/resolv.conf")), gateway_padrao(ler("/proc/net/route"))): |
| if ip and ip not in achados and not ip.startswith("127."): |
| achados.append(ip) |
| return [f"http://{ip}:{porta}" for ip in achados] |
|
|
|
|
| def abridor_de_links_do_windows(existe=None): |
| """Como abrir um link no navegador do Windows a partir do WSL sem |
| interface: ['wslview'] (pacote wslu) ou ['explorer.exe']. None se não houver.""" |
| import shutil |
| existe = existe or shutil.which |
| for comando in (["wslview"], ["explorer.exe"]): |
| if existe(comando[0]): |
| return comando |
| return None |
|
|
