envsec

Gestão segura de segredos de ambiente usando armazenamentos de credenciais nativos do SO.

Demonstração

Recursos

• Armazene segredos no armazenamento de credenciais nativo do seu SO (não em arquivos de texto simples)
• Multiplataforma: macOS, Linux, Windows
• Organize segredos por contexto (ex.: myapp.dev, stripe-api.prod, work.staging)
• Rastreie metadados de segredos (nomes de chaves, carimbos de data/hora) via SQLite
• Pesquise contextos e segredos com padrões glob
• Execute comandos com interpolação de segredos
• Salve e reexecute comandos com cmd (pesquisar, listar, executar, excluir)
• Exporte segredos para arquivos .env (com rastreamento de geração via audit)
• Exporte segredos como variáveis de ambiente do shell (eval $(envsec env))
• Carregue segredos de arquivos .env (com detecção de conflitos)
• Compartilhe segredos criptografados com GPG para membros da equipe
• Interface de terminal interativa (envsec tui) para gerenciar segredos sem memorizar comandos

Pacotes

Este é um monorepo contendo os seguintes pacotes:

Pacote	Descrição	npm
envsec	Ferramenta CLI para gerenciar segredos
@envsec/sdk	SDK Node.js / Bun para carregar segredos programaticamente
@envsec/core	Mecanismo principal — adaptadores de armazenamento de credenciais do SO + banco de metadados
@envsec/tui	Interface de terminal interativa para gerenciamento de segredos

Início Rápido do SDK

Para acesso programático a segredos a partir de Node.js ou Bun, use @envsec/sdk:```bash npm install @envsec/sdk

I'm ready to translate the Kitploit tool content from English to Portuguese. Please provide chunk 3 of 85.```typescript
import { loadSecrets } from "@envsec/sdk";

// Load and inject into process.env
await loadSecrets({ context: "myapp.dev", inject: true });

// Or use the client for full control
import { EnvsecClient } from "@envsec/sdk";
const client = await EnvsecClient.create({ context: "myapp.dev" });
const apiKey = await client.get("api.key");
await client.close();

Consulte a documentação completa do SDK para todas as APIs, suporte a múltiplos contextos e opções.

Requisitos

• Node.js >= 22

macOS

Sem dependências extras. Utiliza o Keychain integrado por meio da ferramenta CLI security.

Linux

Requer libsecret-tools (que fornece o comando secret-tool), que se comunica com o GNOME Keyring, KDE Wallet ou qualquer provedor da API Secret Service via D-Bus.```bash

Debian / Ubuntu

sudo apt install libsecret-tools

Fedora

sudo dnf install libsecret

Arch

sudo pacman -S libsecret

É necessária uma sessão D-Bus em execução e um daemon de keyring (ex.: `gnome-keyring-daemon`) ativo. A maioria dos ambientes desktop lida com isso automaticamente.

### Windows

Sem dependências extras. Utiliza o Gerenciador de Credenciais integrado do Windows via `cmdkey` e PowerShell.

## Instalação

### Homebrew (macOS / Linux)```bash
brew tap davidnussio/homebrew-tap
brew install envsec

npm```bash

npm install -g envsec

### npx (sem instalação)```bash
npx envsec

mise```bash

mise use -g npm:envsec

## Utilização

A maioria dos comandos requer um contexto especificado com `--context` (ou `-c`).
Um contexto é um rótulo de forma livre para agrupar segredos — ex.: `myapp.dev`, `stripe-api.prod`, `work.staging`.

### Opções globais

Estas opções estão disponíveis em todos os comandos:

- `--context`, `-c` — Nome do contexto (ex.: `myapp.dev`, `stripe-api.prod`). Também lê a variável de ambiente `ENVSEC_CONTEXT`
- `--debug`, `-d` — Ativa registos de depuração
- `--json` — Saída em formato JSON para scripts
- `--db` — Caminho para o ficheiro de base de dados SQLite (padrão: `~/.envsec/store.sqlite`). Também lê a variável de ambiente `ENVSEC_DB`

### Caminho personalizado da base de dados

Por padrão, os metadados são armazenados em `~/.envsec/store.sqlite`. Pode substituir isto com `--db` ou a variável de ambiente `ENVSEC_DB`:```bash
# Use a project-local database
envsec --db ./local-store.sqlite -c myapp.dev list

# Or via environment variable
export ENVSEC_DB=/shared/team/envsec.sqlite
envsec -c myapp.dev list

A flag --db tem precedência sobre ENVSEC_DB. Os casos de uso incluem bancos de dados por projeto, bancos de dados compartilhados em equipe em unidades de rede e CI/CD com armazenamento efêmero.

Adicionar um segredo

