Obter o FactoryDev

Clone o repositório ou faça um fork para contribuir.

git@github.com:hugoalmeidahh/factory-dev.git
git clone git@github.com:hugoalmeidahh/factory-dev.git

Fork no GitHub

Cria uma cópia do repo na sua conta para contribuir.

⑂ Fork
Ferramenta de Desenvolvimento Local

FactoryDev

Uma interface web local que centraliza as tarefas mais repetitivas do dia-a-dia de um dev: SSH, Git, Repos, Servidores, Docker e muito mais — sem decorar comandos, sem abrir 10 terminais.

▶ Abrir FactoryDev Ver o que resolve →
scroll ↓
O que resolve

Problemas do dia-a-dia

Cada tarefa repetitiva resolvida com poucos cliques.

Dor Solução no FactoryDev
Gerenciar múltiplas chaves SSH (pessoal, trabalho, cliente) Key Manager — gera, importa e organiza chaves ed25519/RSA/ECDSA Keys
Configurar SSH para vários hosts/contas GitHub/GitLab SSH / Git Accounts — aplica ~/.ssh/config automaticamente com diff preview SSH
Clonar repos com a conta certa, sem errar o SSH host Repositories — clona via SSH com a conta selecionada, status ao vivo Repos
Manter identidades git separadas por projeto Git Identities — configura user.name/email e commit signing por diretório via includeIf Git
Conectar e enviar arquivos para servidores remotos Server Manager — testa SSH, abre terminal, envia via SCP com progresso Servers
Monitorar CPU/RAM/disco da máquina local System Info — dashboard atualizado a cada 5s com go runtime info System
Subir containers de dev rápido (Postgres, Redis, Mongo...) Docker Manager — inicia Docker, lança containers com templates pré-configurados Docker
Funcionalidades

7 módulos, 1 interface

Tudo acessível em http://localhost:7337 — sem instalar extensões, sem configurar nada.

🔑

Key Manager

Gera ed25519, RSA e ECDSA. Importa chaves do disco, regenera pública a partir da privada, exporta em Base64.

SSH Keys
🔗

SSH / Git Accounts

Cria contas vinculando host, chave e identidade. Aplica ~/.ssh/config com diff preview e testa a conexão em tempo real.

~/.ssh/config
📦

Repositories

Clona via SSH assíncrono com progresso. Escaneia diretórios para importar repos. Tabs: Overview, Config, Commits.

git clone
🪪

Git Identities

Perfis de identidade por diretório via includeIf. Configura commit signing SSH. Instruções para GitHub/GitLab.

includeIf
🖥️

Server Manager

Cadastra servidores SSH com tags. Testa conexão async, abre terminal direto, envia arquivos via SCP.

SSH / SCP
📊

System Info

Dashboard com CPU por core, RAM, Swap, discos, rede. Atualização a cada 5s. Go runtime info. Editar hostname.

gopsutil
🐳

Docker Manager

Status do daemon em tempo real, lista containers, logs, pull de imagens. Templates: Postgres, MySQL, Redis, Mongo, Adminer.

Docker SDK
01
Key Manager + SSH Accounts

Chaves sem dor de cabeça

  • 1
    Gerar ou importar chave Escolha o tipo (ed25519, RSA 4096, ECDSA), dê um alias. A chave vai para ~/.fdev/keys/alias/.
  • 2
    Criar conta SSH/Git Associe a chave a um host (github.com, gitlab.com, servidor privado) e a uma identidade git.
  • 3
    Aplicar ~/.ssh/config Veja o diff antes de salvar. A entrada Host aparece automaticamente para cada conta.
  • 4
    Testar conexão Clique em "Testar SSH" — feedback em tempo real. Pronto para clonar.
1# ~/.ssh/config gerado automaticamente
2
3Host github-trabalho
4 HostName github.com
5 User git
6 IdentityFile ~/.fdev/keys/trabalho/id_ed25519
7
8Host github-pessoal
9 HostName github.com
10 User git
11 IdentityFile ~/.fdev/keys/pessoal/id_ed25519
→✓ Conexão SSH autenticada com sucesso
02
Repository Manager

Repos com contexto completo

URL SSH
→
Conta SSH
→
git clone
→
Log ao vivo
Branch ● main
Último commit feat: add docker status
Autor Hugo Dev
Modificados 3 arquivos
03
Git Identities

Identidades por projeto

  • 1
    Criar perfil de identidade Nome, e-mail e chave para commit signing. Pode ser pessoal, trabalho, open-source...
  • 2
    Configurar global Aplica user.name, user.email, gpg.format = ssh e signingkey no ~/.gitconfig global.
  • 3
    Regras por diretório Usa includeIf gitdir:~/trabalho/ para trocar automaticamente a identidade conforme o diretório.
  • 4
    Commit signing SSH Instruções passo a passo para adicionar a chave pública como signing key no GitHub/GitLab.
1# ~/.gitconfig
2
3[user]
4 name = Hugo Dev
5 email = hugo@pessoal.com
6
7[gpg]
8 format = ssh
9
10[includeIf "gitdir:~/trabalho/"]
11 path = ~/.gitconfig-trabalho
12
13# ~/.gitconfig-trabalho
14[user]
15 name = Hugo Empresa
16 email = hugo@empresa.com
04
Server Manager

Servidores ao alcance

  • 1
    Cadastrar servidor Host, porta, usuário, chave SSH, tags (produção, staging, cliente...). Tudo salvo em state.json.
  • 2
    Testar conexão Feedback assíncrono — vê em tempo real se a chave funciona, tempo de resposta e mensagens de erro.
  • 3
    Abrir terminal SSH Abre o Terminal.app (macOS) direto no SSH do servidor. Linux detecta gnome-terminal, konsole, kitty...
  • 4
    Enviar arquivo via SCP Selecione arquivo local e destino remoto. Barra de progresso em tempo real via polling HTMX.

