Terminal rápido e multiplataforma para SSH, túneis, SFTP, RDP, Docker e Kubernetes. Inspirado no Termius, no MobaXterm e no Lens.
Software livre sob a GPL-3.0. Downloads na página de releases — veja a política de assinatura de código e a privacidade.
npm install
npm run tauri dev- Windows (
.msie-setup.exe):npm run tauri buildno Windows; os instaladores ficam emsrc-tauri/target/release/bundle. - Linux (
.deb,.rpm,.AppImage):docker/linux-build/build.sh(no WSL ou num Linux com Docker) compila o commit atual num Ubuntu 22.04 e põe os pacotes emrelease/linux. Rodam em distros com glibc 2.35+ (Ubuntu 22.04, Debian 12, Fedora 36 em diante). - GitHub:
.github/workflows/release.ymlcompila os dois numa tagv*(git tag v0.1.0 && git push origin v0.1.0) e cria uma release em rascunho com os instaladores.
A versão fica em src-tauri/tauri.conf.json, src-tauri/Cargo.toml e package.json.
No GitHub, o executável e os instaladores do Windows são assinados pela SignPath quando o projeto
está configurado lá (variáveis SIGNPATH_* do repositório; ver o comentário no workflow e as
configurações em .signpath/). Builds locais não são assinados: o Windows SmartScreen avisa na
primeira execução ("Mais informações" → "Executar assim mesmo").
Atualização automática: o app procura versões novas (ao abrir e a cada 6 h, ou em
Configurações → Atualizações) no latest.json da última release publicada, avisa com um toast e,
com o ok do usuário, baixa, instala e reinicia. Cada tipo de instalação se atualiza pelo próprio
formato (NSIS, MSI, .deb e .rpm pedindo a senha de administrador, AppImage). Os arquivos são
conferidos com a chave pública em tauri.conf.json (plugins.updater.pubkey); o workflow assina
com a privada, no segredo TAURI_SIGNING_PRIVATE_KEY do repositório, e só gera o latest.json
quando ele existe. Como o app olha a última release publicada, a atualização chega a todos
quando o rascunho é publicado.
Só a interface, no navegador (npm run dev e abrir http://localhost:1420): fora do Tauri, o
src/dev-mock.ts simula o backend com dados de exemplo. ?view=credentials|tunnels|settings|session,
?dialog=host|newhost|credential|tunnel|palette|generate, ?panel=host|sftp (com view=session) e
?theme=light abrem direto uma tela; ?update=1 simula uma versão nova. Na página Kubernetes
(view=kubernetes), ?kind=crd:sealedsecrets.bitnami.com escolhe o tipo e ?seal=new|edit|convert
abre o diálogo do Sealed Secrets. ?argo=list|<app> abre o Argo CD (&tab=resources|history,
&sync=1 abre o diálogo de sync).
O mock fica fora do build de produção.
- Hosts: pastas e todos os hosts em cards (clique conecta;
⋯ou botão direito: editar, duplicar, túnel, excluir). Com uma sessão aberta, os hosts viram uma lista ao lado (botão na barra da esquerda). - Credenciais: usuário + senha, chave SSH (arquivo ou guardada no cofre) ou agente, usadas por
vários hosts — SSH e RDP. Trocou a senha? Muda num lugar só. "Gerar chave SSH" cria um par ed25519
e mostra a chave pública para o
authorized_keys. - Túneis e Configurações (tema claro/escuro/sistema, cor de destaque, fonte do terminal,
importar do
~/.ssh/config, importar/exportar hosts em JSON — sem senhas nem chaves). Ctrl+K: conectar a qualquer host, abrir terminal ou ir para uma página.- Feita com shadcn-svelte (bits-ui + Tailwind 4); componentes em
src/lib/components/ui. Os estilos dos painéis (terminal, RDP, SFTP) ficam emsrc/panes.css.
| Atalho | Ação |
|---|---|
Ctrl+K |
Conectar a um host / buscar |
Ctrl+Shift+T |
Nova aba |
Ctrl+Shift+D / Ctrl+Shift+E |
Dividir à direita / abaixo |
Ctrl+Shift+W |
Fechar painel |
Ctrl+Shift+B |
Broadcast na aba atual |
Ctrl+Shift+F |
Painel de arquivos (SFTP) |
Ctrl+Shift+M |
Painel do host (métricas e containers) |
Alt+setas |
Navegar entre painéis |
Ctrl+Tab / Ctrl+Shift+Tab |
Próxima / anterior aba |
Ctrl+C (com seleção) / Ctrl+V |
Copiar / colar |
| Botão direito | Copia a seleção ou cola |
- Hosts e credenciais ficam em
vault.bin(pasta de dados do app), criptografado com XChaCha20-Poly1305. A chave fica no cofre do sistema (Gerenciador de Credenciais do Windows, Keychain no macOS, Secret Service no Linux). - Verificação de host usa o
~/.ssh/known_hostsdo OpenSSH: o que já é confiado nosshcontinua confiado no Nexo, e vice-versa. - Autenticação por senha (com fallback para keyboard-interactive), chave ou agente SSH. Sem
caminho de chave configurado, tenta
~/.ssh/id_ed25519,id_ecdsa,id_rsae depois o agente. - Agente: no Windows, o serviço OpenSSH Authentication Agent (
\\.\pipe\openssh-ssh-agent) e depois o Pageant; no Linux/macOS,SSH_AUTH_SOCK. - Jump host (ProxyJump): qualquer host salvo pode ser o salto de outro, inclusive em cadeia. Vale para terminal, SFTP e túneis. Senhas/fingerprints de cada salto são pedidas separadamente.
- Importar do
~/.ssh/config(botão de download no cabeçalho de Hosts): entendeHostcom curingas,HostName,User,Port,IdentityFile,ProxyJumpeInclude. - Sessão SSH encerrada:
Enterreconecta. - Prompt de senha no terminal (
sudo,su,Password:,Senha:): aparece uma lista dos hosts com senha salva (o host da sessão primeiro).Enterpreenche,Escignora, digitar segue normal. A senha vai do cofre direto para a sessão, sem passar pelo frontend.
- Painel lateral (
Ctrl+Shift+Fou botão SFTP) com os arquivos do painel SSH focado. Usa um canal extra na mesma conexão do terminal: sem novo login. - Duplo clique abre pasta / baixa arquivo (para a pasta Downloads; "Baixar para…" no menu).
- Enviar: botão de upload ou arrastar arquivos e pastas do Explorer para o painel.
- Botão direito: renomear (
F2), excluir (Del, recursivo), copiar caminho, "abrir no terminal" (cd). - Transferências com progresso e cancelamento; pastas são copiadas recursivamente.
- Painel lateral (
Ctrl+Shift+Mou o botão de atividade na barra da esquerda) com o servidor do painel SSH focado: CPU (com gráfico dos últimos 2 minutos e carga média), memória e swap, rede (taxa de download/upload) e uso de cada disco. Atualiza a cada 2 segundos enquanto está aberto. - Usa um canal extra na conexão do terminal e só lê
/procedf: nada é instalado no servidor. Funciona em servidores Linux (inclusive Alpine/BusyBox). - Também em terminais locais Linux e WSL: o painel mostra a própria máquina (ou a distro WSL,
via
wsl.exe -d <distro>) e o Docker dela. PowerShell e cmd ficam de fora. O "usar sudo" de um terminal local fica nas configurações do Nexo e a senha é pedida quando preciso (só em memória). - Aba Containers: os containers Docker do servidor, agrupados por projeto do Compose, com status, CPU e memória (a cada 5 s). Iniciar, parar, reiniciar, pausar, remover (só parados). Logs (acompanhando ao vivo) e shell no container abrem numa aba nova, na mesma conexão SSH — sem novo login.
- Usuário fora do grupo
docker: o painel oferece usar sudo (com confirmação; também no editor do host, "Docker com sudo"). A senha do sudo é a salva do host/credencial, passada direto do cofre para osudo -S; sem senha salva, o Nexo pergunta (e pode salvar). Se a salva for recusada (sudo com outra senha), a digitada fica só na memória — a do login não é trocada. Logs e shell rodamsudo docker …no terminal, com a sugestão de senha salva no prompt do sudo.
- Página Kubernetes na barra da esquerda, no estilo do Lens. Lê o kubeconfig padrão
(
KUBECONFIGou~/.kube/config, em%USERPROFILE%\.kube\configno Windows) ou outro arquivo escolhido no menu…(por exemplo\\wsl.localhost\Ubuntu\home\<usuário>\.kube\config). Pluginsexecde autenticação (aws,gke-gcloud-auth-plugin,kubelogin…) funcionam como nokubectl. - Escolha de contexto e namespace (ou todos), e os recursos mais usados: pods, deployments,
statefulsets, daemonsets, jobs, services, ingresses, configmaps, secrets, PVCs, nodes, eventos…
As colunas são as do
kubectl get, vindas do próprio cluster (botão de colunas =-o wide); estados com cor, filtro e ordenação. A lista visível atualiza a cada 5 s. - Clicar num item mostra o YAML (sem
managedFields). Em Secrets os valores ficam escondidos até clicar em revelar. - Editar o YAML (lápis no painel;
Ctrl+Ssalva): o objeto é substituído com oresourceVersionque foi aberto, então se alguém mudou o objeto nesse meio-tempo o cluster recusa e nada é sobrescrito. Nome e namespace não mudam; Secrets só com os valores revelados. - Com metrics-server no cluster, pods e nodes ganham as colunas de CPU e memória.
- Custom resources: os CRDs do cluster aparecem na barra, agrupados por API group, com as colunas definidas no CRD, YAML, edição e exclusão.
- Menu de cada item (botão
…ou clique direito): logs (acompanhando ao vivo, ou do container anterior depois de um restart) e shell de pods numa aba de terminal, port-forward, escalar e reiniciar workloads (como okubectl rollout restart) e excluir (com confirmação; namespaces, nodes e volumes ficam de fora). Pods com vários containers mostram cada um no menu do painel de YAML. - Port-forward para pods, services e deployments/statefulsets: escolhe a porta (as declaradas
aparecem como sugestão) e a local; fica em
127.0.0.1enquanto o Nexo estiver aberto, listado na barra da página (clique abre no navegador). Se o pod for trocado (rollout), o próximo acesso escolhe outro pelo seletor. - Sealed Secrets (bitnami-labs/sealed-secrets): com o controller no cluster, aparecem junto dos
Secrets. O botão + Sealed Secret cria um novo; Editar valores abre um existente com os
valores atuais (lidos do Secret que o controller criou), e Selar… num Secret comum converte
ele num SealedSecret, que passa a gerenciar o Secret. A selagem é feita pelo próprio Nexo com o
certificado do controller do contexto (o mesmo formato do
kubeseal, que não precisa estar instalado). Valores não alterados continuam com o mesmo texto selado, então o diff no git mostra só o que mudou. Escopo (strict,namespace-wide,cluster-wide) e tipo do Secret são escolhidos no diálogo. Valores podem vir de arquivos (binários vão em base64). O resultado é aplicado no cluster ou copiado/salvo como YAML para o repositório. - Argo CD: com o Argo CD no cluster, Applications aparece no topo da barra. Os apps são
lidos direto da API do Kubernetes (os CRDs do
argoproj.io), com as permissões do kubeconfig: não precisa do argocd-server, de login nem de token, como noargocd --core. A lista mostra os apps em cartões ou tabela, agrupados por projeto, com filtros de projeto, saúde e sync (com a contagem de cada um) e busca por nome, repositório, namespace ou label. Num app: saúde, sync (commit com link para o GitHub/GitLab/Bitbucket) e a última operação; a árvore de recursos junta o que está no git com o que o cluster criou (ReplicaSets, Jobs e Pods), com a saúde e o erro do último sync em cada um, e clicar num recurso abre o YAML com as ações de sempre (logs, shell, port-forward…). Também a lista de recursos e o histórico. Ações: sincronizar (o app ou só alguns recursos, com prune, simulação, server-side apply, replace e forçar), atualizar (com ou sem cache), voltar para uma versão do histórico, encerrar a operação e ligar/desligar o auto-sync, prune e self-heal. Apps que aplicam em outro cluster mostram só o que o Argo gerencia. O diff entre o git e o cluster ainda não existe (depende do repo-server do Argo).
- Seção Túneis na sidebar:
+cria, ▶/■ inicia e para, lápis edita. - Local (
-L): porta desta máquina → destino visto pelo servidor (ex.:localhost:5432→ banco da VM). - Remoto (
-R): porta no servidor → destino visto desta máquina. - SOCKS (
-D): proxy SOCKS5 local; o tráfego sai pela rede do servidor. - Cada túnel tem conexão SSH própria (não depende de terminal aberto) e reconecta sozinho se cair. "Iniciar automaticamente" sobe o túnel quando o Nexo abre.
- O servidor precisa de
AllowTcpForwarding yes(padrão do OpenSSH).
- No formulário de host, escolha RDP: a área de trabalho abre numa aba (ou painel), como um terminal.
- Login automático: com usuário e senha salvos no cofre, o servidor pula a tela de login (o xRDP também). Sem senha salva, o Nexo pergunta ao conectar (com opção de salvar).
- Gateway SSH: qualquer host SSH salvo pode ser o túnel até o servidor RDP (jump hosts em cadeia valem) — útil para xRDP que só escuta na rede interna.
- Certificado TLS: confiança no primeiro uso, como o
known_hosts; o Nexo avisa se ele mudar. - Resolução acompanha o painel (ao vivo no xRDP 0.10+/Windows; reconecta em servidores antigos) ou fixa. "Alta resolução" usa os pixels físicos da tela.
- Teclado por scancode: o layout é o do servidor (o Nexo informa o layout do Windows, ex.: ABNT2).
- Captura de atalhos (Windows, ligada por padrão): com o painel RDP focado, todas as teclas vão para o servidor — Win, Alt+Tab, Alt+F4, Ctrl+Esc e os atalhos do próprio Nexo. Ctrl+Alt+Home solta o teclado; clicar na tela remota captura de novo. Ctrl+Alt+Del e Win+L o Windows não deixa capturar: use o botão da barra de conexão.
- Área de transferência (texto, nos dois sentidos): copiou no servidor, já está no Windows; copiou no Windows, fica disponível no servidor quando o painel ganha o foco.
- GFX (pipeline gráfico, ligado por padrão): H.264 e RemoteFX progressivo, bem mais fluido que bitmaps. O H.264 é decodificado pelo OpenH264 compilado junto (instalar o NASM antes do build deixa a decodificação mais rápida). No xRDP, o H.264 depende de o servidor ter sido compilado com ele; sem isso, ele usa o RemoteFX progressivo.
- Barra de conexão: leve o mouse à borda de cima do painel — Ctrl+Alt+Del, tela cheia, desconectar.
- Painel encerrado:
Enterou o botão reconecta.
src-tauri/— backend Rust (Tauri 2). Cada sessão implementa o traitSession(session.rs): PTY local (local.rs) e SSH (ssh.rs). A saída vai ao frontend porChannelem binário; o input passa por uma fila por sessão que preserva a ordem das teclas.flow.rspausa a leitura quando o frontend fica mais de 2 MB atrás (ack do xterm.js).sftp.rsabre o subsistema SFTP sob demanda na conexão de cadaSshSession.hostinfo.rslê as métricas do servidor (um script em/procnum canal extra da sessão);docker.rslista os containers e executa as ações pelo CLIdockerdo servidor.tunnel.rsmantém os túneis (conexão própria viassh::establish, reconexão, SOCKS5).rdp.rsé a sessão RDP (IronRDP): decodifica a tela e manda só as regiões alteradas, com ack por mensagem desenhada; input chega porrdp_input(scancodes, mouse, roda). Testes contra servidores reais:cargo test -- --ignored live(ver comentários nos testes; o de RDP usa um container xRDP na porta 13389).src/— frontend Svelte 5 + xterm.js (renderer WebGL).lib/state.svelte.tsguarda abas, árvore de painéis e broadcast;lib/term.tsencapsula cada terminal;lib/sftp.svelte.tsguarda o navegador de arquivos de cada painel SSH e as transferências;lib/rdp.tsé o painel RDP (canvas, mapa de scancodes, cursor do servidor).- CSP (
app.security.cspnotauri.conf.json): scripts só do próprio bundle (script-src 'self', semeval), nenhum recurso externo, rede só pelo IPC do Tauri. Estilos inline são permitidos ('unsafe-inline'emstyle-src) porque o xterm.js e o Svelte os usam; por issodangerousDisableAssetCspModification: ["style-src"]impede o Tauri de pôr nonces ali (com nonce, o navegador ignora o'unsafe-inline'). Imagensdata:são o cursor do RDP. OdevCspé igual, mais o WebSocket do Vite. Recurso novo no frontend (fonte, imagem remota, worker) precisa entrar na política, senão o WebView bloqueia.
Ainda não ativa: até o projeto entrar no programa da SignPath Foundation, os binários do Windows saem sem assinatura Authenticode. Quando entrar, vale o seguinte.
Os binários do Windows publicados nas releases são compilados pelo GitHub Actions a partir deste
repositório (.github/workflows/release.yml) e assinados pela SignPath. Nenhum binário compilado
fora desse fluxo é assinado.
- Autores e revisores (committers): Carlos Silva
- Aprovadores (cada release assinada é aprovada manualmente): Carlos Silva
Contribuições de fora do time entram por pull request, revisadas antes do merge.
O Nexo não coleta nem envia dados a ninguém: não tem telemetria nem analytics. Ele só se conecta
aos servidores que você configura (SSH, RDP, clusters do kubeconfig) e, para procurar
atualizações, ao GitHub (o latest.json das releases deste repositório; dá para desligar em
Configurações → Atualizações). Hosts, credenciais e configurações ficam nesta máquina; senhas e chaves, no cofre
criptografado (vault.bin), com a chave no cofre do sistema operacional.
Copyright (C) 2026 Carlos Silva
Este programa é software livre: você pode redistribuí-lo e/ou modificá-lo sob os termos da GNU General Public License, como publicada pela Free Software Foundation, na versão 3 da licença ou (a seu critério) qualquer versão posterior. Ele é distribuído na esperança de ser útil, mas SEM NENHUMA GARANTIA. Veja o arquivo LICENSE.