Armazene um segredo no armazenamento de credenciais do sistema operacional.

• <key> — Nome da chave do segredo (ex.: api.key, db.password)
• --value, -v — Valor a armazenar (omitir para prompt mascarado interativo)
• --expires, -e — Duração de expiração (ex.: 30m, 2h, 7d, 4w, 3mo, 1y)```bash

Store a value inline

envsec -c myapp.dev add api.key --value "sk-abc123"

Or use the short alias

envsec -c myapp.dev add api.key -v "sk-abc123"

Omit --value for an interactive masked prompt

envsec -c myapp.dev add api.key

Set an expiry duration with --expires (-e)

envsec -c myapp.dev add api.key -v "sk-abc123" --expires 30d

Supported duration units: m (minutes), h (hours), d (days), w (weeks), mo (months), y (years)

Combinable: 1y6mo, 2w3d, 1d12h

envsec -c myapp.dev add api.key -v "sk-abc123" -e 6mo

### Obter um segredo

Recupera um valor de segredo do armazenamento de credenciais do sistema operacional.

- `<key>` — Nome da chave do segredo a ser recuperado
- `--quiet`, `-q` — Imprime apenas o valor bruto (sem avisos ou saída extra)
- `--json` — Saída em formato JSON (inclui contexto, chave, valor, expires_at)```bash
envsec -c myapp.dev get api.key

# Print only the raw value (no warnings or extra output)
envsec -c myapp.dev get api.key --quiet
envsec -c myapp.dev get api.key -q

Eliminar um segredo

Remove um segredo do armazenamento de credenciais do sistema operativo.

• <key> — Nome da chave do segredo a eliminar (opcional se --all for utilizado)
• --yes, -y — Ignorar o pedido de confirmação
• --all — Eliminar todos os segredos no contexto```bash envsec -c myapp.dev delete api.key

or use the alias

envsec -c myapp.dev del api.key

### Renomear um segredo

Renomeie uma chave de segredo dentro do mesmo contexto. O valor e os metadados de expiração são preservados.

- `<old-key>` — Nome atual da chave de segredo
- `<new-key>` — Novo nome da chave de segredo
- `--force`, `-f` — Sobrescreve o destino se ele já existir```bash
# Rename a key
envsec -c myapp.dev rename old.key new.key

# Overwrite target if it already exists
envsec -c myapp.dev rename old.key existing.key --force

Listar todos os segredos num contexto

Lista todas as chaves secretas e metadados num contexto.

• --json — Saída em formato JSON```bash envsec -c myapp.dev list

### Listar todos os contextos

Lista todos os contextos disponíveis com contagens de segredos.

- `--json` — Saída em formato JSON```bash
# Without --context, lists all available contexts with secret counts
envsec list

Pesquisar segredos

Pesquise segredos ou contextos usando padrões glob.

• <pattern> — Padrão glob para pesquisar (ex.: api.*, myapp.*)
• --json — Saída em formato JSON```bash

Search secrets within a context

envsec -c myapp.dev search "api.*"

Search contexts by pattern (without --context)

envsec search "myapp.*"

### Mover segredos entre contextos

Move segredos de um contexto para outro. Os segredos de origem são removidos após a movimentação.

- `<pattern>` — Padrão glob ou chave exata a mover (opcional se `--all` for usado)
- `--to`, `-t` — Contexto de destino para mover os segredos
- `--all` — Move todos os segredos do contexto de origem
- `--force`, `-f` — Sobrescreve segredos existentes no contexto de destino
- `--yes`, `-y` — Ignora o prompt de confirmação```bash
# Move a single secret
envsec -c myapp.dev move api.token --to myapp.prod

# Move secrets matching a glob pattern
envsec -c myapp.dev move "redis.*" --to myapp.prod -y

# Move all secrets from one context to another
envsec -c myapp.dev move --all --to myapp.prod -y

# Overwrite existing secrets in the target context
envsec -c myapp.dev move "redis.*" --to myapp.prod --force -y

Copiar segredos entre contextos

Copia segredos de um contexto para outro. Os segredos de origem permanecem intactos.

