Un período de enfriamiento de 3 días significa que cuando `lodash` publique la versión `4.18.0`, tus builds seguirán usando `4.17.21` hasta que hayan pasado 3 días. Si la nueva versión resulta estar comprometida, nunca estuviste expuesto.

Orden de resolución: override del paquete, luego override del ecosistema, luego el valor predeterminado global. Esto te permite establecer un valor predeterminado conservador y crear excepciones para paquetes donde necesites actualizaciones más rápidas. Consulta [docs/configuration.md](https://github.com/git-pkgs/proxy/blob/main/docs/configuration.md) para la referencia completa de configuración.

## Registros Compatibles

| Registro | Lenguaje/Plataforma | Enfriamiento | Completado |
|----------|-------------------|:--------:|:---------:|
| npm | JavaScript | Sí | ✓ |
| Cargo | Rust | Sí | ✓ |
| RubyGems | Ruby | Sí | ✓ |
| Go proxy | Go | | ✓ |
| Hex | Elixir | Sí* | ✓ |
| pub.dev | Dart | Sí | ✓ |
| PyPI | Python | Sí | ✓ |
| Maven | Java | | ✓ |
| Gradle Build Cache | Java/Kotlin | | ✓ |
| NuGet | .NET | Sí | ✓ |
| Composer | PHP | Sí | ✓ |
| Conan | C/C++ | | ✓ |
| Conda | Python/R | Sí | ✓ |
| CRAN | R | | ✓ |
| Julia | Julia | | ✓ |
| Container | Docker/OCI | | ✓ |
| Debian | Debian/Ubuntu | | ✓ |
| RPM | RHEL/Fedora | | ✓ |
| Alpine | Alpine Linux | | ✗ |
| Arch | Arch Linux | | ✗ |
| Chef | Chef | | ✗ |
| Generic | Cualquiera | | ✗ |
| Helm | Kubernetes | | ✗ |
| Swift | Swift | | ✗ |
| Vagrant | Vagrant | | ✗ |

El enfriamiento requiere marcas de tiempo de publicación en los metadatos. Los registros sin un "Sí" en la columna de enfriamiento o no exponen marcas de tiempo o aún no se han conectado.

\* El enfriamiento de Hex requiere deshabilitar la verificación de firma del registro (`HEX_NO_VERIFY_REPO_ORIGIN=1`) ya que el proxy re-codifica la carga útil de protobuf.

## Instalación```bash
brew install git-pkgs/git-pkgs/proxy

El proxy ahora está en ejecución. Configura tus gestores de paquetes para usarlo.

## OpenAPI (Swagger)

Este repositorio utiliza swaggo para generar una especificación OpenAPI a partir de los handlers anotados.

Genera la especificación:```bash
go install github.com/swaggo/swag/cmd/swag@latest
go generate ./internal/server

Or establece por proyecto en `.npmrc`:```
registry=http://localhost:8080/npm/

### Cargo

Crea o edita `~/.cargo/config.toml`:```toml
[source.crates-io]
replace-with = "proxy"

[source.proxy]
registry = "sparse+http://localhost:8080/cargo/"

O configurar globalmente:```bash
gem sources --add http://localhost:8080/gem/
bundle config mirror.https://rubygems.org http://localhost:8080/gem

Or in your shell profile for persistence.

### Hex (Elixir)

Configure in `~/.hex/hex.config`:```erlang
{default_url, <<"http://localhost:8080/hex">>}.

### pub.dev (Dart/Flutter)

Establece la variable de entorno PUB_HOSTED_URL:```bash
export PUB_HOSTED_URL=http://localhost:8080/pub

Or establezca en `~/.pip/pip.conf`:```ini
[global]
index-url = http://localhost:8080/pypi/simple/

El endpoint `/maven/` utiliza Maven Central como upstream principal y recurre al Gradle Plugin Portal para los metadatos de marcadores de plugins de Gradle y los artefactos relacionados cuando el upstream principal devuelve un "no encontrado".

Para la resolución de plugins de Gradle a través del mismo endpoint de proxy:```kotlin
pluginManagement {
  repositories {
    maven(url = "http://localhost:8080/maven/")
  }
}

### NuGet

Configura en `nuget.config`:```xml
<configuration>
  <packageSources>
    <clear />
    <add key="proxy" value="http://localhost:8080/nuget/v3/index.json" />
  </packageSources>
</configuration>

### Composer (PHP)

Configúralo en `composer.json`:```json
{
    "repositories": [
        {
            "type": "composer",
            "url": "http://localhost:8080/composer"
        }
    ]
}

### Conan (C/C++)

Añade el proxy como remoto:```bash
conan remote add proxy http://localhost:8080/conan
conan remote disable conancenter

O configúralo mediante el comando:```bash
conda config --add channels http://localhost:8080/conda/main

Or in `~/.Rprofile` para persistencia:```r
local({
  r <- getOption("repos")
  r["CRAN"] <- "http://localhost:8080/cran"
  options(repos = r)
})

O dentro de una sesión en ejecución:```julia
ENV["JULIA_PKG_SERVER"] = "http://localhost:8080/julia"
using Pkg; Pkg.update()

Entonces reinicia Docker:```bash
sudo systemctl restart docker

### Helm

Configura cada repositorio de charts HTTP con un nombre y, a continuación, añade la URL del proxy correspondiente a Helm:```yaml
upstream:
  helm:
    bitnami: "https://charts.bitnami.com/bitnami"

## 🛡️ Características

- **Escaneo de puertos**: Escaneo rápido y completo de puertos TCP/UDP.
- **Detección de servicios**: Identifica versiones de servicios y sistemas operativos.
- **Detección de vulnerabilidades**: Comprueba vulnerabilidades conocidas (CVE) y configuraciones incorrectas.
- **Fuerza bruta**: Soporta ataques de fuerza bruta contra servicios como SSH, FTP, HTTP, etc.
- **Informes**: Genera informes detallados en varios formatos (HTML, PDF, JSON).
- **Interfaz de línea de comandos**: Interfaz fácil de usar con opciones de línea de comandos.
- **Modo silencioso**: Ejecución silenciosa para evitar la detección.
- **Multihilo**: Escaneo rápido mediante el uso de múltiples hilos.
- **Actualizaciones**: Actualización automática de la base de datos de vulnerabilidades.
- **Compatibilidad**: Funciona en Windows, Linux y macOS.
``````bash
helm repo add bitnami http://localhost:8080/helm/bitnami
helm repo update
helm pull bitnami/nginx

# Instalación

## Requisitos previos

- Python 3.8 o superior
- pip (gestor de paquetes de Python)

## Instalación desde PyPI

Puedes instalar la herramienta directamente desde PyPI usando pip:

```bash
pip install kitploit-tool

git clone https://github.com/example/kitploit-tool.git
cd kitploit-tool
pip install -r requirements.txt

kitploit-tool --version

### Debian / APT

Configura APT para usar el proxy en `/etc/apt/sources.list.d/proxy.list`:```
deb http://localhost:8080/debian stable main contrib

El valor predeterminado de upstream es `http://deb.debian.org/debian`. Para usar un proxy con un repositorio APT diferente (por ejemplo, Ubuntu), establece `upstream.debian` en el archivo de configuración o `PROXY_UPSTREAM_DEBIAN` en el entorno:```yaml
upstream:
  debian: "http://archive.ubuntu.com/ubuntu"

Entonces:```bash
sudo dnf clean all
sudo dnf update

### Variables de Entorno```bash
PROXY_LISTEN=:8080
PROXY_BASE_URL=http://localhost:8080
PROXY_UI_URL=http://localhost:8080  # Optional; defaults to PROXY_BASE_URL
PROXY_STORAGE_URL=file:///var/cache/proxy/artifacts
PROXY_DATABASE_DRIVER=sqlite
PROXY_DATABASE_PATH=./cache/proxy.db
PROXY_DATABASE_URL=postgres://user:pass@localhost/proxy?sslmode=disable
PROXY_LOG_LEVEL=info
PROXY_LOG_FORMAT=text
PROXY_ACCESS_LOG_PATH=/var/log/proxy/access.jsonl

Consulta la [referencia de configuración](https://github.com/git-pkgs/proxy/blob/main/docs/configuration.md#upstream-registries) para conocer cada clave de upstream, variable de entorno y URL predeterminada.

Ejecutar con archivo de configuración:```bash
./proxy -config /etc/proxy/config.yaml

O mediante variables de entorno:```bash
PROXY_DATABASE_DRIVER=postgres
PROXY_DATABASE_URL=postgres://user:password@localhost:5432/proxy?sslmode=disable

Para servicios compatibles con S3 como MinIO:```yaml
storage:
  url: "s3://my-bucket?endpoint=http://localhost:9000&disableSSL=true&s3ForcePathStyle=true"

La autenticación utiliza [Credenciales predeterminadas de la aplicación](https://docs.cloud.google.com/docs/authentication/application-default-credentials), lo que significa que no es necesario incrustar credenciales en la configuración ni en el entorno. Las fuentes compatibles, en orden:

- **GKE Workload Identity** — vincula la cuenta de servicio de Kubernetes que ejecuta el proxy a una cuenta de servicio de Google que tenga `roles/storage.objectAdmin` en el bucket. El proxy utilizará automáticamente el token de la carga de trabajo.
- **Cuenta de servicio adjunta** en GCE, Cloud Run, Cloud Functions, etc.
- **Variable de entorno `GOOGLE_APPLICATION_CREDENTIALS`** que apunta a un archivo de clave JSON de cuenta de servicio.
- **`gcloud auth application-default login`** para desarrollo local.

#### Configuración de GKE Workload Identity```bash
# 1. Create a Google service account
gcloud iam service-accounts create git-pkgs-proxy \
  --project=PROJECT_ID

# 2. Grant it access to the bucket
gsutil iam ch \
  serviceAccount:git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com:objectAdmin \
  gs://my-bucket-name

# 3. Bind the Kubernetes service account to it
gcloud iam service-accounts add-iam-policy-binding \
  git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.workloadIdentityUser \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"

# 4. Annotate the Kubernetes service account
kubectl annotate serviceaccount KSA_NAME \
  --namespace=NAMESPACE \
  iam.gke.io/gcp-service-account=git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com

## Comandos CLI

### serve (predeterminado)

Inicia el servidor proxy. Este es el comando predeterminado si no se especifica ninguno.```bash
proxy serve [flags]
proxy [flags]  # same as 'proxy serve'

El comando mirror acepta los mismos flags de almacenamiento y base de datos que `serve`. Los artefactos ya almacenados en caché se omiten.

También hay una API de mirror disponible cuando el servidor está en ejecución:```bash
# Start a mirror job
curl -X POST http://localhost:8080/api/mirror \
  -H "Content-Type: application/json" \
  -d '{"purls": ["pkg:npm/[email protected]"]}'

# Check job status
curl http://localhost:8080/api/mirror/mirror-1

# Cancel a running job
curl -X DELETE http://localhost:8080/api/mirror/mirror-1

Ejemplo de salida:```
Cache Statistics
================

Packages:   45
Versions:   128
Artifacts:  128
Total size: 892.4 MB
Total hits: 1547

Packages by ecosystem:
  npm        32
  cargo      13

Most popular packages:
   1. npm/lodash (342 hits, 24.7 KB)
   2. npm/react (198 hits, 89.3 KB)
   3. cargo/serde (156 hits, 234.1 KB)

Recently cached:
  npm/[email protected] (2024-01-15 14:32, 54.2 KB)
  cargo/[email protected] (2024-01-15 14:28, 412.8 KB)

## Instalación

```bash
# Clonar el repositorio
git clone https://github.com/yourusername/yourproject.git

# Navegar al directorio
cd yourproject

# Instalar dependencias
pip install -r requirements.txt

python main.py --help

#### Obtener Versión con Vulnerabilidades```bash
curl http://localhost:8080/api/package/npm/lodash/4.17.0

## Instalación

### Requisitos previos

- Python 3.8 o superior
- pip (gestor de paquetes de Python)

### Instalación desde PyPI

```bash
pip install kitploit-tool

git clone https://github.com/example/kitploit-tool.git
cd kitploit-tool
pip install -r requirements.txt
python setup.py install

kitploit-tool --help
kitploit-tool scan --target example.com
kitploit-tool report --format json

# Configuración de ejemplo
target: example.com
timeout: 30
verbose: true

kitploit-tool scan --target example.com --verbose

kitploit-tool report --format html --output report.html

{
  "package": {
    "ecosystem": "npm",
    "name": "lodash",
    "latest_version": "4.17.21",
    "license": "MIT",
    "license_category": "permissive"
  },
  "version": {
    "ecosystem": "npm",
    "name": "lodash",
    "version": "4.17.0",
    "license": "MIT",
    "published_at": "2016-06-17T03:59:56Z",
    "yanked": false,
    "is_outdated": true
  },
  "vulnerabilities": [
    {
      "id": "GHSA-p6mc-m468-83gw",
      "summary": "Prototype Pollution in lodash",
      "severity": "HIGH",
      "cvss_score": 7.4,
      "fixed_version": "4.17.12"
    }
  ],
  "is_outdated": true,
  "license_category": "permissive"
}
```
#### Comprobar Paquetes Desactualizados```bash
curl -X POST http://localhost:8080/api/outdated \
  -H "Content-Type: application/json" \
  -d '{
    "packages": [
      {"ecosystem": "npm", "name": "lodash", "version": "4.17.0"},
      {"ecosystem": "pypi", "name": "requests", "version": "2.25.0"}
    ]
  }'
```
The `--no-verify` flag is used to skip the verification of the certificate. This is useful when you are using a self-signed certificate or when you want to test the connection without verifying the certificate.```json
{
  "results": [
    {
      "ecosystem": "npm",
      "name": "lodash",
      "version": "4.17.0",
      "latest_version": "4.17.21",
      "is_outdated": true
    },
    {
      "ecosystem": "pypi",
      "name": "requests",
      "version": "2.25.0",
      "latest_version": "2.31.0",
      "is_outdated": true
    }
  ]
}
```
#### Búsqueda Masiva de Paquetes```bash
curl -X POST http://localhost:8080/api/bulk \
  -H "Content-Type: application/json" \
  -d '{
    "purls": [
      "pkg:npm/[email protected]",
      "pkg:pypi/[email protected]"
    ]
  }'
