Poly

poly

English · Français

Um comando, todos os gerenciadores de pacotes. poly instala a partir de pip, npm, Homebrew e lançamentos binários verificados por checksum em um único comando unificado, no macOS, Linux e Windows.

Site e gerenciamento de conta: poly.candygate.eu

$ poly install ripgrep
downloading ripgrep  [############################] 100%  1.7MiB/1.7MiB
installed ripgrep 15.1.0 (via tap)
note: tap binaries are installed to ~/.poly/bin — make sure it's on your PATH

$ poly install requests@2.31.0
installed requests 2.31.0 (via pip)

$ poly install npm:cowsay
installed cowsay 1.6.0 (via npm)

$ poly install brew:jq
installed jq 1.8.2 (via brew)

$ poly list
NAME      VERSION  ADAPTER  INSTALLED
cowsay    1.6.0    npm      2026-07-11 15:52
jq        1.8.2    brew     2026-07-11 17:30
requests  2.31.0   pip      2026-07-11 15:52
ripgrep   15.1.0   tap      2026-07-11 15:52

Instalação

macOS — baixe o poly-macos.pkg, abra-o e clique no instalador. Instala um binário universal (Intel + Apple Silicon) em /usr/local/bin/poly. Ele não é assinado/notarizado (ainda sem conta de desenvolvedor Apple), então o Gatekeeper avisará na primeira abertura — clique com o botão direito → Abrir, ou System Settings → Privacy & Security → Open Anyway.

Windows — baixe o poly-setup.exe, execute-o. Instala em %LOCALAPPDATA%\Poly e o adiciona ao seu PATH de usuário (sem necessidade de direitos de administrador). Ele não é assinado, então o SmartScreen avisará — "Mais informações" → "Executar mesmo assim". (Compilado multiplataforma via NSIS; ainda não verificado em uma máquina Windows real — por favor, reporte problemas.)

A partir do código-fonte (qualquer SO, requer Go 1.21+):

git clone https://github.com/opencorp2030-ctrl/poly.git
cd poly
go build -o poly .
./poly version           # sanity check: runs the binary in place

# put it on PATH, e.g.:
cp poly /opt/homebrew/bin/poly   # macOS (Homebrew's bin, no sudo needed)
# or: sudo cp poly /usr/local/bin/poly       # macOS/Linux, needs sudo
# or: add this folder to PATH yourself

poly version              # now works from anywhere

Recompile os instaladores você mesmo com VERSION=x.y.z installers/build.sh (requer makensis para o do Windows: brew install makensis).

Compile cruzado para outro SO/arquitetura com GOOS/GOARCH, ou execute scripts/build-all.sh para compilar todos os cinco alvos (darwin/linux/windows × amd64/arm64) em dist/.

🖥️ Poly Desktop — agora disponível para Windows

Poly Desktop é um aplicativo desktop nativo para gerenciar sua conta Poly sem navegador: publique e edite aplicativos com uma prévia ao vivo da listagem na loja, pesquise/instale/remova pacotes através do CLI real, navegue pela comunidade e pela loja pública de aplicativos, notificações reais com alertas nativos do SO e um seletor completo de tema/cor de destaque.

⬇ Baixe o Poly Desktop para Windows — execute o instalador, sem necessidade de direitos de administrador. Entra com a mesma conta que o poly login no CLI.

As versões para macOS e Linux estão chegando muito em breve. O Windows sai primeiro porque foi o que foi testado de ponta a ponta; o aplicativo em si é Electron/Node simples, então as outras plataformas estão a um passo de empacotamento. Marque o repositório com estrela/observação para saber quando chegarem.

Como funciona a resolução de pacotes

poly install <name> tenta o Search de cada adaptador em ordem — tap → brew → pip → npm → cargo → go — e instala através do primeiro que informar que o pacote existe. Force um backend específico com um prefixo:

Comando	Resolve para
poly install ripgrep	primeira correspondência: tap → brew → pip → npm → cargo → go
poly install tap:ripgrep	download binário forçado da fórmula do tap
poly install brew:wget	brew install wget forçado
poly install pip:requests	pip install requests forçado
poly install npm:lodash	npm install -g lodash forçado
poly install cargo:ripgrep	cargo install ripgrep forçado
poly install go:golang.org/x/tools/cmd/goimports	go install <module>@latest forçado
poly install gem:rails	gem install rails forçado
poly install apt:ripgrep	apt-get install ripgrep forçado (Debian/Ubuntu)
poly install dnf:ripgrep	dnf install ripgrep forçado (Fedora/RHEL)
poly install pacman:ripgrep	pacman -S ripgrep forçado (Arch)
poly install winget:BurntSushi.ripgrep	winget install --exact forçado (Windows)
poly install choco:ripgrep	choco install ripgrep forçado (Windows)

gem, apt, dnf, pacman, winget e choco são apenas com prefixo explícito, como community e gh abaixo — nunca resolvidos automaticamente, então um pacote do sistema ou uma gem de linguagem única não pode silenciosamente sombrear a cadeia tap/brew/pip/npm/cargo/go.

Acrescente @version para fixar: poly install requests@2.31.0. pip, npm e cargo repassam isso diretamente; o adaptador tap só oferece a versão fixada em sua fórmula e gera erro se você pedir uma diferente; go trata isso como a versão/tag do módulo.

Comandos

Comando	Função
poly install [[adapter:]name[@version] ...]	instala pacotes, roteados automaticamente ou forçados; sem argumentos, instala a partir de poly.json
poly remove name	desinstala, através do adaptador que instalou
poly list	mostra tudo o que o poly instalou e através do quê
poly search [adapter:]name	verifica existência e versão mais recente entre adaptadores
poly info [adapter:]name	versão, resumo, página inicial e status de instalação, por adaptador
poly init	escreve poly.json a partir dos seus pacotes atualmente instalados
poly upgrade	atualiza cada pacote instalado para a versão mais recente do adaptador
poly self-update	atualiza o próprio binário do poly para o lançamento mais recente do GitHub
poly account	mostra seu e-mail/nome de usuário/bio/plano conectados
poly login / poly logout	entra/sai da sua conta Poly (desbloqueia o Pro)
poly version	imprime a versão de compilação do poly e, se conectado, sua conta/plano

O estado fica em ~/.poly/manifest.json. Os binários do tap ficam em ~/.poly/bin (adicione-o ao seu PATH). As credenciais de login ficam em ~/.poly/credentials.json (modo 0600). poly self-update e, para contas Pro, poly upgrade também são executados automaticamente em segundo plano (limitados a ~uma vez/dia, registrados em ~/.poly/auto-update.log) para que você não precise lembrar de executá-los.

Instalações reproduzíveis com poly.json

poly init escreve um poly.json no diretório atual listando cada pacote que o poly instalou, fixado na versão exata:

{
  "packages": [
    "tap:ripgrep@15.1.0",
    "npm:eslint@9.2.0",
    "pip:requests@2.31.0"
  ]
}

Faça o commit e qualquer pessoa (ou qualquer máquina de CI) pode reproduzir o mesmo conjunto com um simples poly install — sem necessidade de argumentos.

Poly Pro

O Poly é e continuará sendo 100% gratuito e de código aberto — todo o catálogo integrado do tap (ripgrep, fd, jq, ...) também é gratuito, de propósito: o Pro não é sobre reter ferramentas que as pessoas esperam gratuitas. O único benefício real e mensurável hoje:

• poly install a b c (vários pacotes em um comando) os instala sequencialmente no plano gratuito; conectado com um plano Pro ativo (poly login), o mesmo comando os instala concorrentemente, e poly upgrade é executado automaticamente em segundo plano em vez de apenas sob demanda.

Gerencie sua conta (cadastre-se, verifique seu plano) em poly.candygate.eu/account.html, com suporte do Supabase Auth — veja internal/account/account.go para a lógica do lado do cliente e a tabela public.profiles para onde o status do plano fica.

Adaptadores

• pip — executa pip3/pip, transmitindo a saída ao vivo para que você veja o progresso do download do próprio pip. A busca usa a API JSON do PyPI (pypi.org/pypi/<name>/json), uma consulta por nome exato — o PyPI não tem mais API pública de busca por texto livre.
• npm — executa npm install -g, com a mesma saída transmitida ao vivo. A busca usa registry.npmjs.org/<name>/latest.
• brew — executa um brew install/brew uninstall local, com a mesma saída transmitida ao vivo. A busca usa o formulae.brew.sh/api/formula/<name>.json público, então funciona mesmo sem o brew instalado (apenas a instalação real precisa dele).
• cargo — executa cargo install --force/cargo uninstall. A busca usa a API pública crates.io/api/v1/crates/<name>.
• go — executa go install <module>@version. Os pacotes aqui são caminhos completos de importação de módulos, não nomes curtos (ex.: golang.org/x/tools/cmd/goimports), então este é realisticamente usado apenas via um prefixo explícito go:. A busca percorre o caminho para cima contra o proxy público de módulos Go até encontrar o módulo que contém, a mesma resolução que o go install faz internamente.
• tap — instala binários pré-compilados diretamente de uma URL fixada, com uma barra de progresso ao vivo em bytes durante o download, verificados contra um checksum SHA-256, depois extraídos (.tar.gz/.zip) ou copiados para ~/.poly/bin. Sem necessidade de Python, Node, Rust ou Homebrew.
• gem — executa um gem install/gem uninstall local. A busca usa a API pública rubygems.org/api/v1/gems/<name>.json. Apenas com prefixo explícito gem:, como cargo/go.
• apt — executa um apt-get install/apt-get remove local no Debian/Ubuntu. A busca lê a saída local do apt-cache show, sem chamada de rede necessária. Apenas com prefixo explícito apt: — resolver automaticamente um nome simples para um pacote do sistema seria uma surpresa no Linux.
• dnf — mesma ideia no Fedora/RHEL, via dnf install/dnf remove e dnf info. Apenas com prefixo explícito dnf:.
• pacman — mesma ideia no Arch, via pacman -S/pacman -R e pacman -Si contra os repositórios sincronizados (não o AUR). Apenas com prefixo explícito pacman:; o pacman não tem uma forma integrada de fixar uma versão arbitrária dos repositórios regulares, então fixações de versão são rejeitadas.
• winget — executa um winget install --exact/winget uninstall on Windows. Search reads local winget show --exact local. Apenas com prefixo explícito winget:.
• choco — executa um choco install/choco uninstall (Chocolatey) local no Windows. A busca lê a saída local choco search --exact --limit-output output. Explicit choco: — apenas com prefixo.

Adicionando uma fórmula de tap

Coloque um arquivo YAML em ~/.poly/taps/<name>.yaml (isso substitui qualquer fórmula integrada de mesmo nome — veja internal/registry/embedded/taps para as que acompanham o poly):

name: ripgrep
description: "Line-oriented search tool that recursively searches directories for a regex pattern"
homepage: "https://github.com/BurntSushi/ripgrep"
version: "15.1.0"
binary: rg
tier: free   # omit for free, or "pro" to gate it behind an active Pro plan
artifacts:
  darwin_arm64:
    url: "https://github.com/BurntSushi/ripgrep/releases/download/15.1.0/ripgrep-15.1.0-aarch64-apple-darwin.tar.gz"
    sha256: "378e973289176ca0c6054054ee7f631a065874a352bf43f0fa60ef079b6ba715"
  darwin_amd64: { url: "...", sha256: "..." }
  linux_amd64: { url: "...", sha256: "..." }
  linux_arm64: { url: "...", sha256: "..." }
  windows_amd64: { url: "...", sha256: "..." }

A chave do artefato é <GOOS>_<GOARCH>. poly install <name> escolhe a entrada correspondente à máquina em que está sendo executado. Fórmulas integradas hoje, todas gratuitas: ripgrep, fd, jq — veja internal/registry/embedded/taps.

Estrutura do projeto

main.go                          entrypoint
cmd/                              cobra commands (install, upgrade, init, info, account, self-update, ...)
internal/manifest/                ~/.poly/manifest.json read/write
internal/lockfile/                poly.json read/write
internal/adapters/                Adapter interface + pip, npm, brew, cargo, go, tap, gem, apt, dnf, pacman, winget, choco implementations
internal/registry/embedded/       tap formulas built into the binary
internal/account/                 Supabase Auth client (login/plan/profile)
internal/selfupdate/              downloads + verifies + replaces the poly binary
installers/                       macOS .pkg and Windows .exe installer sources
site/                             marketing site, docs, account, community pages
scripts/build-all.sh              cross-platform release build

Status

Funcionando: instalar/remover/listar/buscar/info/atualizar/init em pip, npm, brew, cargo, go, tap, gem, apt, dnf, pacman, winget e choco; fixação de versão (onde o backend suporta); auto-atualização e (Pro) atualizações automáticas de pacotes; instaladores para macOS/Windows; um sistema de contas com suporte do Supabase com um diretório da comunidade. Ainda não construído: instaladores assinados/notarizados e uma interface de busca de pacotes cobrindo o catálogo completo de cada adaptador (em vez de consultas por nome exato).