• <pattern> — Padrão glob ou chave exata a copiar (opcional se --all for usado)
• --to, -t — Contexto de destino para copiar os segredos
• --all — Copiar todos os segredos do contexto de origem
• --force, -f — Sobrescrever segredos existentes no contexto de destino
• --yes, -y — Ignorar o prompt de confirmação```bash

Copy a single secret

envsec -c myapp.dev copy api.token --to myapp.staging

Copy secrets matching a glob pattern

envsec -c myapp.dev copy "redis.*" --to myapp.staging -y

Copy all secrets from one context to another

envsec -c myapp.dev copy --all --to myapp.staging -y

Overwrite existing secrets in the target context

envsec -c myapp.dev copy "redis.*" --to myapp.staging --force -y

### Executar um comando com segredos

Execute um comando com valores secretos interpolados por meio de placeholders ou injetados como variáveis de ambiente.

- `<command>` — Comando a ser executado. Use placeholders `{key}` para interpolação de segredos
- `--inject`, `-i` — Injetar todos os segredos do contexto como variáveis de ambiente (`KEY.NAME` → `KEY_NAME`)
- `--save`, `-s` — Salvar este comando para uso posterior
- `--name`, `-n` — Nome para o comando salvo (solicitado interativamente se omitido com `--save`)```bash
# Placeholders {key} are resolved with secret values before execution
envsec -c myapp.dev run 'curl {api.url} -H "Authorization: Bearer {api.token}"'

# Any {dotted.key} in the command string is replaced with its value
envsec -c myapp.prod run 'psql {db.connection_string}'

# Inject ALL context secrets as environment variables (KEY.NAME → KEY_NAME)
envsec -c myapp.dev run --inject 'node server.js'
envsec -c myapp.dev run -i 'docker compose up'

# Combine --inject with placeholders
envsec -c myapp.dev run --inject 'curl {api.url} -H "Authorization: Bearer $API_TOKEN"'

# Save the command for later use with --save (-s) and --name (-n)
envsec -c myapp.dev run --save --name deploy 'kubectl apply -f - <<< {k8s.manifest}'

# If you use --save without --name, you'll be prompted interactively
envsec -c myapp.dev run --save 'psql {db.connection_string}'

Se algum placeholder referenciar um segredo que não existe, o comando não será executado e você verá um erro claro:``` ❌ Missing secrets in context "myapp.dev":

• api.url
• api.token

Add them with: envsec -c myapp.dev add

### Comandos salvos

Os comandos salvos ficam sob o subcomando `cmd`, mantendo-os separados das operações secretas.

#### cmd list

Lista todos os comandos salvos.```bash
envsec cmd list

cmd run

Executa um comando salvo (usa o contexto com o qual foi salvo).

• <name> — Nome do comando salvo a ser executado
• --override-context, -o — Substitui o contexto salvo no momento da execução
• --quiet, -q — Suprime a saída informativa (imprime apenas a saída do comando)
• --inject, -i — Injeta todos os segredos do contexto como variáveis de ambiente```bash envsec cmd run deploy

Run quietly (suppress informational output like "Resolved N secret(s)")

envsec cmd run deploy --quiet envsec cmd run deploy -q

Override the context at execution time

envsec cmd run deploy --override-context myapp.prod envsec cmd run deploy -o myapp.prod

Inject all context secrets as env vars when running a saved command

envsec cmd run deploy --inject envsec cmd run deploy -i

#### cmd search

Pesquise comandos salvos por nome ou string de comando.

- `<pattern>` — Padrão de pesquisa
- `--name`, `-n` — Pesquisar apenas nos nomes dos comandos
- `--command`, `-m` — Pesquisar apenas nas strings dos comandos```bash
envsec cmd search psql

# Search only by name
envsec cmd search deploy -n

# Search only by command string
envsec cmd search kubectl -m

cmd delete

Elimina um comando salvo.

• <name> — Nome do comando a eliminar```bash envsec cmd delete deploy

### Gerar um arquivo .env

Exporte todos os segredos de um contexto para um arquivo `.env`.

- `--output`, `-o` — Caminho do arquivo de saída (padrão: `.env`)```bash
# Creates .env with all secrets from the context
envsec -c myapp.dev env-file

# Specify a custom output path
envsec -c myapp.dev env-file --output .env.local

As chaves são convertidas para UPPER_SNAKE_CASE (ex.: api.token → API_TOKEN).

Exportar segredos como variáveis de ambiente

Gera instruções de exportação para uso com eval ou source no shell.

• --shell, -s — Sintaxe do shell de destino: bash (padrão), zsh, fish, powershell
• --unset, -u — Gera comandos de unset/remoção em vez de exportação```bash

Output export statements for eval (bash/zsh)

eval $(envsec -c myapp.dev env)

Specify target shell syntax

envsec -c myapp.dev env --shell fish envsec -c myapp.dev env --shell powershell

Output unset commands to clean up exported variables

eval $(envsec -c myapp.dev env --unset)

Combine shell and unset

envsec -c myapp.dev env --unset --shell fish

Shells suportados: `bash` (padrão), `zsh`, `fish`, `powershell`. As chaves são convertidas para `UPPER_SNAKE_CASE` (ex.: `api.token` → `API_TOKEN`). A saída vai para stdout, podendo ser canalizada para `eval` ou usada diretamente via source — nenhum arquivo é gravado em disco.

### Iniciar uma sessão de shell com escopo de segredos

Abra um subshell interativo com todos os segredos do contexto injetados como
variáveis de ambiente. Ao executar `exit`, os segredos desaparecem — sem necessidade de limpeza.

- `--shell`, `-s` — Shell a ser iniciado (`bash`, `zsh`, `fish`, `powershell`). Padrão: detecção automática
- `--no-inherit` — Não herdar variáveis de ambiente do processo pai
- `--quiet`, `-q` — Suprimir o banner de início/saída```bash
envsec -c myapp.dev shell