```
```
## Instalación

### Requisitos previos

- Python 3.8 o superior
- pip (gestor de paquetes de Python)

### Instalación desde PyPI

```bash
pip install kitploit-tool
```

### Instalación desde el código fuente

```bash
git clone https://github.com/example/kitploit-tool.git
cd kitploit-tool
pip install -r requirements.txt
python setup.py install
```

## Uso

### Uso básico

```bash
kitploit-tool --target example.com
```

### Opciones disponibles

| Opción | Descripción |
|--------|-------------|
| `--target` | Especifica el dominio o la dirección IP de destino |
| `--verbose` | Habilita la salida detallada |
| `--output` | Especifica el archivo de salida para los resultados |
| `--threads` | Define el número de hilos a utilizar (por defecto: 10) |
| `--timeout` | Establece el tiempo de espera en segundos (por defecto: 30) |

### Ejemplos

Escaneo básico con salida detallada:

```bash
kitploit-tool --target example.com --verbose
```

Guardar los resultados en un archivo:

```bash
kitploit-tool --target example.com --output results.txt
```

## Configuración

La herramienta se puede configurar mediante un archivo de configuración ubicado en `~/.kitploit/config.yaml`. A continuación se muestra un ejemplo de configuración:

```yaml
# Archivo de configuración de ejemplo
target:
  default_timeout: 30
  max_threads: 20

output:
  format: json
  directory: ./results

logging:
  level: INFO
  file: kitploit.log
```

