Poly

poly

English · Français

Un comando, todos los gestores de paquetes. poly instala desde pip, npm, Homebrew y versiones binarias verificadas por checksum detrás de un único comando unificado, en macOS, Linux y Windows.

Sitio y gestión de cuentas: 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

Instalación

macOS — descarga poly-macos.pkg, ábrelo y sigue el instalador. Instala un binario universal (Intel + Apple Silicon) en /usr/local/bin/poly. No está firmado/notarizado (aún no tenemos cuenta de Apple Developer), por lo que Gatekeeper te avisará al abrirlo por primera vez: clic derecho → Abrir, o System Settings → Privacy & Security → Open Anyway.

Windows — descarga poly-setup.exe, y ejecútalo. Instala en %LOCALAPPDATA%\Poly y lo añade a tu PATH de usuario (no se necesitan derechos de administrador). No está firmado, por lo que SmartScreen te avisará: "Más información" → "Ejecutar de todos modos". (Compilado multiplataforma mediante NSIS; aún no verificado en una máquina Windows real: por favor, reporta problemas.)

Desde el código fuente (cualquier sistema operativo, requiere 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

Reconstruye los instaladores tú mismo con VERSION=x.y.z installers/build.sh (necesita makensis para el de Windows: brew install makensis).

Compila de forma cruzada para otro SO/arquitectura con GOOS/GOARCH, o ejecuta scripts/build-all.sh para compilar los cinco objetivos (darwin/linux/windows × amd64/arm64) en dist/.

🖥️ Poly Desktop — ya disponible para Windows

Poly Desktop es una aplicación de escritorio nativa para gestionar tu cuenta de Poly sin navegador: publica y edita aplicaciones con una vista previa en vivo del listado de la tienda, busca/instala/elimina paquetes a través del CLI real, explora la comunidad y la tienda pública de aplicaciones, notificaciones reales con alertas nativas del sistema operativo y un selector completo de tema/color de acento.

⬇ Descarga Poly Desktop para Windows — ejecuta el instalador, no se necesitan derechos de administrador. Inicia sesión con la misma cuenta que poly login en el CLI.

Las versiones para macOS y Linux llegarán muy pronto. Windows se publica primero porque es lo que se ha probado de principio a fin; la aplicación en sí es Electron/Node simple, por lo que las otras plataformas están a un paso de empaquetado. Marca con estrella/vigila el repositorio para saber cuándo llegan.

Cómo funciona la resolución de paquetes

poly install <name> prueba el Search de cada adaptador en orden — tap → brew → pip → npm → cargo → go — e instala a través del primero que informe de que el paquete existe. Fuerza un backend específico con un prefijo:

Comando	Resuelve a
poly install ripgrep	primera coincidencia: tap → brew → pip → npm → cargo → go
poly install tap:ripgrep	descarga binaria forzada desde la fórmula tap
poly install brew:wget	brew install wget forzado
poly install pip:requests	pip install requests forzado
poly install npm:lodash	npm install -g lodash forzado
poly install cargo:ripgrep	cargo install ripgrep forzado
poly install go:golang.org/x/tools/cmd/goimports	go install <module>@latest forzado
poly install gem:rails	gem install rails forzado
poly install apt:ripgrep	apt-get install ripgrep forzado (Debian/Ubuntu)
poly install dnf:ripgrep	dnf install ripgrep forzado (Fedora/RHEL)
poly install pacman:ripgrep	pacman -S ripgrep forzado (Arch)
poly install winget:BurntSushi.ripgrep	winget install --exact forzado (Windows)
poly install choco:ripgrep	choco install ripgrep forzado (Windows)

gem, apt, dnf, pacman, winget y choco son solo de prefijo explícito, como community y gh a continuación — nunca se resuelven automáticamente, por lo que un paquete del sistema o una gema de un solo lenguaje no puede sombrear silenciosamente la cadena tap/brew/pip/npm/cargo/go.

Añade @version para fijar: poly install requests@2.31.0. pip, npm y cargo lo pasan directamente; el adaptador tap solo ofrece la versión fijada en su fórmula y da error si pides una diferente; go lo trata como la versión/etiqueta del módulo.

Comandos

Comando	Función
poly install [[adapter:]name[@version] ...]	instala paquetes, con enrutado automático o forzado; sin argumentos instala desde poly.json
poly remove name	desinstala, mediante el adaptador que lo instaló
poly list	muestra todo lo que poly tiene instalado y a través de qué
poly search [adapter:]name	comprueba la existencia y la última versión en todos los adaptadores
poly info [adapter:]name	versión, resumen, página de inicio y estado de instalación, por adaptador
poly init	escribe poly.json a partir de tus paquetes actualmente instalados
poly upgrade	actualiza cada paquete instalado a la última versión de su adaptador
poly self-update	actualiza el propio binario de poly a la última versión de GitHub
poly account	muestra tu correo/nombre de usuario/bio/plan con sesión iniciada
poly login / poly logout	inicia/cierra sesión en tu cuenta de Poly (desbloquea Pro)
poly version	imprime la versión de compilación de poly y, si has iniciado sesión, tu cuenta/plan

El estado vive en ~/.poly/manifest.json. Los binarios tap van a ~/.poly/bin (añádelo a tu PATH). Las credenciales de inicio de sesión viven en ~/.poly/credentials.json (modo 0600). poly self-update y, para cuentas Pro, poly upgrade también se ejecutan automáticamente en segundo plano (limitados a ~una vez al día, registrados en ~/.poly/auto-update.log) para que no tengas que acordarte de ejecutarlos.

Instalaciones reproducibles con poly.json

poly init escribe un poly.json en el directorio actual que lista cada paquete que poly tiene instalado, fijado a su versión exacta:

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

Hazle commit y cualquiera (o cualquier máquina de CI) puede reproducir el mismo conjunto con un simple poly install — sin necesidad de argumentos.

Poly Pro

Poly es y seguirá siendo 100% gratuito y de código abierto — todo el catálogo tap integrado (ripgrep, fd, jq, ...) también es gratuito, a propósito: Pro no se trata de retener herramientas que la gente espera que sean gratuitas. La única ventaja real y medible hoy:

• poly install a b c (varios paquetes en un comando) los instala secuencialmente en el nivel gratuito; con sesión iniciada y un plan Pro activo (poly login), el mismo comando los instala concurrentemente, y poly upgrade se ejecuta automáticamente en segundo plano en lugar de solo bajo demanda.

Gestiona tu cuenta (regístrate, consulta tu plan) en poly.candygate.eu/account.html, respaldado por Supabase Auth — consulta internal/account/account.go para la lógica del lado del cliente y la tabla public.profiles para saber dónde vive el estado del plan.

Adaptadores

• pip — ejecuta pip3/pip, transmitiendo su salida en vivo para que veas el progreso de descarga de pip. La búsqueda usa la API JSON de PyPI (pypi.org/pypi/<name>/json), una consulta por nombre exacto — PyPI ya no tiene API de búsqueda pública de texto libre.
• npm — ejecuta npm install -g, con la misma salida transmitida en vivo. La búsqueda usa registry.npmjs.org/<name>/latest.
• brew — ejecuta un brew install/brew uninstall local, con la misma salida transmitida en vivo. La búsqueda usa el formulae.brew.sh/api/formula/<name>.json público, por lo que funciona incluso sin tener brew instalado (solo la instalación real lo necesita).
• cargo — ejecuta cargo install --force/cargo uninstall. La búsqueda usa la API pública de crates.io/api/v1/crates/<name>.
• go — ejecuta go install <module>@version. Los paquetes aquí son rutas completas de importación de módulos, no nombres cortos (p. ej. golang.org/x/tools/cmd/goimports), por lo que este se usa de forma realista solo mediante un prefijo explícito go:. La búsqueda recorre la ruta hacia arriba contra el proxy público de módulos de Go hasta encontrar el módulo contenedor, la misma resolución que go install hace internamente.
• tap — instala binarios precompilados directamente desde una URL fijada, con una barra de progreso de bytes en vivo durante la descarga, verificados contra un checksum SHA-256, y luego extraídos (.tar.gz/.zip) o copiados en ~/.poly/bin. No se necesitan Python, Node, Rust ni Homebrew.
• gem — ejecuta un gem install/gem uninstall local. La búsqueda usa la API pública de rubygems.org/api/v1/gems/<name>.json. Solo prefijo explícito gem:, como cargo/go.
• apt — ejecuta un apt-get install/apt-get remove local en Debian/Ubuntu. La búsqueda lee la salida local de apt-cache show, sin necesidad de llamada de red. Solo prefijo explícito apt: — resolver automáticamente un nombre simple a un paquete del sistema sería una sorpresa en Linux.
• dnf — la misma idea en Fedora/RHEL, mediante dnf install/dnf remove y dnf info. Solo prefijo explícito dnf:.
• pacman — la misma idea en Arch, mediante pacman -S/pacman -R y pacman -Si contra los repositorios sincronizados (no el AUR). Solo prefijo explícito pacman:; pacman no tiene forma integrada de fijar una versión arbitraria de los repositorios regulares, por lo que se rechazan las fijaciones de versión.
• winget — ejecuta un winget install --exact/winget uninstall on Windows. Search reads local winget show --exact de salida. Solo prefijo explícito winget:.
• choco — ejecuta un choco install/choco uninstall (Chocolatey) local en Windows. La búsqueda lee la salida local de choco search --exact --limit-output output. Explicit choco: solo prefijo.

Añadir una fórmula tap

Coloca un archivo YAML en ~/.poly/taps/<name>.yaml (esto anula cualquier fórmula integrada del mismo nombre — consulta internal/registry/embedded/taps para las que vienen con 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: "..." }

La clave del artefacto es <GOOS>_<GOARCH>. poly install <name> elige la entrada que coincide con la máquina en la que se ejecuta. Las fórmulas integradas hoy, todas gratuitas: ripgrep, fd, jq — consulta internal/registry/embedded/taps.

Estructura del proyecto

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

Estado

Funcionando: instalar/eliminar/listar/buscar/info/actualizar/init en pip, npm, brew, cargo, go, tap, gem, apt, dnf, pacman, winget y choco; fijación de versión (donde el backend lo soporta); autoactualización y (Pro) actualizaciones automáticas de paquetes; instaladores para macOS/Windows; un sistema de cuentas respaldado por Supabase con un directorio de comunidad. Aún no construido: instaladores firmados/notarizados y una interfaz de búsqueda de paquetes que cubra el catálogo completo de cada adaptador (en lugar de consultas por nombre exacto).