api.produção.com

● online prod
ubuntu@api.producao.com:22
Chave: ~/.fdev/keys/producao/id_ed25519
Enviando deploy.tar.gz… 73%
05
Docker Manager

Dev stacks em segundos

Status do daemon Docker no header da página, atualizado a cada 8s. Se o Docker não estiver rodando, um botão ▶ Iniciar Docker executa open -a Docker (macOS) ou orienta o Linux sobre systemctl.

  • 1
    Containers ao vivo Lista com refresh a cada 10s. Iniciar, parar, reiniciar, remover — tudo em 1 clique.
  • 2
    Logs e detalhes Visualize logs do container, inspecione variáveis de ambiente e configurações.
  • 3
    Templates pré-configurados PostgreSQL 16, MySQL 8, Redis 7, MongoDB 7, Adminer — ou configuração manual completa.
  • 4
    Gerenciar imagens Listar, pull assíncrono com progresso e remover imagens não utilizadas.
● Docker rodando 3 rodando · 1 parado v27.3.1 · 1.2 GB
postgres-dev
running 5432
redis-7
running 6379
adminer
stopped 8080
🐘
PostgreSQL
16-alpine
🔴
Redis
7-alpine
🍃
MongoDB
7.0
Arquitetura

Simples, sem build step

Binário único. Assets embutidos via go:embed. Zero dependências externas em produção.

Frontend
HTMX 2.x Alpine.js HTML Templates CSS Custom
↕
Backend (Go)
Go 1.24 chi router html/template go:embed
↕
Sistema / Integrações
Docker SDK gopsutil/v3 os/exec + ssh osascript
↕
Persistência
~/.fdev/state.json ~/.fdev/keys/ ~/.ssh/config ~/.gitconfig
# Estrutura do projeto
factory-dev/
├── cmd/factorydev/ # entrypoint
├── internal/
│ ├── app/ # state + handlers wiring
│ ├── handler/ # HTTP handlers
│ ├── docker/ # Docker SDK client
│ ├── git/ # git ops + terminal
│ └── system/ # gopsutil wrapper
└── web/
├── templates/ # HTML Go templates
└── static/ # CSS + JS (embed)
# Estado persistido
~/.fdev/
├── state.json # chaves, contas, repos...
└── keys/alias/ # pares SSH gerados
~15ms
tempo de resposta médio
1 bin
sem dependências externas
Como rodar

Rodando em desenvolvimento

Pré-requisitos

Go 1.23+ golang.org/dl
Git para as funcionalidades de repo
Docker Desktop (opcional) para Docker Manager

Comandos Make

make dev Servidor dev com go run
make build Compila bin/factorydev
make release Binários linux-amd64 e arm64
make lint golangci-lint ou go vet
make clean Remove bin/ e dist/
$ git clone <url> factory-dev
$ cd factory-dev
# Baixar dependências
$ go mod download
# Rodar em modo dev
$ make dev
FactoryDev listening on :7337
# Abrir no browser
$ open http://localhost:7337

Dev mode: hot reload de templates

Em modo dev, os assets CSS, JS e templates HTML são lidos do disco em tempo real. Altere um template e recarregue o browser — sem restart do servidor.

Health check
:7337/health
{"status":"ok"}
Diagnóstico
:7337/doctor
git, ssh, docker detectados
Build & Release

Binário autocontido

Assets embutidos via //go:embed — o binário final não precisa de nada além do sistema operacional.

Build local (macOS/Linux)

# Compilar o binário
$ make build
# Executar
$ ./bin/factorydev
# Com versão customizada
$ VERSION=1.0.0 make build
$ ./bin/factorydev

Release para servidor Linux

# Gera ambas as arquiteturas
$ make release
# Binários gerados em dist/
dist/factorydev-linux-amd64
dist/factorydev-linux-arm64
# Deploy direto (sem instalar Go)
$ scp dist/factorydev-linux-amd64
user@server:/usr/local/bin/factorydev
Variável
FDEV_PORT=7337
FDEV_HOST=127.0.0.1
Dados
~/.fdev/state.json
~/.fdev/keys/
Tech Stack

Tecnologias que fazem sentido

Escolhas pragmáticas: sem frameworks pesados, sem build steps, sem surpresas.

🐹

Go 1.24

Backend, HTTP server, templates, embeds, goroutines para jobs assíncronos

⚡

HTMX 2.x

Interações dinâmicas sem escrever JavaScript. Polling, swap, triggers via atributos HTML

🏔️

Alpine.js

Estado local de componentes (tabs, toggles, accordions) de forma declarativa no HTML

🔗

chi

Roteador HTTP idiomático para Go. Leve, sem dependências, middleware padrão net/http

📈

gopsutil/v3

Métricas de sistema multiplataforma: CPU, RAM, disco, rede — macOS e Linux

🐳

Docker SDK

docker/docker client oficial. Containers, imagens, logs, stats — comunicação direta com o daemon

📦

go:embed

Templates HTML, CSS e JS embutidos no binário final. Deploy = copiar 1 arquivo

💾

JSON local

Persistência simples em ~/.fdev/state.json. Sem banco de dados, sem migrations, sem setup

Pronto para usar

Seu workflow,
sem fricção.

FactoryDev roda em localhost:7337, salva tudo em ~/.fdev/ e não precisa de configuração inicial.

▶ Abrir FactoryDev ↑ Voltar ao início
make dev → development
make build → binário local
make release → Linux deploy
MIT License