Aqui está a tradução do conteúdo:

# 🚀 **Bem-vindo ao Kitploit** — A plataforma definitiva para entusiastas e profissionais de segurança cibernética!

[![Kitploit](https://kitploit.com/assets/img/logo.png)](https://kitploit.com)

**Kitploit** é um diretório abrangente de ferramentas de segurança de código aberto, projetado para ajudar pesquisadores de segurança, profissionais de segurança ofensiva e defensiva, e entusiastas a descobrir, explorar e utilizar as ferramentas mais recentes e eficazes no campo da segurança cibernética.

---

## 📌 **Recursos Principais**

- **Extensa Coleção de Ferramentas**: Milhares de ferramentas de segurança categorizadas para fácil navegação.
- **Atualizações Diárias**: Novas ferramentas e atualizações são adicionadas regularmente para manter o diretório atualizado.
- **Pesquisa e Filtros Avançados**: Encontre rapidamente ferramentas por categoria, tags, ou palavras-chave.
- **Informações Detalhadas**: Cada ferramenta inclui descrições, instruções de instalação, exemplos de uso e links para o repositório original.
- **Interface Amigável**: Design limpo e intuitivo para uma experiência de usuário perfeita.

---

## 🛠️ **Categorias de Ferramentas**

O Kitploit cobre uma ampla gama de categorias, incluindo, mas não se limitando a:

- 🔍 **Reconhecimento e Coleta de Informações**
- 🛡️ **Defesa e Proteção**
- 🔓 **Testes de Penetração**
- 📡 **Análise de Rede**
- 🧬 **Engenharia Reversa**
- 🕵️ **Análise Forense Digital**
- 🤖 **IA e Aprendizado de Máquina em Segurança**
- E muito mais!

---

## 🚀 **Como Usar**

1. **Navegue** pelas categorias ou use a barra de pesquisa para encontrar ferramentas específicas.
2. **Explore** os detalhes de cada ferramenta, incluindo documentação e exemplos.
3. **Clone ou baixe** a ferramenta diretamente do repositório vinculado.
4. **Contribua** compartilhando suas próprias ferramentas ou sugerindo melhorias.

---

## 🤝 **Contribuindo**

Adoraríamos ter sua contribuição! Se você tem uma ferramenta de segurança que gostaria de compartilhar ou deseja melhorar o Kitploit, siga estas etapas:

1. Faça um **fork** do repositório.
2. Crie uma nova **branch** para sua funcionalidade.
3. Envie um **pull request** com uma descrição clara das suas alterações.

---

## 📄 **Licença**

Este projeto está licenciado sob a [Licença MIT](https://github.com/davidnussio/envsec/blob/main/LICENSE).

---

## 📬 **Contato**

Para perguntas, sugestões ou feedback, sinta-se à vontade para entrar em contato:

- **Website**: [https://kitploit.com](https://kitploit.com)
- **Twitter**: [@kitploit](https://twitter.com/kitploit)
- **GitHub**: [Kitploit](https://github.com/kitploit)

---

**Aproveite o Kitploit e mantenha-se seguro!** 🔐

▶ envsec shell — context: myapp.dev (8 secrets loaded) Type 'exit' or press Ctrl+D to leave the session.

(envsec:myapp.dev) ~ $ echo $DATABASE_URL postgres://user:pass@localhost/mydb

(envsec:myapp.dev) ~ $ exit → Exiting envsec shell — secrets cleared.

Aqui está a tradução do conteúdo:

- **`--no-verify`**: Ignora a verificação de assinatura do servidor (não recomendado).
- **`--timeout <segundos>`**: Define o tempo limite da conexão (padrão: 30).
- **`--retries <n>`**: Número de tentativas de reconexão (padrão: 3).
- **`--proxy <url>`**: Usa um proxy para a conexão (ex.: `socks5://127.0.0.1:9050`).
- **`--user-agent <string>`**: Define um User-Agent personalizado para as requisições.
- **`--output <arquivo>`**: Salva a saída em um arquivo em vez de imprimir no terminal.
- **`--verbose`**: Exibe informações detalhadas de depuração durante a execução.
- **`--quiet`**: Suprime todas as saídas, exceto os resultados finais.
- **`--version`**: Exibe a versão da ferramenta e sai.
- **`--help`**: Exibe a mensagem de ajuda e sai.

### Exemplos de uso

```bash
# Exemplo básico: verificar um único alvo
python3 tool.py --target https://exemplo.com

# Verificar vários alvos a partir de um arquivo
python3 tool.py --list alvos.txt --output resultados.txt

# Usar um proxy SOCKS5 (ex.: Tor) com timeout personalizado
python3 tool.py --target https://exemplo.com --proxy socks5://127.0.0.1:9050 --timeout 60

# Modo silencioso com saída em arquivo
python3 tool.py --list alvos.txt --quiet --output relatorio.json

Opções de saída

A ferramenta suporta vários formatos de saída para facilitar a integração com outros fluxos de trabalho:

Para selecionar um formato, use a flag --format:

python3 tool.py --target https://exemplo.com --format json

Códigos de saída

A ferramenta retorna códigos de saída padrão para facilitar o uso em scripts:

Integração com outras ferramentas

A saída JSON pode ser facilmente canalizada para outras ferramentas de análise:

python3 tool.py --target https://exemplo.com --format json | jq '.vulnerabilidades[] | {severidade, tipo, url}'

Isso permite criar pipelines automatizados de segurança, integrando a ferramenta com sistemas de CI/CD, SIEM ou outras soluções de orquestração.```bash

Force a specific shell

envsec -c myapp.dev shell --shell zsh

Only envsec secrets in env (no parent variables, except PATH)

envsec -c myapp.dev shell --no-inherit

Suppress the startup/exit banner

envsec -c myapp.dev shell --quiet

A variável `ENVSEC_CONTEXT` é sempre definida dentro da sessão, para que você possa
referenciá-la em scripts ou personalizações de prompt.

### Carregar segredos de um arquivo .env

Importe segredos de um arquivo `.env` para um contexto.

- `--input`, `-i` — Caminho do arquivo `.env` de entrada (padrão: `.env`)
- `--force`, `-f` — Sobrescrever segredos existentes sem solicitar confirmação
- `--batch`, `-b` — Modo lote: adiar a persistência no banco de dados até que todos os segredos sejam importados```bash
# Import secrets from .env into the context
envsec -c myapp.dev load

# Specify a custom input file
envsec -c myapp.dev load --input .env.local

# Overwrite existing secrets without warning
envsec -c myapp.dev load --force

As chaves são convertidas de UPPER_SNAKE_CASE para dotted.lowercase (ex.: API_TOKEN → api.token). Se uma chave já existir, ela é ignorada com um aviso, a menos que --force (-f) seja fornecido.

Compartilhar segredos (criptografados com GPG)

Criptografe todos os segredos de um contexto para um membro da equipe usando GPG.

• --encrypt-to — Chave de destinatário GPG (e-mail, ID da chave ou impressão digital) para criptografar
• --output, -o — Caminho do arquivo de saída (padrão: stdout). Use - para stdout explicitamente
• --json — Use o formato JSON dentro do payload criptografado (padrão: formato .env)```bash

Encrypt all secrets from a context for a team member

envsec -c myapp.dev share --encrypt-to [email protected]

Save encrypted output to a file

envsec -c myapp.dev share --encrypt-to [email protected] -o secrets.enc

Use JSON format inside the encrypted payload

envsec -c myapp.dev --json share --encrypt-to [email protected] -o secrets.enc

O destinatário pode descriptografar com `gpg --decrypt secrets.enc` e canalizar o resultado para `envsec load`. Por padrão, o payload criptografado usa o formato `.env` (`KEY="value"`); com `--json`, usa um objeto JSON estruturado. Requer GPG instalado e a chave pública do destinatário no seu chaveiro.

### Auditar segredos quanto à expiração

Verifica segredos expirados ou prestes a expirar e exportações de arquivos `.env` rastreados.

- `--within`, `-w` — Mostra segredos que expiram dentro desta duração (padrão: `30d`). Use `0d` para mostrar apenas os já expirados
- `--json` — Saída em formato JSON```bash
# Check for expired or expiring secrets in a context (default window: 30 days)
envsec -c myapp.dev audit

# Specify a custom window
envsec -c myapp.dev audit --within 7d

# Show only already-expired secrets
envsec -c myapp.dev audit --within 0d

# Audit across all contexts (omit --context)
envsec audit

# JSON output
envsec -c myapp.dev audit --json

Segredos com uma duração --expires definida via envsec add são rastreados nos metadados. O comando audit verifica segredos que já expiraram ou que expirarão dentro da janela especificada. Os comandos get e list também exibem avisos de expiração inline.

O comando audit também rastreia arquivos .env gerados. Sempre que env-file é usado, o caminho de saída, o contexto e o timestamp são registrados. A saída do audit inclui uma segunda seção listando esses arquivos. Se um arquivo .env rastreado não existir mais no disco, o audit o remove automaticamente dos metadados e relata a limpeza.

Gerar um segredo aleatório

Gere um segredo aleatório criptograficamente seguro, opcionalmente armazenando-o.

• <key> — Nome da chave do segredo (opcional; omita para geração de senha independente)
• --length, -l — Comprimento do segredo gerado (padrão: 32)
• --prefix, -p — Prefixo a ser adicionado ao segredo gerado (ex.: sk_)
• --expires, -e — Duração da expiração (ex.: 30m, 2h, 7d, 4w, 3mo, 1y)
• --alphanumeric, -a — Usar apenas caracteres alfanuméricos [a-zA-Z0-9] (padrão)
• --special, -s — Incluir caracteres especiais comuns [a-zA-Z0-9!@#$%^&*]
• --all-chars, -A — Usar todos os caracteres ASCII imprimíveis para entropia máxima```bash

Generate and store a 32-char alphanumeric secret

envsec -c myapp.dev secret api.key

Custom length and prefix

envsec -c myapp.dev secret api.key --prefix "sk_" --length 48

Character sets:

--alphanumeric (-a) [a-zA-Z0-9] (default)

--special (-s) [a-zA-Z0-9] + !@#$%^&*

--all-chars (-A) all printable ASCII

envsec -c myapp.dev secret db.password --special --length 64

With expiry

envsec -c myapp.dev secret api.key --prefix "sk_" -l 48 --expires 90d

Standalone password generator (no store, just print)

envsec secret --length 32 envsec secret --special --length 64 --prefix "pk_"

Quando tanto o contexto quanto a chave são fornecidos, o valor gerado é armazenado e impresso. Sem nenhum dos dois, o valor bruto vai para o stdout — útil para redirecionar para `pbcopy`, `xclip` ou outras ferramentas.

### TUI Interativa

O envsec inclui uma interface de terminal em tela cheia para gerenciar segredos de forma interativa — sem necessidade de memorizar comandos.```bash
# Launch the TUI
envsec tui

# Launch with a pre-selected context
envsec -c myapp.dev tui

A TUI fornece oito telas acessíveis pelo menu principal:

• Contextos — navegue por todos os contextos, defina o contexto ativo com s, limpe o contexto com x, veja contagens de segredos, exclua contextos inteiros
• Segredos — liste segredos em uma tabela, revele valores, adicione ou exclua segredos
• Adicionar Segredo — formulário interativo com entrada mascarada e duração de expiração opcional
• Pesquisar — pesquisa por padrão glob em segredos ou contextos
• Comandos Salvos — liste, visualize e exclua modelos de comandos salvos
• Auditoria — verifique segredos expirados/expirando, revise exportações rastreadas de arquivos .env
• Importar .env — carregue segredos de um arquivo .env para o contexto atual
• Exportar .env — exporte segredos para um arquivo .env (rastreado para auditoria)

Atalhos de teclado:

Diagnosticar sua configuração

Execute verificações de integridade para validar sua instalação do envsec.

• --json — Saída em formato JSON para scripts```bash

Run all health checks

envsec doctor

JSON output for scripting

envsec --json doctor

O comando `doctor` verifica se a sua instalação do envsec está funcionando corretamente. Ele verifica:
- Suporte de plataforma e versão do Node.js
- Disponibilidade do armazenamento de credenciais (Keychain do macOS, secret-tool do Linux, cmdkey do Windows)
- Acesso de leitura/gravação ao keychain
- Caminho do banco de dados, permissões e integridade do esquema
- Segredos órfãos (metadados sem entrada no keychain)
- Segredos expirados
- Variáveis de ambiente (`ENVSEC_DB`, `ENVSEC_CONTEXT`)
- Shell atual

### Completions de shell

O envsec suporta conclusão por tabulação dinâmica para bash, zsh e fish. As completions são sensíveis ao contexto: elas sugerem os seus nomes de contexto reais, chaves de segredo e nomes de comandos salvos em tempo real, consultando o banco de dados de metadados.```bash
# Bash (add to ~/.bashrc)
eval "$(envsec --completions bash)"

# Zsh (add to ~/.zshrc)
eval "$(envsec --completions zsh)"

# Fish (add to ~/.config/fish/config.fish)
envsec --completions fish | source

O que é completado dinamicamente:

• --context / -c — lista todos os seus contextos
• Argumentos de chave secreta (get, add, delete) — lista chaves para o contexto atual
• cmd run / cmd delete — lista nomes de comandos salvos
• --override-context / -o — lista contextos para cmd run
• Subcomandos, flags e escolhas estáticas (shells, etc.) também são completados

Comparação

Como o envsec se compara a outras ferramentas para gerenciar segredos de ambiente?

| Autenticação biométrica | Herda biometria do SO (ex.: desbloqueio do Keychain do macOS) | Nenhuma | Impressão digital / Touch ID via integração com o app | | Rastreamento de metadados | SQLite (nomes de chaves, timestamps — nunca valores) | Nenhum | Histórico de itens e logs de auditoria baseados em nuvem |

Em resumo: dotenv é a abordagem mais simples (arquivos no disco), a CLI do 1Password é a mais rica em recursos para equipes com sincronização em nuvem e RBAC, e o envsec fica no meio — oferecendo criptografia nativa do SO com zero contas, zero dependências de nuvem e um fluxo de trabalho focado no desenvolvedor que vai além do que arquivos .env podem fazer.

Como funciona

Os segredos são armazenados no armazenamento de credenciais nativo do SO. O backend é selecionado automaticamente com base na plataforma:

Os metadados (nomes de chaves, timestamps) são mantidos em um banco de dados SQLite em ~/.envsec/store.sqlite (configurável via --db ou ENVSEC_DB). As chaves devem conter pelo menos um separador de ponto (ex.: service.account), que mapeia para a estrutura de serviço/conta do armazenamento de credenciais.

Segurança

O envsec é construído em torno de um princípio simples: seus segredos pertencem ao seu SO, não a dotfiles. Cada decisão de design parte dessa base.

Como o envsec protege seus segredos

Criptografia nativa do SO, zero criptografia personalizada. Os valores dos segredos são armazenados diretamente no Keychain do macOS, no GNOME Keyring / KDE Wallet ou no Windows Credential Manager. O envsec nunca inventa sua própria criptografia — ele delega aos armazenamentos de credenciais testados em batalha que seu sistema operacional já fornece, protegidos pela sua sessão de usuário e (no macOS) pelo keychain de login.

Suporte completo a Unicode. Os valores dos segredos podem conter qualquer caractere Unicode, incluindo emojis e letras acentuadas. Os valores são codificados em base64 antes de serem armazenados no armazenamento de credenciais do SO, evitando peculiaridades de codificação específicas da plataforma (ex.: a CLI security do macOS codifica saída não ASCII em hexadecimal). Segredos legados em texto puro são lidos de forma transparente para compatibilidade retroativa.

Segredos nunca tocam o disco como texto puro. Os valores vão direto do seu terminal para o armazenamento de credenciais do SO. Eles nunca são gravados em arquivos de configuração, logs ou armazenamento intermediário.

Sem segredos na saída do terminal. Os comandos list e search exibem apenas nomes de chaves — valores nunca são impressos. Isso mantém os segredos fora dos buffers de scrollback, gravações de tela e do alcance de olhares curiosos.

Execução segura de comandos. O comando run injeta segredos como variáveis de ambiente do processo filho, em vez de interpolá-los na string do comando. Isso significa que os valores dos segredos não aparecem na saída do ps nem no histórico do shell. Se qualquer segredo referenciado estiver ausente, o comando é bloqueado por completo — sem execução parcial com credenciais incompletas.

Validação de entrada e prevenção de injeção. Os nomes de contextos são validados contra uma allowlist estrita (alfanuméricos, pontos, hífens, sublinhados) com verificações de path traversal e poluição de prototype. Todas as consultas SQLite usam prepared statements com parâmetros vinculados, prevenindo injeção de SQL. Argumentos do PowerShell no Windows são escapados para proteger contra injeção de comandos.

Permissões de arquivo restritivas. O diretório de metadados (~/.envsec/) é criado com permissões 0700 e o banco de dados SQLite com 0600, limitando o acesso ao usuário proprietário.

Limitações conhecidas e áreas para melhoria

Acreditamos em ser transparentes sobre o que o envsec ainda não cobre. Estas são compensações reais, não bugs — e entendê-las ajuda você a tomar decisões informadas.

Metadados são visíveis. O banco de dados SQLite em ~/.envsec/store.sqlite armazena nomes de chaves, nomes de contextos e timestamps — nunca valores de segredos, mas o suficiente para revelar quais segredos existem. Modelos de comandos salvos (com placeholders {key}) também são armazenados lá. Se a confidencialidade dos metadados for importante para você, garanta que seu diretório home esteja em um volume criptografado.

Exportações env-file são texto puro. O comando env-file grava valores de segredos em um arquivo .env no disco. Isso é inerentemente sensível — trate o arquivo de saída de acordo e nunca o envie para o controle de versão. Considere-o uma ponte de conveniência, não um mecanismo de armazenamento.

A execução de shell carrega risco inerente. O comando run passa seu modelo de comando por /bin/sh (ou cmd.exe no Windows). Se o próprio modelo vier de entrada não confiável, a injeção de shell é possível. Execute apenas modelos de comando que você escreveu ou em que confia.

Sem controle de acesso entre contextos. Qualquer processo executado como seu usuário do SO pode ler todos os segredos em todos os contextos. O envsec depende do isolamento de usuário no nível do SO — ele não adiciona sua própria camada de autorização entre contextos.

Ambientes Linux headless. No Linux, o envsec depende de uma sessão D-Bus ativa e de um daemon de keyring (ex.: gnome-keyring-daemon). Em contêineres ou servidores headless sem sessão gráfica, o keyring pode estar indisponível ou pode armazenar segredos com proteção mais fraca.

A criptografia depende do seu SO. O envsec não adiciona criptografia adicional em repouso além do que o armazenamento de credenciais nativo fornece. Em sistemas sem criptografia de disco completo, um atacante com acesso físico poderia potencialmente extrair segredos do keychain. Recomendamos habilitar a criptografia de disco completo (FileVault, LUKS, BitLocker) para a proteção mais forte.

Desenvolvimento

Pré-requisitos

• Node.js >= 22
• pnpm

Os pacotes core, SDK, CLI e TUI usam Effect 4 e estão atualmente fixados em 4.0.0-rc.112. Mantenha as versões do Effect e do @effect/platform-node alinhadas em todo o workspace enquanto o Effect 4 permanecer em status de release candidate.

Configuração```bash

git clone https://github.com/davidnussio/envsec.git cd envsec pnpm install pnpm run build

### Estrutura do Projeto```
packages/
  cli/     → envsec CLI (published as `envsec`)
  sdk/     → Node.js/Bun SDK (published as `@envsec/sdk`)
  core/    → Core engine, shared by CLI and SDK (published as `@envsec/core`)
  tui/     → Interactive terminal UI (published as `@envsec/tui`)
apps/
  website/ → Documentation website

Comandos comuns```bash

Build all packages

pnpm run build

Lint and format check (all packages)

pnpm run check

Auto-fix lint and formatting

pnpm run fix

Run package unit and contract tests

pnpm run test:unit

Run the CLI end-to-end suite with isolated database and credential fixtures

pnpm --filter envsec test

Release (build + changeset publish)

pnpm run release

O conjunto E2E isolado nunca acessa o armazenamento nativo de credenciais. Para exercitar
o adaptador real do SO no macOS ou Linux, compile primeiro e opte por isso explicitamente:```bash
ENVSEC_E2E_CLI="$PWD/packages/cli/dist/main.js" \
  ENVSEC_E2E_ISOLATED=0 \
  pnpm --filter envsec test

Testes E2E nativos usam contextos dedicados test.e2e* e os removem em seguida.

Executando localmente sem instalar

Crie um alias temporário para usar o build local como se ele estivesse instalado globalmente:```bash

Bash / Zsh

alias envsec="node $(pwd)/packages/cli/dist/main.js"

Fish

alias envsec "node (pwd)/packages/cli/dist/main.js"

### Testar conclusões de shell localmente

Após compilar e configurar o alias, carregue as conclusões na sua sessão atual:```bash
# Bash
alias envsec="node $(pwd)/packages/cli/dist/main.js"
eval "$(envsec --completions bash)"

# Zsh
alias envsec="node $(pwd)/packages/cli/dist/main.js"
eval "$(envsec --completions zsh)"

# Fish
alias envsec "node (pwd)/packages/cli/dist/main.js"
envsec --completions fish | source

Em seguida, pressione TAB após envsec -c para ver seus contextos, ou após envsec -c myapp.dev get para ver as chaves de segredos.

Executando testes

Os testes de integração de ponta a ponta cobrem todo o ciclo de vida da CLI (add, get, list, search, env-file, load, delete, run, cmd, audit, share, completions).```bash

Build first

pnpm run build

macOS / Linux

bash packages/cli/test/e2e-test.sh

Windows (PowerShell)

pwsh packages/cli/test/e2e-test.ps1

CI é executado automaticamente em push/PR para `main` via GitHub Actions, executando `e2e-test.sh` no macOS e Ubuntu, e `e2e-test.ps1` no Windows.

## Licença

MIT