# yaml-language-server: $schema=https://schema.zeabur.app/template.json
apiVersion: zeabur.com/v1
kind: Template
metadata:
    name: OneCLI
spec:
    description: Open-source credential gateway and vault for AI agents. Store API keys once, inject them transparently when your agents make HTTP calls — they never see the real secrets.
    coverImage: https://raw.githubusercontent.com/onecli/onecli/main/assets/onecli-logo-dark.gif
    icon: https://avatars.githubusercontent.com/u/263660444?s=60&v=4
    variables:
        - key: PUBLIC_DOMAIN
          type: DOMAIN
          name: Domain
          description: Your OneCLI dashboard domain (auto-assigned by Zeabur, customizable)
        - key: GATEWAY_DOMAIN
          type: DOMAIN
          name: Gateway Domain
          description: Public domain for the OneCLI gateway (where AI agents send their HTTP requests). Auto-assigned by Zeabur; must be a separate subdomain from the dashboard domain.
    tags:
        - AI
        - Security
        - Vault
        - Credentials
        - AI Agents
        - Gateway
    readme: |-
        # OneCLI — Secret Vault for AI Agents (create by SEAFOODHOLDHAND)

        **OneCLI** is the open-source credential gateway that sits between your AI agents and the services they call. Store real API keys once in OneCLI's encrypted vault, give your agents placeholder keys (e.g. `FAKE_KEY`), and OneCLI's gateway injects the real credentials transparently on outbound requests — agents never see the real secrets.

        This template deploys a complete OneCLI instance with a single click.

        ## Architecture

        ```
        [Zeabur LB] → OneCLI App (single image, two processes)
                          ├─ :10254  → Next.js Web Dashboard (UI + API)
                          └─ :10255  → Rust Gateway (credential injection proxy)
        [PostgreSQL]   → OneCLI database (agents, secrets, audit logs)
        ```

        The OneCLI app image (`ghcr.io/onecli/onecli:latest`) bundles:
        - **Next.js web dashboard** on port 10254 (UI, agent management, secret management)
        - **Rust gateway** on port 10255 (transparent credential injection proxy)
        - **Prisma migrations** run automatically on container start
        - **Auto-generated SECRET_ENCRYPTION_KEY** persisted to `/app/data/` (AES-256-GCM)

        ## ⚠️ Read this before storing real credentials — Security

        By default this template deploys in **single-user / local mode: the dashboard opens with no login.** Anyone who can reach your dashboard domain can see and manage every stored API key. OneCLI is a **credential vault** — that makes the default unsafe to expose on the public internet.

        **Before storing any real secret, do ONE of the following:**

        1. **Lock the dashboard behind Google OAuth** — on the `onecli` service in the Zeabur Dashboard, set `NEXTAUTH_SECRET` + `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET` together (all three, then restart). See "Post-Deployment Configuration" below.
        2. **OR keep the dashboard on a private/non-public domain** (e.g. reachable only over VPN or from a private network), so only you can open it.

        The **Gateway Domain** (where agents send requests) is always public — that's fine, the gateway authenticates every call with a per-agent access token. The concern is only the **Dashboard Domain** in default local mode.

        > Why not just default to OAuth? OneCLI's auth is all-or-nothing: `NEXTAUTH_SECRET` set without Google credentials makes the dashboard redirect to a setup-error page. So local mode is the only working zero-input default; securing it is a deliberate one-time step you take after deploy.

        ## How It Works

        1. **Open the dashboard** at `https://your-domain.zeabur.app`
        2. **Create an agent** and get an access token
        3. **Store real API keys** in OneCLI's encrypted vault (e.g. OpenAI, GitHub, Stripe)
        4. **Configure your agent** to route HTTP traffic through `https://your-gateway-domain.zeabur.app` (the separate **Gateway Domain** auto-provisioned for the gateway port)
        5. **Give your agent a placeholder** (e.g. `Bearer FAKE_KEY`) — when it makes a request, the gateway swaps it for the real credential

        ```
        Your Agent → [FAKE_KEY] → OneCLI Gateway → [REAL_KEY] → External API (OpenAI, GitHub, etc.)
                                              ↓
                                      Audit log + rate limit
        ```

        ## Features

        - **Transparent credential injection** — agents make normal HTTP calls, gateway handles auth
        - **AES-256-GCM encryption at rest** — secrets decrypted only at request time
        - **Host & path matching** — route secrets to specific API endpoints
        - **Multi-agent support** — each agent gets its own scoped access token
        - **Rust gateway** — fast, memory-safe HTTP proxy with MITM interception
        - **Two auth modes** — single-user (no login, default) or Google OAuth (multi-user teams)
        - **Vault integration** — connect Bitwarden for on-demand credential injection
        - **Full audit log** — see exactly what every agent is doing

        ## First Login

        After deployment completes (may take 2-3 minutes for initial startup + migrations):

        1. Open `https://your-domain.zeabur.app` in your browser
        2. You'll land directly on the dashboard (no login required in single-user mode)
        3. Create your first agent and grab its access token
        4. Add secrets to the vault
        5. Point your AI agent's HTTP client to the gateway URL

        ## Configure Your AI Agent

        Once you have an agent token and at least one secret stored, point your agent at the **Gateway Domain** (a separate subdomain that Zeabur auto-provisions for the gateway port — find it in the service's **Domains** tab):

        ```bash
        # Example: route OpenAI calls through OneCLI
        curl https://your-gateway-domain.zeabur.app/v1/chat/completions \
          -H "Authorization: Bearer <your-agent-access-token>" \
          -H "Content-Type: application/json" \
          -d '{"model":"gpt-4","messages":[{"role":"user","content":"Hello!"}]}'
        ```

        In your agent code, just use a placeholder like `FAKE_OPENAI_KEY` and OneCLI swaps it for the real key.

        ## Post-Deployment Configuration (Optional)

        Customize these environment variables in the Zeabur Dashboard under the **onecli** service:

        ### Enable Google OAuth (multi-user mode)
        Set all three together (then restart), or leave all three empty for single-user mode:
        - `NEXTAUTH_SECRET` → your NextAuth secret
        - `GOOGLE_CLIENT_ID` → your Google OAuth client ID
        - `GOOGLE_CLIENT_SECRET` → your Google OAuth client secret

        > ⚠️ Auth is all-or-nothing: setting `NEXTAUTH_SECRET` alone (without the Google credentials) makes the dashboard redirect to a setup-error page. Set all three together, or none.

        ### Custom Gateway Port
        - `GATEWAY_PORT` → default 10255

        ## Notes

        - The encryption key (`SECRET_ENCRYPTION_KEY`) is auto-generated on first start and persisted to `/app/data/`. **Don't lose this volume** — without it, all stored secrets are unrecoverable.
        - The Rust gateway uses HTTPS interception (MITM) for credential injection. Your agent must trust the OneCLI CA cert (or set `--insecure-skip-verify` in development).
        - Database migrations run automatically via the entrypoint script.
        - The all-in-one image is ~500MB (Next.js + Rust gateway). Smaller than running separately.

        Learn more: https://github.com/onecli/onecli

        If you encounter any issues during deployment, please let me know via GitHub issues:
        [https://github.com/glasschan/seafoodholdhand-zeabur-templates](https://github.com/glasschan/seafoodholdhand-zeabur-templates)
    services:
        - name: PostgreSQL
          icon: https://raw.githubusercontent.com/zeabur/service-icons/main/marketplace/postgresql.svg
          template: PREBUILT_V2
          spec:
            id: postgresql
            source:
                image: postgres:18-alpine
            ports:
                - id: database
                  port: 5432
                  type: TCP
            volumes:
                - id: pg-data
                  dir: /var/lib/postgresql
            instructions:
                - title: PostgreSQL connection string (internal)
                  content: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${CONTAINER_HOSTNAME}:${DATABASE_PORT}/${POSTGRES_DB}
            env:
                POSTGRES_DB:
                    default: onecli
                    expose: true
                POSTGRES_HOST:
                    default: ${CONTAINER_HOSTNAME}
                    expose: true
                POSTGRES_PASSWORD:
                    default: ${PASSWORD}
                    expose: true
                POSTGRES_PORT:
                    default: ${DATABASE_PORT}
                    expose: true
                POSTGRES_USER:
                    default: onecli
                    expose: true
            healthCheck:
                type: TCP
                port: database
        - name: onecli
          icon: https://avatars.githubusercontent.com/u/263660444?s=60&v=4
          dependencies:
            - PostgreSQL
          template: PREBUILT_V2
          spec:
            id: onecli
            source:
                image: ghcr.io/onecli/onecli:latest
            ports:
                - id: web
                  port: 10254
                  type: HTTP
                - id: gateway
                  port: 10255
                  type: HTTP
            volumes:
                - id: onecli-data
                  dir: /app/data
            instructions:
                - title: Dashboard URL
                  content: ${ZEABUR_WEB_URL}
                - title: Gateway URL (point your AI agents here)
                  content: https://${GATEWAY_DOMAIN}
                - title: Example agent call (create an agent in the dashboard first)
                  content: 'curl https://${GATEWAY_DOMAIN}/v1/chat/completions -H "Authorization: Bearer <agent-access-token>" -H "Content-Type: application/json" -d ''{"model":"gpt-4","messages":[{"role":"user","content":"Hello!"}]}'''
            env:
                APP_URL:
                    default: https://${ZEABUR_WEB_DOMAIN}
                    expose: false
                AUTH_TRUST_HOST:
                    default: "true"
                    expose: false
                DATABASE_URL:
                    default: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${POSTGRES_PORT}/${POSTGRES_DB}
                    expose: false
                GATEWAY_API_URL:
                    default: https://${GATEWAY_DOMAIN}
                    expose: false
                GATEWAY_PORT:
                    default: "10255"
                    expose: false
                GOOGLE_CLIENT_ID:
                    default: ""
                    expose: false
                GOOGLE_CLIENT_SECRET:
                    default: ""
                    expose: false
                HOSTNAME:
                    default: 0.0.0.0
                    expose: false
                INTERNAL_API_URL:
                    default: http://localhost:10254
                    expose: false
                NEXTAUTH_SECRET:
                    default: ""
                    expose: false
                NEXTAUTH_URL:
                    default: https://${ZEABUR_WEB_DOMAIN}
                    expose: false
            healthCheck:
                type: TCP
                port: web
          domainKey:
            - port: web
              variable: PUBLIC_DOMAIN
            - port: gateway
              variable: GATEWAY_DOMAIN
localization:
    es-ES:
        description: Pasarela y bóveda de credenciales de código abierto para agentes de IA. Almacena las claves API una vez, las inyecta de forma transparente cuando tus agentes hacen llamadas HTTP — nunca ven las claves reales.
        variables:
            - key: PUBLIC_DOMAIN
              type: DOMAIN
              name: Dominio
              description: Dominio de tu instancia OneCLI (asignado automáticamente por Zeabur, personalizable)
            - key: GATEWAY_DOMAIN
              type: DOMAIN
              name: Dominio de la Pasarela
              description: Dominio público para la pasarela OneCLI (donde los agentes de IA envían sus peticiones HTTP). Asignado automáticamente por Zeabur; debe ser un subdominio diferente al del dashboard.
        readme: |-
            # OneCLI — Bóveda de Secretos para Agentes de IA (creado por SEAFOODHOLDHAND)

            **OneCLI** es la pasarela de credenciales de código abierto que se sitúa entre tus agentes de IA y los servicios a los que llaman. Almacena las claves API reales una vez en la bóveda cifrada de OneCLI, da a tus agentes claves placeholder (p. ej. `FAKE_KEY`), y la pasarela OneCLI inyecta las credenciales reales de forma transparente en las solicitudes salientes — los agentes nunca ven los secretos reales.

            Esta plantilla despliega una instancia completa de OneCLI con un solo clic.

            ## Arquitectura

            ```
            [Zeabur LB] → Aplicación OneCLI (una sola imagen, dos procesos)
                              ├─ :10254  → Dashboard Web Next.js (UI + API)
                              └─ :10255  → Pasarela Rust (proxy de inyección de credenciales)
            [PostgreSQL]  → Base de datos OneCLI (agentes, secretos, registros de auditoría)
            ```

            La imagen de la app OneCLI (`ghcr.io/onecli/onecli:latest`) incluye:
            - **Dashboard web Next.js** en el puerto 10254 (UI, gestión de agentes, gestión de secretos)
            - **Pasarela Rust** en el puerto 10255 (proxy transparente de inyección de credenciales)
            - **Migraciones de Prisma** se ejecutan automáticamente al iniciar el contenedor
            - **SECRET_ENCRYPTION_KEY auto-generada** y persistida en `/app/data/` (AES-256-GCM)

            ## ⚠️ Léelo antes de guardar credenciales reales — Seguridad

            Por defecto, esta plantilla se despliega en **modo usuario único / local: el dashboard se abre sin login.** Cualquiera que pueda llegar al dominio de tu dashboard puede ver y gestionar todas las claves API almacenadas. OneCLI es un **almacén de credenciales** — exponerlo por defecto en internet público no es seguro.

            **Antes de guardar cualquier secreto real, haz UNO de los siguiente:**

            1. **Bloquea el dashboard con Google OAuth** — en el servicio `onecli` del panel de Zeabur, define `NEXTAUTH_SECRET` + `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET` **juntos** (los tres, luego reinicia). Consulta "Configuración Post-Despliegue" más abajo.
            2. **O mantén el dashboard en un dominio privado / no público** (p. ej. accesible solo por VPN o red privada), para que solo tú puedas abrirlo.

            El **Dominio de la Pasarela** (adonde los agentes envían peticiones) siempre es público — eso es correcto, la pasarela autentica cada llamada con un access token por agente. La preocupación es solo el **Dominio del Dashboard** en modo local por defecto.

            ## Cómo Funciona

            1. Abre `https://your-domain.zeabur.app` en tu navegador
            2. Accederás directamente al dashboard (no requiere login en modo usuario único)
            3. Crea tu primer agente y obtén un access token
            4. Añade las claves API reales a la bóveda
            5. Dirige el cliente HTTP de tu agente de IA a la URL de la pasarela

            ```
            Tu Agente → [FAKE_KEY] → Pasarela OneCLI → [REAL_KEY] → API Externa (OpenAI, GitHub, etc.)
                                                             ↓
                                                    Log de auditoría + rate limit
            ```

            ## Funcionalidades

            - **Inyección transparente de credenciales** — los agentes hacen llamadas HTTP normales, la pasarela maneja la auth
            - **Cifrado AES-256-GCM en reposo** — los secretos se descifran solo en el momento de la solicitud
            - **Coincidencia por host y ruta** — enruta secretos a endpoints específicos de API
            - **Soporte multi-agente** — cada agente obtiene su propio access token con scopes
            - **Pasarela Rust** — proxy HTTP rápido y memory-safe con intercepción MITM
            - **Dos modos de auth** — usuario único (sin login) o Google OAuth (equipos multi-usuario)
            - **Integración con Vault** — conecta Bitwarden para inyección de credenciales bajo demanda
            - **Log de auditoría completo** — ve exactamente qué está haciendo cada agente

            ## Primer Inicio de Sesión

            Después de que se complete el despliegue (puede tomar 2-3 minutos para el inicio inicial + migraciones):

            1. Abre `https://your-domain.zeabur.app` en tu navegador
            2. Accederás directamente al dashboard (no requiere login en modo usuario único)
            3. Crea tu primer agente y obtén un access token
            4. Añade secretos a la bóveda
            5. Dirige el cliente HTTP de tu agente de IA a la URL de la pasarela

            ## Configura tu Agente de IA

            Una vez que tengas un token de agente y al menos un secreto almacenado:

            ```bash
            # Ejemplo: enrutar llamadas de OpenAI a través de OneCLI
            curl https://your-gateway-domain.zeabur.app/v1/chat/completions \
              -H "Authorization: Bearer <your-agent-access-token>" \
              -H "Content-Type: application/json" \
              -d '{"model":"gpt-4","messages":[{"role":"user","content":"Hello!"}]}'
            ```

            En el código de tu agente, simplemente usa un placeholder como `FAKE_OPENAI_KEY` y OneCLI lo intercambiará por la clave real.

            ## Configuración Post-Despliegue (Opcional)

            Personaliza estas variables de entorno en el panel de Zeabur bajo el servicio **onecli**:

            **Habilitar Google OAuth (modo multi-usuario):**
            - `NEXTAUTH_SECRET` → tu NextAuth secret
            - `GOOGLE_CLIENT_ID` → tu Google OAuth client ID
            - `GOOGLE_CLIENT_SECRET` → tu Google OAuth client secret

            **Puerto de Pasarela Personalizado:**
            - `GATEWAY_PORT` → por defecto 10255

            ## Notas

            - La clave de cifrado (`SECRET_ENCRYPTION_KEY`) se genera automáticamente en el primer inicio y se persiste en `/app/data/`. **No pierdas este volumen** — sin él, todos los secretos almacenados son irrecuperables.
            - La pasarela Rust usa intercepción HTTPS (MITM) para inyectar credenciales. Tu agente debe confiar en el certificado CA de OneCLI (o usar `--insecure-skip-verify` en desarrollo).
            - Las migraciones de base de datos se ejecutan automáticamente a través del script de entrypoint.
            - La imagen all-in-one pesa ~500MB (Next.js + pasarela Rust). Más pequeño que ejecutarlos por separado.

            Más información: https://github.com/onecli/onecli

            Si encuentras algún problema durante el despliegue, avísanos a través de GitHub issues:
            [https://github.com/glasschan/seafoodholdhand-zeabur-templates](https://github.com/glasschan/seafoodholdhand-zeabur-templates)
    id-ID:
        description: Gateway dan vault kredensial sumber terbuka untuk agen AI. Simpan kunci API sekali saja, suntikkan secara transparan saat agen Anda melakukan panggilan HTTP — mereka tidak pernah melihat kunci asli.
        variables:
            - key: PUBLIC_DOMAIN
              type: DOMAIN
              name: Domain
              description: Domain instance OneCLI Anda (otomatis ditetapkan oleh Zeabur, dapat disesuaikan)
            - key: GATEWAY_DOMAIN
              type: DOMAIN
              name: Domain Gateway
              description: Domain publik untuk gateway OneCLI (ke mana agen AI mengirim permintaan HTTP). Otomatis ditetapkan oleh Zeabur; harus berupa subdomain yang berbeda dari domain dashboard.
        readme: |-
            # OneCLI — Vault Rahasia untuk Agen AI (dibuat oleh SEAFOODHOLDHAND)

            **OneCLI** adalah gateway kredensial sumber terbuka yang berada di antara agen AI Anda dan layanan yang mereka panggil. Simpan kunci API asli di vault terenkripsi OneCLI, berikan placeholder (mis. `FAKE_KEY`) kepada agen Anda, dan gateway OneCLI akan menyuntikkan kredensial asli secara transparan pada permintaan keluar — agen tidak pernah melihat rahasia asli.

            Template ini men-deploy instance OneCLI lengkap dalam satu klik.

            ## Arsitektur

            ```
            [Zeabur LB] → Aplikasi OneCLI (satu image, dua proses)
                              ├─ :10254  → Dashboard Web Next.js (UI + API)
                              └─ :10255  → Gateway Rust (proksi injeksi kredensial)
            [PostgreSQL]  → Database OneCLI (agen, rahasia, log audit)
            ```

            Image aplikasi OneCLI (`ghcr.io/onecli/onecli:latest`) mencakup:
            - **Dashboard web Next.js** di port 10254 (UI, manajemen agen, manajemen rahasia)
            - **Gateway Rust** di port 10255 (proksi injeksi kredensial transparan)
            - **Migrasi Prisma** berjalan otomatis saat container dimulai
            - **SECRET_ENCRYPTION_KEY otomatis dibuat** dan disimpan di `/app/data/` (AES-256-GCM)

            ## ⚠️ Baca ini sebelum menyimpan kredensial asli — Keamanan

            Secara default, template ini di-deploy dalam **mode pengguna tunggal / lokal: dashboard terbuka tanpa login.** Siapa pun yang bisa mengakses domain dashboard Anda dapat melihat dan mengelola setiap kunci API yang tersimpan. OneCLI adalah **vault kredensial** — exposure default di internet publik tidak aman.

            **Sebelum menyimpan rahasia asli apa pun, lakukan SALAH SATU dari berikut:**

            1. **Kunci dashboard dengan Google OAuth** — pada layanan `onecli` di Zeabur Dashboard, setel `NEXTAUTH_SECRET` + `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET` **bersama-sama** (ketiganya, lalu restart). Lihat "Konfigurasi Pasca-Deploy" di bawah.
            2. **ATAU simpan dashboard di domain privat / non-publik** (mis. hanya dapat dijangkau via VPN atau jaringan pribadi), sehingga hanya Anda yang bisa membukanya.

            **Domain Gateway** (tempat agen mengirim permintaan) selalu publik — itu tidak masalah, karena gateway mengautentikasi setiap panggilan dengan access token per-agen. Yang menjadi perhatian hanyalah **Domain Dashboard** dalam mode lokal default.

            ## Cara Kerja

            1. Buka `https://your-domain.zeabur.app` di browser
            2. Anda akan langsung masuk ke dashboard (tidak perlu login dalam mode pengguna tunggal)
            3. Buat agen pertama Anda dan dapatkan access token
            4. Tambahkan kunci API asli ke vault
            5. Arahkan HTTP client agen AI Anda ke URL gateway

            ```
            Agen Anda → [FAKE_KEY] → Gateway OneCLI → [REAL_KEY] → API Eksternal (OpenAI, GitHub, dll.)
                                                          ↓
                                                    Log audit + rate limit
            ```

            ## Fitur

            - **Injeksi kredensial transparan** — agen membuat panggilan HTTP normal, gateway menangani auth
            - **Enkripsi AES-256-GCM at rest** — rahasia hanya didekripsi saat permintaan
            - **Pencocokan host & path** — rutekan rahasia ke endpoint API tertentu
            - **Dukungan multi-agen** — setiap agen mendapat access token dengan scope sendiri
            - **Gateway Rust** — proksi HTTP cepat, memory-safe dengan intersepsi MITM
            - **Dua mode auth** — pengguna tunggal (tanpa login) atau Google OAuth (tim multi-pengguna)
            - **Integrasi Vault** — hubungkan Bitwarden untuk injeksi kredensial sesuai permintaan
            - **Log audit lengkap** — lihat apa yang dilakukan setiap agen

            ## Login Pertama

            Setelah deployment selesai (membutuhkan 2-3 menit untuk startup awal + migrasi):

            1. Buka `https://your-domain.zeabur.app` di browser
            2. Anda akan langsung masuk ke dashboard (tidak perlu login dalam mode pengguna tunggal)
            3. Buat agen pertama Anda dan dapatkan access token
            4. Tambahkan rahasia ke vault
            5. Arahkan HTTP client agen AI Anda ke URL gateway

            ## Konfigurasi Agen AI Anda

            Setelah Anda memiliki token agen dan setidaknya satu rahasia tersimpan:

            ```bash
            # Contoh: rutekan panggilan OpenAI melalui OneCLI
            curl https://your-gateway-domain.zeabur.app/v1/chat/completions \
              -H "Authorization: Bearer <your-agent-access-token>" \
              -H "Content-Type: application/json" \
              -d '{"model":"gpt-4","messages":[{"role":"user","content":"Hello!"}]}'
            ```

            Dalam kode agen Anda, gunakan placeholder seperti `FAKE_OPENAI_KEY` dan OneCLI akan menggantinya dengan kunci asli.

            ## Konfigurasi Pasca-Deploy (Opsional)

            Sesuaikan variabel lingkungan ini di Zeabur Dashboard pada layanan **onecli**:

            **Aktifkan Google OAuth (mode multi-pengguna):**
            - `NEXTAUTH_SECRET` → NextAuth secret Anda
            - `GOOGLE_CLIENT_ID` → Google OAuth client ID Anda
            - `GOOGLE_CLIENT_SECRET` → Google OAuth client secret Anda

            **Port Gateway Kustom:**
            - `GATEWAY_PORT` → default 10255

            ## Catatan

            - Kunci enkripsi (`SECRET_ENCRYPTION_KEY`) dibuat otomatis saat start pertama dan disimpan di `/app/data/`. **Jangan hilangkan volume ini** — tanpa itu, semua rahasia yang tersimpan tidak dapat dipulihkan.
            - Gateway Rust menggunakan intersepsi HTTPS (MITM) untuk injeksi kredensial. Agen Anda harus mempercayai sertifikat CA OneCLI (atau gunakan `--insecure-skip-verify` di development).
            - Migrasi database berjalan otomatis melalui entrypoint script.
            - Image all-in-one sekitar 500MB (Next.js + Rust gateway). Lebih kecil dari menjalankannya secara terpisah.

            Pelajari lebih lanjut: https://github.com/onecli/onecli

            Jika Anda mengalami masalah selama deployment, beri tahu melalui GitHub issues:
            [https://github.com/glasschan/seafoodholdhand-zeabur-templates](https://github.com/glasschan/seafoodholdhand-zeabur-templates)
    ja-JP:
        description: オープンソースの AI エージェント用認証情報ゲートウェイとボールト。API キーを一度保存すれば、エージェントが HTTP リクエストを行う際に透過的に注入されます — エージェントが本物のキーを目にすることはありません。
        variables:
            - key: PUBLIC_DOMAIN
              type: DOMAIN
              name: ドメイン
              description: OneCLI インスタンスのドメイン(Zeabur が自動割り当て、カスタマイズ可能)
            - key: GATEWAY_DOMAIN
              type: DOMAIN
              name: ゲートウェイドメイン
              description: OneCLI ゲートウェイの公開ドメイン(AI エージェントが HTTP リクエストを送信する場所)。Zeabur が自動割り当て。ダッシュボールドメインとは別のサブドメインにする必要があります。
        readme: |-
            # OneCLI — AI エージェントのシークレットボールト(SEAFOODHOLDHAND 作成)

            **OneCLI** は AI エージェントとその呼び出し先サービスの間に位置するオープンソースの認証情報ゲートウェイです。実際の API キーを OneCLI の暗号化ボールトに保存し、エージェントにはプレースホルダー(例:`FAKE_KEY`)を渡すだけで、OneCLI ゲートウェイがリクエスト時に実際の認証情報を透過的に注入します。エージェントが本物のシークレットを見ることはありません。

            このテンプレートは OneCLI の完全なインスタンスをワンクリックでデプロイします。

            ## アーキテクチャ

            ```
            [Zeabur LB] → OneCLI アプリ(単一イメージ、2 プロセス)
                              ├─ :10254  → Next.js Web ダッシュボード(UI + API)
                              └─ :10255  → Rust ゲートウェイ(認証情報注入プロキシ)
            [PostgreSQL]  → OneCLI データベース(エージェント、シークレット、監査ログ)
            ```

            OneCLI アプリイメージ(`ghcr.io/onecli/onecli:latest`)には以下が含まれます:
            - **Next.js Web ダッシュボード**(port 10254、UI、エージェント管理、シークレット管理)
            - **Rust ゲートウェイ**(port 10255、透明な認証情報注入プロキシ)
            - **Prisma マイグレーション** コンテナ起動時に自動実行
            - **SECRET_ENCRYPTION_KEY 自動生成** `/app/data/` に永続化(AES-256-GCM)

            ## ⚠️ 本物の認証情報を保存する前に必ず読む — セキュリティ

            デフォルトでは、このテンプレートは**シングルユーザー / ローカルモード**でデプロイされます:**ダッシュボードはログインなしで直接開きます。** ダッシュボードのドメインを知っていれば、誰でも保存されているすべての API キーを閲覧・管理できます。OneCLI は**認証情報ボールト**です — デフォルト状態を公共のインターネットに晒すことは安全ではありません。

            **本物のシークレットを保存する前に、以下のいずれかを行ってください:**

            1. **Google OAuth でダッシュボードを保護する** — Zeabur ダッシュボードの `onecli` サービスで、`NEXTAUTH_SECRET` + `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET` を**3 つとも**設定して再起動します。下記「デプロイ後の設定」を参照。
            2. **またはダッシュボードをプライベート / 非公開ドメインに置く**(VPN やプライベートネットワークからのみ到達可能など)、自分だけが開けるようにします。

            **ゲートウェイドメイン**(エージェントがリクエストを送る場所)は常に公開です — これは問題ありません。ゲートウェイはエージェントごとのアクセストークンで全呼び出しを認証します。リスクがあるのはデフォルトのローカルモードにおける**ダッシュボードドメイン**だけです。

            ## 動作の仕組み

            1. ブラウザで `https://your-domain.zeabur.app` を開く
            2. ダッシュボードに直接アクセス(シングルユーザーモードはログイン不要)
            3. 最初のエージェントを作成してアクセストークンを取得
            4. 実際の API キーをボールトに追加
            5. AI エージェントの HTTP クライアントをゲートウェイ URL に向けます

            ```
            あなたのエージェント → [FAKE_KEY] → OneCLI ゲートウェイ → [REAL_KEY] → 外部 API(OpenAI、GitHub など)
                                                             ↓
                                                         監査ログ + レート制限
            ```

            ## 主な機能

            - **透過的な認証情報注入** — エージェントは通常の HTTP リクエストを送信、ゲートウェイが認証を処理
            - **AES-256-GCM 暗号化ストレージ** — シークレットはリクエスト時にのみ復号化
            - **ホストとパスのマッチング** — 特定の API エンドポイントにシークレットをルーティング
            - **マルチエージェント対応** — 各エージェントが独自のスコープ付きアクセストークンを取得
            - **Rust ゲートウェイ** — 高速でメモリ安全な HTTP プロキシ(MITM 対応)
            - **2 つの認証モード** — シングルユーザー(ログイン不要)または Google OAuth(マルチユーザーチーム)
            - **Vault 連携** — Bitwarden を接続してオンデマンドで認証情報を注入
            - **完全な監査ログ** — すべてのエージェントの動作を確認

            ## 初回ログイン

            デプロイ完了後(初回起動 + マイグレーションに 2〜3 分):

            1. ブラウザで `https://your-domain.zeabur.app` を開く
            2. ダッシュボードに直接アクセス(シングルユーザーモードはログイン不要)
            3. 最初のエージェントを作成してアクセストークンを取得
            4. シークレットをボールトに追加
            5. AI エージェントの HTTP クライアントをゲートウェイ URL に向けます

            ## AI エージェントの設定

            エージェントトークンと少なくとも 1 つのシークレットを取得したら:

            ```bash
            # 例:OpenAI リクエストを OneCLI ゲートウェイ経由で送信
            curl https://your-gateway-domain.zeabur.app/v1/chat/completions \
              -H "Authorization: Bearer <your-agent-access-token>" \
              -H "Content-Type: application/json" \
              -d '{"model":"gpt-4","messages":[{"role":"user","content":"Hello!"}]}'
            ```

            エージェントのコードでは、`FAKE_OPENAI_KEY` のようなプレースホルダーを使用してください。OneCLI が実際のキーに自動置換します。

            ## デプロイ後の設定(オプション)

            Zeabur ダッシュボードの **onecli** サービスで環境変数をカスタマイズできます:

            **Google OAuth を有効にする(マルチユーザーモード):**
            - `NEXTAUTH_SECRET` → NextAuth シークレット
            - `GOOGLE_CLIENT_ID` → Google OAuth クライアント ID
            - `GOOGLE_CLIENT_SECRET` → Google OAuth クライアントシークレット

            **ゲートウェイポートのカスタマイズ:**
            - `GATEWAY_PORT` → デフォルト 10255

            ## 注意事項

            - 暗号化キー(`SECRET_ENCRYPTION_KEY`)は初回起動時に自動生成され `/app/data/` に保存されます。**このボリュームを失わないでください** — 失うと、保存されたすべてのシークレットが復元不能になります。
            - Rust ゲートウェイは認証情報注入に HTTPS 傍受(MITM)を使用します。エージェントは OneCLI の CA 証明書を信頼する必要があります(または開発環境では `--insecure-skip-verify` を設定)。
            - データベースマイグレーションは entrypoint スクリプトにより自動実行されます。
            - All-in-one イメージは約 500MB(Next.js + Rust ゲートウェイ)。別々にデプロイするより小さくなります。

            詳細:https://github.com/onecli/onecli

            デプロイ中に問題が発生した場合は、GitHub issues でお知らせください:
            [https://github.com/glasschan/seafoodholdhand-zeabur-templates](https://github.com/glasschan/seafoodholdhand-zeabur-templates)
    zh-CN:
        description: 开源 AI 代理凭证网关与保险库。一次性存储 API 密钥,代理发出 HTTP 请求时自动注入 — 代理永远不会看到真实密钥。
        variables:
            - key: PUBLIC_DOMAIN
              type: DOMAIN
              name: 域名
              description: 你的 OneCLI 域名(Zeabur 自动分配,可自定义)
            - key: GATEWAY_DOMAIN
              type: DOMAIN
              name: 网关域名
              description: OneCLI 网关的公开域名(AI 代理发送 HTTP 请求的地方)。Zeabur 自动分配,必须与控制台域名是不同的子域名。
        readme: |-
            # OneCLI — AI 代理的密钥保险库(由 SEAFOODHOLDHAND 创建)

            **OneCLI** 是开源的凭证网关,位于你的 AI 代理与外部服务之间。将真实 API 密钥存储在 OneCLI 的加密保险库中,给代理一个 placeholder(如 `FAKE_KEY`),OneCLI 网关会在请求时自动替换为真实凭证 — 代理永远不会看到真实密钥。

            此模板一键部署完整的 OneCLI 实例。

            ## 架构

            ```
            [Zeabur LB] → OneCLI 应用(单一 image,两个进程)
                              ├─ :10254  → Next.js 网页控制台(UI + API)
                              └─ :10255  → Rust 网关(凭证注入代理)
            [PostgreSQL]  → OneCLI 数据库(代理、密钥、审计日志)
            ```

            OneCLI app image(`ghcr.io/onecli/onecli:latest`)包含:
            - **Next.js 网页控制台**(port 10254,UI、代理管理、密钥管理)
            - **Rust 网关**(port 10255,透明的凭证注入代理)
            - **Prisma migrations** 在容器启动时自动执行
            - **自动生成 SECRET_ENCRYPTION_KEY** 持久化到 `/app/data/`(AES-256-GCM)

            ## ⚠️ 存储真实凭证之前请先看 — 安全性

            默认情况下,此模板以**单用户 / 本地模式**部署:**控制台无需登录就会直接打开。** 任何知道你控制台域名的人都可以看到并管理其中存储的所有 API 密钥。OneCLI 是一个**凭证保险库** — 这样默认暴露在公共互联网是不安全的。

            **存储任何真实密钥之前,请做以下其中一项:**

            1. **用 Google OAuth 锁定控制台** — 在 Zeabur Dashboard 的 `onecli` 服务下,同时设置 `NEXTAUTH_SECRET` + `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET`(三个都要,然后重启)。见下面"部署后配置"。
            2. **或者将控制台放在私有 / 非公开域名**(例如只能通过 VPN 或私有网络访问),这样只有你能打开。

            **网关域名**(代理发送请求的地方)永远是公开的 — 这没问题,网关会用每个代理的 access token 验证每次调用。有风险的只是默认本地模式下的**控制台域名**。

            ## 工作原理

            1. 在浏览器打开 `https://your-domain.zeabur.app`
            2. 直接进入控制台(单用户模式无需登录)
            3. 创建第一个代理并获取 access token
            4. 将真实 API 密钥加入保险库
            5. 将你的 AI 代理的 HTTP client 指向网关 URL

            ```
            你的代理 → [FAKE_KEY] → OneCLI 网关 → [REAL_KEY] → 外部 API(OpenAI、GitHub 等)
                                                    ↓
                                                审计日志 + 速率限制
            ```

            ## 功能

            - **透明凭证注入** — 代理正常发 HTTP 请求,网关处理认证
            - **AES-256-GCM 加密存储** — 密钥仅在请求时解密
            - **主机与路径匹配** — 将密钥路由到特定 API endpoint
            - **多代理支持** — 每个代理有自己 scoped 的 access token
            - **Rust 网关** — 快速、内存安全的 HTTP 代理(支持 MITM)
            - **两种认证模式** — 单用户(无需登录)或 Google OAuth(多用户团队)
            - **Vault 集成** — 连接 Bitwarden 按需注入凭证
            - **完整审计日志** — 查看每个代理做了什么

            ## 首次登录

            部署完成后(首次启动 + migrations 需要 2-3 分钟):

            1. 在浏览器打开 `https://your-domain.zeabur.app`
            2. 直接进入控制台(单用户模式无需登录)
            3. 创建第一个代理并获取 access token
            4. 将密钥加入保险库
            5. 将你的 AI 代理的 HTTP client 指向网关 URL

            ## 配置你的 AI 代理

            获取代理 token 和至少一个密钥后:

            ```bash
            # 示例:将 OpenAI 请求通过 OneCLI 网关
            curl https://your-gateway-domain.zeabur.app/v1/chat/completions \
              -H "Authorization: Bearer <your-agent-access-token>" \
              -H "Content-Type: application/json" \
              -d '{"model":"gpt-4","messages":[{"role":"user","content":"Hello!"}]}'
            ```

            在你的代理代码中,使用 placeholder(如 `FAKE_OPENAI_KEY`),OneCLI 会自动替换为真实密钥。

            ## 部署后配置(可选)

            你可以在 Zeabur Dashboard 的 **onecli** 服务下自定义环境变量:

            **启用 Google OAuth(多用户模式):**
            - `NEXTAUTH_SECRET` → 你的 NextAuth 密钥
            - `GOOGLE_CLIENT_ID` → 你的 Google OAuth client ID
            - `GOOGLE_CLIENT_SECRET` → 你的 Google OAuth client secret

            **自定义网关端口:**
            - `GATEWAY_PORT` → 默认 10255

            ## 备注

            - 加密密钥(`SECRET_ENCRYPTION_KEY`)首次启动时自动生成并存储到 `/app/data/`。**不要丢失这个 volume** — 没了它,所有存储的密钥都不可恢复。
            - Rust 网关使用 HTTPS 拦截(MITM)来注入凭证。你的代理必须信任 OneCLI 的 CA 证书(或者在开发环境使用 `--insecure-skip-verify`)。
            - 数据库 migrations 通过 entrypoint script 自动执行。
            - All-in-one image 约 500MB(Next.js + Rust 网关),比单独部署小。

            了解更多:https://github.com/onecli/onecli

            如在部署期间遇到任何问题,请通过 GitHub issues 告知:
            [https://github.com/glasschan/seafoodholdhand-zeabur-templates](https://github.com/glasschan/seafoodholdhand-zeabur-templates)
    zh-TW:
        description: 開源 AI 代理憑證閘道與保險庫。一次儲存 API 金鑰，代理發出 HTTP 請求時自動注入 — 代理永遠不會看到真實密鑰。
        variables:
            - key: PUBLIC_DOMAIN
              type: DOMAIN
              name: 網域
              description: 你的 OneCLI 網域（Zeabur 自動分配，可自訂）
            - key: GATEWAY_DOMAIN
              type: DOMAIN
              name: 閘道網域
              description: OneCLI 閘道的公開網域（AI 代理發送 HTTP 請求的地方）。Zeabur 自動分配，必須與控制台網域為不同的子網域。
        readme: |-
            # OneCLI — AI 代理的密鑰保險庫（由 SEAFOODHOLDHAND 建立）

            **OneCLI** 是開源的憑證閘道，位於你的 AI 代理與外部服務之間。將真實 API 金鑰儲存於 OneCLI 的加密保險庫中，給予代理一個 placeholder（例如 `FAKE_KEY`），OneCLI 閘道會在請求時自動替換為真實憑證 — 代理永遠不會看到真實密鑰。

            此模板一鍵部署完整的 OneCLI 實例。

            ## 架構

            ```
            [Zeabur LB] → OneCLI 應用（單一 image，兩個 process）
                              ├─ :10254  → Next.js 網頁控制台（UI + API）
                              └─ :10255  → Rust 閘道（憑證注入代理）
            [PostgreSQL]  → OneCLI 資料庫（代理、密鑰、審計日誌）
            ```

            OneCLI app image (`ghcr.io/onecli/onecli:latest`) 包含：
            - **Next.js 網頁控制台**（port 10254，UI、代理管理、密鑰管理）
            - **Rust 閘道**（port 10255，透明的憑證注入代理）
            - **Prisma migrations** 於容器啟動時自動執行
            - **自動產生 SECRET_ENCRYPTION_KEY** 持久化於 `/app/data/`（AES-256-GCM）

            ## ⚠️ 儲存真實憑證前請先閱讀 — 安全性

            預設情況下，此模板以**單用戶 / 本地模式**部署：**控制台無需登入即會直接開啟。** 任何知道你控制台網域的人都能檢視並管理其中儲存的所有 API 金鑰。OneCLI 是一個**憑證保險庫** — 此預設狀態暴露於公共網際網路並不安全。

            **儲存任何真實密鑰前，請執行以下其中一項：**

            1. **以 Google OAuth 鎖定控制台** — 於 Zeabur Dashboard 的 `onecli` 服務下，同時設定 `NEXTAUTH_SECRET` + `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET`（三者缺一不可，然後重新啟動）。請見下方「部署後配置」。
            2. **或將控制台置於私人 / 非公開網域**（例如僅能透過 VPN 或私人網路存取），如此便只有你能開啟。

            **閘道網域**（代理發送請求之處）永遠為公開 — 這並無問題，閘道會以每個代理的 access token 驗證每次呼叫。有風險的僅是預設本地模式下的**控制台網域**。

            ## 運作方式

            1. 於瀏覽器開啟 `https://your-domain.zeabur.app`
            2. 直接進入控制台（單用戶模式無需登入）
            3. 建立第一個代理並取得 access token
            4. 將真實 API 金鑰加入保險庫
            5. 將你 AI 代理的 HTTP client 指向閘道 URL

            ```
            你的代理 → [FAKE_KEY] → OneCLI 閘道 → [REAL_KEY] → 外部 API（OpenAI、GitHub 等）
                                                    ↓
                                                審計日誌 + 速率限制
            ```

            ## 功能

            - **透明憑證注入** — 代理正常發送 HTTP 請求，閘道處理認證
            - **AES-256-GCM 加密儲存** — 密鑰僅於請求時解密
            - **主機與路徑匹配** — 將密鑰路由至特定 API endpoint
            - **多代理支援** — 每個代理擁有各自的 scoped access token
            - **Rust 閘道** — 快速、記憶體安全的 HTTP 代理（支援 MITM）
            - **兩種認證模式** — 單用戶（無需登入）或 Google OAuth（多用戶團隊）
            - **Vault 整合** — 串接 Bitwarden 隨需注入憑證
            - **完整審計日誌** — 檢視每個代理的行為

            ## 首次登入

            部署完成後（首次啟動 + migrations 約需 2-3 分鐘）：

            1. 於瀏覽器開啟 `https://your-domain.zeabur.app`
            2. 直接進入控制台（單用戶模式無需登入）
            3. 建立第一個代理並取得 access token
            4. 將密鑰加入保險庫
            5. 將你 AI 代理的 HTTP client 指向閘道 URL

            ## 配置你的 AI 代理

            取得代理 token 與至少一個密鑰後：

            ```bash
            # 範例：將 OpenAI 請求經由 OneCLI 閘道
            curl https://your-gateway-domain.zeabur.app/v1/chat/completions \
              -H "Authorization: Bearer <your-agent-access-token>" \
              -H "Content-Type: application/json" \
              -d '{"model":"gpt-4","messages":[{"role":"user","content":"Hello!"}]}'
            ```

            在你的代理程式碼中，使用 placeholder（例如 `FAKE_OPENAI_KEY`），OneCLI 會自動替換為真實金鑰。

            ## 部署後配置（可選）

            你可在 Zeabur Dashboard 的 **onecli** 服務下自訂環境變數：

            **啟用 Google OAuth（多用戶模式）：**
            - `NEXTAUTH_SECRET` → 你的 NextAuth 密鑰
            - `GOOGLE_CLIENT_ID` → 你的 Google OAuth client ID
            - `GOOGLE_CLIENT_SECRET` → 你的 Google OAuth client secret

            **自訂閘道連接埠：**
            - `GATEWAY_PORT` → 預設 10255

            ## 備註

            - 加密金鑰（`SECRET_ENCRYPTION_KEY`）於首次啟動時自動產生並儲存於 `/app/data/`。**請勿遺失此 volume** — 一旦遺失，所有已儲存的密鑰將無法復原。
            - Rust 閘道以 HTTPS 攔截（MITM）注入憑證。你的代理必須信任 OneCLI 的 CA 憑證（或在開發環境使用 `--insecure-skip-verify`）。
            - 資料庫 migrations 透過 entrypoint script 自動執行。
            - All-in-one image 約 500MB（Next.js + Rust 閘道），比分開部署更小。

            了解更多：https://github.com/onecli/onecli

            如於部署期間遇到任何問題，請透過 GitHub issues 告知：
            [https://github.com/glasschan/seafoodholdhand-zeabur-templates](https://github.com/glasschan/seafoodholdhand-zeabur-templates)