## Documentación de la API

### Clase `Scanner`

La clase principal para realizar escaneos.

```python
from kitploit import Scanner

scanner = Scanner(target="example.com")
results = scanner.run()
```

#### Métodos

- `run()`: Ejecuta el escaneo y devuelve los resultados.
- `stop()`: Detiene el escaneo en curso.
- `get_status()`: Devuelve el estado actual del escaneo.

### Clase `Report`

Maneja la generación y exportación de informes.

```python
from kitploit import Report

report = Report(results)
report.save("report.html")
```

## Solución de problemas

### Error de conexión

Si encuentras errores de conexión, verifica tu conexión de red y asegúrate de que el destino sea accesible.

### Error de permisos

Si encuentras errores de permisos al instalar, intenta usar `pip install --user` o ejecuta el comando con privilegios de administrador.

### Problemas de dependencias

Si tienes conflictos de dependencias, crea un entorno virtual:

```bash
python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate
pip install -r requirements.txt
```

## Preguntas frecuentes

**P: ¿La herramienta es compatible con IPv6?**

R: Sí, la herramienta admite direcciones IPv4 e IPv6.

**P: ¿Puedo usar la herramienta con fines comerciales?**

R: Sí, la herramienta tiene licencia MIT y se puede usar libremente con fines comerciales.

**P: ¿Cómo puedo contribuir al proyecto?**

R: Consulta la guía de contribución en el repositorio de GitHub.

## Licencia

Este proyecto está licenciado bajo la Licencia MIT. Consulta el archivo [LICENSE](https://github.com/git-pkgs/proxy/blob/main/LICENSE) para obtener más detalles.

## Agradecimientos

- A todos los contribuyentes del proyecto
- A la comunidad de seguridad de código abierto
- A los mantenedores de las bibliotecas utilizadas

## Contacto

Para preguntas o comentarios, abre un problema en el repositorio de GitHub o contacta al equipo de desarrollo en [email protected].
``````json
{
  "packages": {
    "pkg:npm/lodash": {
      "ecosystem": "npm",
      "name": "lodash",
      "latest_version": "4.17.21",
      "license": "MIT",
      "license_category": "permissive"
    },
    "pkg:pypi/requests": {
      "ecosystem": "pypi",
      "name": "requests",
      "latest_version": "2.31.0",
      "license": "Apache-2.0",
      "license_category": "permissive"
    }
  }
}
```
### Respuesta de estadísticas (endpoint HTTP)```json
{
  "cached_artifacts": 142,
  "total_size_bytes": 523456789,
  "total_size": "499.2 MB",
  "storage_url": "file:///path/to/cache/artifacts",
  "database_path": "./cache/proxy.db"
}
```
## Cómo Funciona

1. El gestor de paquetes solicita los metadatos del paquete al proxy
2. El proxy obtiene los metadatos del upstream, reescribe las URL de los artefactos para que apunten al proxy
3. El gestor de paquetes solicita el artefacto (tarball, crate, etc.)
4. El proxy verifica la caché local:
   - **Acierto de caché**: Sirve desde el almacenamiento local
   - **Fallo de caché**: Obtiene del upstream, almacena localmente, sirve al cliente
5. Las solicitudes posteriores del mismo artefacto se sirven desde la caché```
┌─────────────┐     ┌─────────┐     ┌──────────┐
│   npm/cargo │────▶│  proxy  │────▶│ upstream │
│   client    │◀────│         │◀────│ registry │
└─────────────┘     └─────────┘     └──────────┘
                         │
                         ▼
                    ┌─────────┐
                    │  cache  │
                    │ storage │
                    └─────────┘
```
## Interfaz Web

El proxy sirve una interfaz web en `/ui`. No se necesita una compilación de frontend separada: las plantillas y los recursos están incrustados en el binario. `GET /` redirige a `/ui/`. La interfaz está montada bajo su propio prefijo, de modo que un proxy inverso puede aplicar reglas de acceso diferentes a las de los endpoints de paquetes (por ejemplo, exigir autenticación para `PathPrefix(/ui)` mientras se dejan `/npm`, `/pypi`, etc. abiertos para las máquinas de compilación).

- **Panel de control** (`/ui/`) -- estadísticas de caché, paquetes populares, artefactos recientemente almacenados en caché y resumen de vulnerabilidades.
- **Guía de instalación** (`/ui/install`) -- instrucciones de configuración por ecosistema, para que no tengas que buscarlas aquí.
- **Explorador de paquetes** (`/ui/packages`) -- explora todos los paquetes en caché con filtrado por ecosistema y ordenación por aciertos, tamaño, nombre o número de vulnerabilidades.
- **Búsqueda** (`/ui/search?q=...`) -- busca paquetes en caché por nombre.
- **Detalle del paquete** (`/ui/package/{ecosystem}/{name}`) -- metadatos, licencia, vulnerabilidades y lista de versiones de un paquete. Puedes seleccionar dos versiones para compararlas.
- **Detalle de versión** (`/ui/package/{ecosystem}/{name}/{version}`) -- metadatos por versión, hash de integridad, estado de caché del artefacto y recuentos de aciertos.
- **Explorador de fuentes** (`/ui/package/{ecosystem}/{name}/{version}/browse`) -- explora archivos dentro de los archivos en caché con resaltado de sintaxis para archivos de texto y vistas previas de imágenes.
- **Diff de versiones** (`/ui/package/{ecosystem}/{name}/compare/{v1}...{v2}`) -- diff lado a lado de dos versiones en caché que muestra archivos añadidos, eliminados y modificados.

## Monitorización

El proxy expone métricas de Prometheus en `GET /metrics`. Todos los nombres de métricas llevan el prefijo `proxy_`.

| Métrica | Tipo | Etiquetas | Descripción |
|--------|------|--------|-------------|
| `proxy_requests_total` | contador | `ecosystem`, `status` | Respuestas del proxy por ecosistema de paquetes y estado HTTP |
| `proxy_request_duration_seconds` | histograma | `ecosystem`, `status` | Duración de las solicitudes del proxy |
| `proxy_cache_hits_total` | contador | `ecosystem` | Aciertos de caché |
| `proxy_cache_misses_total` | contador | `ecosystem` | Fallos de caché |
| `proxy_cache_size_bytes` | gauge | | Tamaño total de los artefactos en caché |
| `proxy_cached_artifacts_total` | gauge | | Número de artefactos en caché |
| `proxy_upstream_fetch_duration_seconds` | histograma | `ecosystem` | Tiempo dedicado a la obtención desde el upstream |
| `proxy_upstream_errors_total` | contador | `ecosystem`, `error_type` | Fallos de obtención del upstream |
| `proxy_storage_operation_duration_seconds` | histograma | `operation` | Latencia de lectura/escritura del almacenamiento |
| `proxy_storage_errors_total` | contador | `operation` | Fallos de lectura/escritura del almacenamiento |
| `proxy_active_requests` | gauge | | Solicitudes en curso |
| `proxy_health_probe_failures_total` | contador | `step` | Fallos de la sonda de salud del almacenamiento por paso fallido (`write`, `size`, `read`, `verify`, `delete`). |

El tamaño de la caché y el recuento de artefactos se actualizan cada 60 segundos. Las métricas restantes se actualizan en cada solicitud.

### Comprobación de Salud

`/health` devuelve un informe JSON estructurado del estado de los subsistemas. HTTP 200 si todas las comprobaciones pasan; 503 si alguna falla.```json
{
  "status": "ok",
  "checks": {
    "database": {"status": "ok"},
    "storage":  {"status": "ok"}
  }
}
```
Los checks que fallan incluyen un campo `"error"`. Los fallos de almacenamiento también incluyen un campo `"step"` que identifica qué paso de la sonda falló (`write`, `size`, `read`, `verify`, `delete`). Cuando el check de la base de datos falla, la entrada de almacenamiento reporta `{"status": "skipped"}` para que la respuesta siempre lleve el mismo conjunto de claves.

Los resultados de las sondas de almacenamiento se cachean durante `health.storage_probe_interval` (por defecto 30s) para acotar el coste de sondear backends remotos. Una sonda mantiene un mutex interno durante hasta 10 segundos (el timeout por sonda hardcodeado), por lo que `/health` está pensado como una sonda de **readiness** de Kubernetes más que como una sonda de liveness — un round-trip lento de S3 debería sacar el pod de la rotación, no reiniciarlo.

Config de scrape para Prometheus:```yaml
scrape_configs:
  - job_name: git-pkgs-proxy
    static_configs:
      - targets: ["localhost:8080"]
```
## Despliegue en Producción

### Servicio Systemd

Crea `/etc/systemd/system/proxy.service`:```ini
[Unit]
Description=git-pkgs proxy
After=network.target

[Service]
Type=simple
User=proxy
ExecStart=/usr/local/bin/proxy -config /etc/proxy/config.yaml
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
```
Habilita e inicia:```bash
sudo systemctl enable proxy
sudo systemctl start proxy
```
### Docker

Se incluye un Dockerfile en el repositorio. Compila y ejecuta:```bash
docker build -t proxy .
docker run -p 8080:8080 -v proxy-data:/data proxy
```
Con Postgres y S3:```bash
docker run -p 8080:8080 \
  -e PROXY_DATABASE_DRIVER=postgres \
  -e PROXY_DATABASE_URL=postgres://user:pass@db:5432/proxy \
  -e PROXY_STORAGE_URL=s3://my-bucket?region=us-east-1 \
  -e AWS_ACCESS_KEY_ID=... \
  -e AWS_SECRET_ACCESS_KEY=... \
  proxy
```
### Detrás de un Proxy Inverso

Cuando se ejecuta detrás de nginx, Apache u otro proxy inverso, establece `base_url` a tu URL pública:```yaml
base_url: "https://proxy.example.com"
```
Si la interfaz de usuario se accede desde un nombre de host distinto al de los endpoints del paquete — por ejemplo, la interfaz expuesta públicamente en un dominio mientras las máquinas de compilación usan un alias de red de Docker — configura `ui_base_url` por separado. `base_url` es la URL que usan los gestores de paquetes y la reescritura de metadatos; `ui_base_url` es la URL que se anuncia a los humanos que visitan la interfaz web (etiquetas canónicas/`og:url` y el banner de la guía de instalación):```yaml
base_url: "http://pkg-proxy:8080"        # internal alias for build machines
ui_base_url: "https://proxy.example.com/ui"  # public UI URL
```
Cuando no se define, `ui_base_url` toma por defecto el valor de `base_url`.

> **Advertencia:** el proxy sirve la interfaz de usuario y los endpoints de paquetes en el mismo listener. Definir `ui_base_url` solo cambia la URL que la interfaz anuncia a los humanos; no impide que los endpoints de paquetes sigan siendo accesibles en el mismo hostname y puerto. Al exponer el proxy con un reverse proxy público, restringe la ruta pública a `PathPrefix(/ui)` (o su equivalente en tu proxy); de lo contrario, `/npm`, `/pypi` y los demás endpoints de paquetes permanecen expuestos junto a la interfaz.

Ejemplo de nginx, restringiendo el host público a la interfaz mientras los endpoints de paquetes permanecen accesibles solo en el listener interno:```nginx
server {
    listen 443 ssl;
    server_name proxy.example.com;

    location /ui/ {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_buffering off;
    }

    location / {
        return 404;
    }
}
```
Traefik example using `PathPrefix(/ui)` so the public router only matches UI traffic:```yaml
labels:
  traefik.enable: "true"
  traefik.http.services.pkg-proxy.loadbalancer.server.port: "8080"
  traefik.http.routers.pkg-proxy.rule: "Host(`proxy.example.com`) && PathPrefix(`/ui`)"
  traefik.http.routers.pkg-proxy.entrypoints: "websecure"
```
## Cache Management

El proxy almacena los artefactos en el directorio de almacenamiento configurado con esta estructura:```
cache/artifacts/
├── npm/
│   └── lodash/
│       └── 4.17.21/
│           └── lodash-4.17.21.tgz
├── cargo/
│   └── serde/
│       └── 1.0.193/
│           └── serde-1.0.193.crate
├── oci/
│   └── library/nginx/
│       └── sha256:abc123.../
│           └── sha256:abc123...
├── deb/
│   └── nginx/
│       └── 1.18.0-6/
│           └── nginx_1.18.0-6_amd64.deb
└── rpm/
    └── nginx/
        └── 1.24.0-1.fc39/
            └── nginx-1.24.0-1.fc39.x86_64.rpm
```
La metadatos de caché se almacenan en SQLite (por defecto) o PostgreSQL. Para limpiar una caché local:```bash
rm -rf ./cache/artifacts/*
rm ./cache/proxy.db
```
El proxy recreará la base de datos en el próximo inicio.

## Compilación desde el código fuente

Requisitos:

- Go (la versión del proyecto se declara en `go.mod`)```bash
git clone https://github.com/git-pkgs/proxy.git
cd proxy
go build -o proxy ./cmd/proxy
```
Ejecutar pruebas:```bash
go test ./...
```
## Licencia

GPL-3.0-o-posterior