bump upstream to 0.4.1, add the status page UI, fix CI branch triggers

Community-registry audit ahead of listing.

Upstream 0.4.1 renames the model catalog (private/kimi-k2-6 →
private/kimi-k3, drops qwen3-vl-30b) and serves a status page at GET /,
so the package was documenting a stale model list and hiding a whole
surface. Export that page as a `ui` interface alongside the existing
`api` on one host, and unmask the API interface — its URL carries no
credentials, so masking hid the address for nothing.

PPQ_DATA_DIR stays unset deliberately. With it set, upstream persists a
browser-entered key to its own config.json while the StartOS-supplied
PPQ_API_KEY still wins at every restart, silently reverting the user.
StartOS owns the key via the action; the status page's form renders
disabled.

CI never ran: build.yml's PR target and tagAndRelease.yml's push
trigger both named `master` on a repo whose only branch is `main`.
Point them at `main` and reset all three workflows to the package
template, dropping the guard job retired in start-technologies@ed0dca2.

packageRepo now names the Start9-Community fork, which is where CI
runs, where the org's registry variables live, and where releases are
cut.

Also: drop three .catch handlers on file-model reads, which swallowed a
genuine read failure into "no key configured" — readOnce already
returns null for a missing file; pass null rather than an empty Mounts
for the unmounted subcontainer; inline two single-use interface consts;
and rewrite README/instructions against the writing guides, fixing a
YAML block that claimed a /data mount the package deliberately does not
make.
This commit is contained in:
helix-nine committed 2026-08-12 09:58:35 -06:00
1 parent 5146a2670f
commit 42b2841945
17 files changed
+204 -168

No files matched your search

+1 -3
View File
@@ -4,7 +4,7 @@ on:
workflow_dispatch:
pull_request:
paths-ignore: ['*.md']
branches: ['master']
branches: ['main']
concurrency:
group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
@@ -14,6 +14,4 @@ jobs:
build:
if: github.event.pull_request.draft == false
uses: Start9Labs/start-technologies/.github/workflows/build.yml@master
# with:
# FREE_DISK_SPACE: true
# No DEV_KEY — a PR build doesn't publish, so it doesn't need the signing key.
-14
View File
@@ -6,23 +6,9 @@ on:
- 'v*.*'
jobs:
guard:
runs-on: ubuntu-latest
outputs:
id: ${{ steps.read.outputs.id }}
steps:
- uses: actions/checkout@v4
- id: read
run: |
id="$(awk -F"'" '/id:/ {print $2; exit}' startos/manifest/index.ts)"
echo "id=$id" >> "$GITHUB_OUTPUT"
release:
needs: guard
if: needs.guard.outputs.id != 'hello-world'
uses: Start9Labs/start-technologies/.github/workflows/release.yml@master
with:
# FREE_DISK_SPACE: true
RELEASE_REGISTRY: ${{ vars.RELEASE_REGISTRY }}
S3_S9PKS_BASE_URL: ${{ vars.S3_S9PKS_BASE_URL }}
secrets:
+1 -15
View File
@@ -2,7 +2,7 @@ name: Tag and Release
on:
push:
branches: ['master']
branches: ['main']
paths-ignore: ['*.md']
concurrency:
@@ -10,24 +10,10 @@ concurrency:
cancel-in-progress: true
jobs:
guard:
runs-on: ubuntu-latest
outputs:
id: ${{ steps.read.outputs.id }}
steps:
- uses: actions/checkout@v4
- id: read
run: |
id="$(awk -F"'" '/id:/ {print $2; exit}' startos/manifest/index.ts)"
echo "id=$id" >> "$GITHUB_OUTPUT"
tag:
needs: guard
if: needs.guard.outputs.id != 'hello-world'
uses: Start9Labs/start-technologies/.github/workflows/tagAndRelease.yml@master
with:
REFERENCE_REGISTRY: ${{ vars.REFERENCE_REGISTRY }}
# FREE_DISK_SPACE: true
RELEASE_REGISTRY: ${{ vars.RELEASE_REGISTRY }}
S3_S9PKS_BASE_URL: ${{ vars.S3_S9PKS_BASE_URL }}
secrets:
+38 -18
View File
@@ -55,35 +55,46 @@ variables only.
## Installation and First-Run Flow
On install, a critical task prompts for a PPQ.AI API key. The service cannot
start until the key is provided (upstream exits immediately without
`PPQ_API_KEY`). There is no other setup.
start until the key is provided (the task blocks startup, and upstream exits
immediately when neither `PPQ_API_KEY` nor `PPQ_DATA_DIR` is set). There is no
other setup.
## Configuration Management
All upstream configuration is via environment variables; StartOS manages them
from `config.json`:
Nothing is upstream-managed: the proxy has no config file of its own and takes
every setting from an environment variable, all of which StartOS supplies from
`config.json`.
- `PPQ_API_KEY` — set from the **Configure PPQ API Key** action
- `DEBUG` — set from the same action's Verbose Logging toggle
- `HOST` — fixed to `0.0.0.0` (container binding)
- `PORT` — fixed to `8787`
- `PORT` — fixed to 8787
- `PPQ_API_BASE` — not set (upstream default `https://api.ppq.ai`)
- `PPQ_DATA_DIR` — deliberately not set (see Limitations)
Changing settings restarts the daemon (values are read reactively).
## Network Access and Interfaces
One interface, `api` (port 8787, HTTP): the upstream OpenAI-compatible API,
shown as a copyable connection string. Endpoints: `GET /health`,
`GET /v1/models`, `POST /v1/chat/completions` (OpenAI format),
`POST /v1/messages` (Anthropic format). Availability on LAN/Tor is decided by
the user from the interface panel.
Two interfaces on one HTTP host, port 8787, both served by the proxy:
- **Status Page** (`ui`) — upstream's server-rendered page at `/`: attestation
state (enclave host and code fingerprint), API-key status, the private model
list, and client setup snippets.
- **OpenAI-Compatible API** (`api`) — the same origin, shown as a copyable
connection string for AI clients. Endpoints: `GET /health`,
`GET /v1/models`, `POST /v1/chat/completions` (OpenAI format),
`POST /v1/messages` (Anthropic format).
Availability on LAN/Tor is decided by the user from the interface panel.
## Actions (StartOS UI)
- **Configure PPQ API Key** (`configure-api-key`) — sets the PPQ.AI API key
(masked, never echoed back) and the Verbose Logging toggle. Available at any
service status. Also the target of the critical first-run task.
- **Configure PPQ API Key** (`configure-api-key`) — visible and enabled at any
service status. Inputs: the PPQ.AI API key (masked; left blank it keeps the
key already saved, and it is never echoed back into the form) and the Verbose
Logging toggle. No result output. Also the target of the critical first-run
task.
## Backups and Restore
@@ -108,16 +119,22 @@ None.
1. This service is a client-side encryption proxy, not a self-hosted model
server: inference runs remotely in PPQ.AI's attested TEE enclaves, and a
funded [PPQ.AI](https://ppq.ai) API key is required (pay-per-query).
2. The upstream OpenClaw-plugin mode is not packaged; only the standalone
2. The API-key form on upstream's status page is inactive here. StartOS is the
single source of truth for the key, so `PPQ_DATA_DIR` is left unset: with
it set, upstream would persist a browser-entered key to its own
`config.json` while the StartOS-supplied `PPQ_API_KEY` still won at every
restart, silently reverting it. Use the **Configure PPQ API Key** action.
3. The upstream OpenClaw-plugin mode is not packaged; only the standalone
proxy runs on StartOS.
3. The bind address and port are fixed (`0.0.0.0:8787` inside the container);
upstream's `HOST`/`PORT`/`PPQ_API_BASE` variables are not user-configurable.
4. The bind address and port are fixed inside the container; upstream's
`HOST`/`PORT`/`PPQ_API_BASE` variables are not user-configurable.
## What Is Unchanged from Upstream
- All API endpoints, request/response formats, and streaming behavior
- The encryption and attestation flow (EHBP transport via the `tinfoil` client)
- Model catalog and per-request `Authorization: Bearer` key override
- The status page rendered at `/`, minus its API-key form
## Contributing
@@ -131,9 +148,12 @@ See [AGENTS.md](AGENTS.md).
package_id: ppq-private-mode
architectures: [x86_64, aarch64]
volumes:
main: /data
main: null # host-side config.json only; not mounted into the container
ports:
api: 8787
main: 8787 # one host serving both interfaces
interfaces:
- ui
- api
dependencies: none
startos_managed_env_vars:
- PPQ_API_KEY
+6 -7
View File
@@ -1,9 +1,8 @@
# TODO — remaining work before release
- [x] Verified on StartOS 0.4.0 (aarch64, QEMU/HVF VM): sideload install,
critical first-run task, Configure PPQ API Key action, attestation-gated
health check, OpenAI chat completion through the exported TLS interface,
logs, stop/start persistence, uninstall, and backup/restore to a disk
target (service restores with its key, no re-prompt).
- [ ] Submit to the Community Registry (email submissions@start9.com with a
link to this repo).
- [ ] Run one live inference request with a funded PPQ.AI key. Everything up to
the enclave is verified (attestation, encrypted forward, error handling),
but no request has yet been billed end-to-end against a real key.
- [ ] Re-run backup and restore on a StartOS box: back up, uninstall, restore,
and confirm the service comes back with its key and raises no
configuration task.
+15 -9
View File
@@ -2,14 +2,15 @@
Upstream is [PayPerQ/ppq-private-mode-proxy](https://github.com/PayPerQ/ppq-private-mode-proxy),
vendored as the `ppq-private-mode-proxy` git submodule and built from its own
`Dockerfile`. The package version tracks upstream's `package.json` version.
`Dockerfile`. The package version tracks upstream's `package.json` version,
which upstream tags as `v<version>`.
## Determining the upstream version
```bash
git -C ppq-private-mode-proxy fetch origin
git -C ppq-private-mode-proxy log --oneline HEAD..origin/main # anything new?
jq -r .version ppq-private-mode-proxy/package.json # current pin
git -C ppq-private-mode-proxy fetch origin --tags
git -C ppq-private-mode-proxy describe --tags HEAD # current pin
git -C ppq-private-mode-proxy tag --sort=-v:refname | head # latest released
```
The packaged version lives in `startos/versions/current.ts` (`version:
@@ -17,9 +18,14 @@ The packaged version lives in `startos/versions/current.ts` (`version:
## Applying the bump
1. Advance the submodule: `git -C ppq-private-mode-proxy checkout origin/main`
2. Update `version` in `startos/versions/current.ts` to the new upstream
1. Advance the submodule: `git -C ppq-private-mode-proxy checkout v<version>`
2. Read the upstream diff (`git -C ppq-private-mode-proxy diff <old>..<new>`)
for anything the package has to follow — new or renamed environment
variables, changed endpoints, a changed bind/attestation order (the health
check depends on the port being bound only after attestation), or a model
catalog change that the docs name.
3. Update `version` in `startos/versions/current.ts` to the new upstream
`package.json` version with revision `:0` (bump only the revision for
packaging-only changes), and write release notes.
3. Rebuild and test: `make x86` (or `make arm`), install, verify attestation
completes and a `/v1/models` request succeeds.
packaging-only changes), and write release notes in every locale.
4. Rebuild and test: `make x86` (or `make arm`), install, verify attestation
completes, the Status Page loads, and a `/v1/models` request succeeds.
+37 -14
View File
@@ -5,21 +5,38 @@
- [Upstream proxy documentation](https://github.com/PayPerQ/ppq-private-mode-proxy) — endpoints, client examples, and how the encryption works
- [PPQ.AI API docs](https://ppq.ai/api-docs) — creating an API key and funding your account
## What you get on StartOS
A local endpoint your AI clients talk to instead of talking to a model provider
directly. Everything sent through it is encrypted on your server and only
decrypted inside an attested hardware enclave, so neither PPQ.AI nor the model
host can read your queries.
Two interfaces share one address:
- **Status Page** — a web page showing whether enclave attestation succeeded,
which private models are available, and how to point a client at the proxy.
- **OpenAI-Compatible API** — the same address, ready to copy into a client.
The only thing the service stores is your PPQ.AI API key and the logging
setting.
## Getting set up
1. When the service is installed, you will be prompted to run **Configure PPQ
API Key**. Paste an API key from [ppq.ai](https://ppq.ai) (create one under
**Settings → API Keys** and fund the account — usage is billed per query to
this key).
1. You will be prompted to run **Configure PPQ API Key**. Paste an API key from
[ppq.ai](https://ppq.ai) — create one under **Settings → API Keys** and fund
the account, since usage is billed per query to this key.
2. The service starts and performs a cryptographic attestation of the remote
enclave. The health check reports ready once attestation is verified —
usually within a few seconds.
3. Copy the **OpenAI-Compatible API** address from the service's interface
panel. That is the URL you point your AI clients at.
3. Open the **Status Page** to confirm attestation succeeded, or copy the
**OpenAI-Compatible API** address to point a client at it.
## Using the proxy
## Using PPQ Private Mode
Point any OpenAI-compatible client at the interface address:
### Connecting a client
Point any OpenAI-compatible client at the API address:
```
POST <api-address>/v1/chat/completions
@@ -34,16 +51,22 @@ export ANTHROPIC_BASE_URL="<api-address>"
export ANTHROPIC_MODEL="private/glm-5-2"
```
`GET <api-address>/v1/models` lists the available private models. Every
request is encrypted on your server before it leaves and is only decrypted
inside the attested enclave — neither PPQ.AI nor the model host can read your
queries.
`GET <api-address>/v1/models` lists the available private models, and the
Status Page shows the same list.
Requests are billed to your saved API key by default. To bill a different
PPQ.AI key per request, pass it as an `Authorization: Bearer` header.
If you need to change the key or turn on verbose logging later, run
**Configure PPQ API Key** again from the service's Actions.
### Actions
Run **Configure PPQ API Key** again whenever you want to replace the key or
turn verbose logging on or off. Leaving the key field blank keeps the key you
already saved.
## Limitations
The Status Page has its own "save API key" form upstream; it is inactive here,
because the key is managed by the **Configure PPQ API Key** action instead.
Backups of this service include your saved API key, and restoring a backup
restores it — keep that in mind when handling backup drives.
+9 -14
View File
@@ -41,24 +41,19 @@ export const configureApiKey = sdk.Action.withInput(
inputSpec,
// Prefill: the API key is never echoed back into the form.
async ({ effects }) => {
const debug = await configJson
.read((c) => c.debug)
.once()
.catch(() => false)
return { debug: debug ?? false }
},
async ({ effects }) => ({
debug: (await configJson.read((c) => c.debug).once()) ?? false,
}),
async ({ effects, input }) => {
const existingKey = await configJson
.read((c) => c.apiKey)
.once()
.catch(() => undefined)
const apiKey = (input.apiKey ?? '').trim() || existingKey
const apiKey =
(input.apiKey ?? '').trim() ||
(await configJson.read((c) => c.apiKey).once())
if (!apiKey) {
throw new Error(
i18n('An API key is required. Create one at ppq.ai under Settings → API Keys.'),
i18n(
'An API key is required. Create one at ppq.ai under Settings → API Keys.',
),
)
}
+12 -10
View File
@@ -7,18 +7,20 @@ const dict = {
'The proxy is ready — enclave attestation verified': 2,
'The proxy is not ready (enclave attestation pending)': 3,
// interfaces.ts
'OpenAI-Compatible API': 4,
'Point any OpenAI or Anthropic SDK client at this URL to use PPQ private (TEE) models with end-to-end encryption': 5,
'Status Page': 4,
'Enclave attestation state, the available private models, and client setup snippets': 5,
'OpenAI-Compatible API': 6,
'Point any OpenAI or Anthropic SDK client at this URL to use PPQ private (TEE) models with end-to-end encryption': 7,
// actions/configureApiKey.ts
'PPQ.AI API Key': 6,
'Your API key from ppq.ai (Settings → API Keys). Leave blank to keep the key already saved.': 7,
'Verbose Logging': 8,
'Log every request the proxy handles. Useful for troubleshooting.': 9,
'Configure PPQ API Key': 10,
'Set the PPQ.AI API key the proxy uses to authenticate. Requests are billed to this key.': 11,
'An API key is required. Create one at ppq.ai under Settings → API Keys.': 12,
'PPQ.AI API Key': 8,
'Your API key from ppq.ai (Settings → API Keys). Leave blank to keep the key already saved.': 9,
'Verbose Logging': 10,
'Log every request the proxy handles. Useful for troubleshooting.': 11,
'Configure PPQ API Key': 12,
'Set the PPQ.AI API key the proxy uses to authenticate. Requests are billed to this key.': 13,
'An API key is required. Create one at ppq.ai under Settings → API Keys.': 14,
// init/taskConfigureApiKey.ts
'Add your PPQ.AI API key to start the proxy': 13,
'Add your PPQ.AI API key to start the proxy': 15,
} as const
/**
+48 -40
View File
@@ -6,63 +6,71 @@ export default {
1: 'Proxy cifrado',
2: 'El proxy está listo — atestación del enclave verificada',
3: 'El proxy no está listo (atestación del enclave pendiente)',
4: 'API compatible con OpenAI',
5: 'Apunta cualquier cliente SDK de OpenAI o Anthropic a esta URL para usar los modelos privados (TEE) de PPQ con cifrado de extremo a extremo',
6: 'Clave API de PPQ.AI',
7: 'Tu clave API de ppq.ai (Ajustes → Claves API). Déjalo en blanco para conservar la clave ya guardada.',
8: 'Registro detallado',
9: 'Registra cada solicitud que maneja el proxy. Útil para diagnosticar problemas.',
10: 'Configurar clave API de PPQ',
11: 'Establece la clave API de PPQ.AI que el proxy usa para autenticarse. Las solicitudes se facturan a esta clave.',
12: 'Se requiere una clave API. Crea una en ppq.ai en Ajustes → Claves API.',
13: 'Añade tu clave API de PPQ.AI para iniciar el proxy',
4: 'Página de estado',
5: 'Estado de la atestación del enclave, los modelos privados disponibles y fragmentos de configuración para clientes',
6: 'API compatible con OpenAI',
7: 'Apunta cualquier cliente SDK de OpenAI o Anthropic a esta URL para usar los modelos privados (TEE) de PPQ con cifrado de extremo a extremo',
8: 'Clave API de PPQ.AI',
9: 'Tu clave API de ppq.ai (Ajustes → Claves API). Déjalo en blanco para conservar la clave ya guardada.',
10: 'Registro detallado',
11: 'Registra cada solicitud que maneja el proxy. Útil para diagnosticar problemas.',
12: 'Configurar clave API de PPQ',
13: 'Establece la clave API de PPQ.AI que el proxy usa para autenticarse. Las solicitudes se facturan a esta clave.',
14: 'Se requiere una clave API. Crea una en ppq.ai en Ajustes → Claves API.',
15: 'Añade tu clave API de PPQ.AI para iniciar el proxy',
},
de_DE: {
0: 'Starte PPQ Private Mode!',
1: 'Verschlüsselter Proxy',
2: 'Der Proxy ist bereit — Enklave-Attestierung verifiziert',
3: 'Der Proxy ist nicht bereit (Enklave-Attestierung ausstehend)',
4: 'OpenAI-kompatible API',
5: 'Verbinde jeden OpenAI- oder Anthropic-SDK-Client mit dieser URL, um die privaten (TEE) Modelle von PPQ mit Ende-zu-Ende-Verschlüsselung zu nutzen',
6: 'PPQ.AI-API-Schlüssel',
7: 'Dein API-Schlüssel von ppq.ai (Einstellungen → API-Schlüssel). Leer lassen, um den bereits gespeicherten Schlüssel zu behalten.',
8: 'Ausführliche Protokollierung',
9: 'Protokolliert jede Anfrage, die der Proxy verarbeitet. Nützlich zur Fehlersuche.',
10: 'PPQ-API-Schlüssel konfigurieren',
11: 'Lege den PPQ.AI-API-Schlüssel fest, mit dem sich der Proxy authentifiziert. Anfragen werden diesem Schlüssel in Rechnung gestellt.',
12: 'Ein API-Schlüssel ist erforderlich. Erstelle einen auf ppq.ai unter Einstellungen → API-Schlüssel.',
13: 'Füge deinen PPQ.AI-API-Schlüssel hinzu, um den Proxy zu starten',
4: 'Statusseite',
5: 'Status der Enklave-Attestierung, die verfügbaren privaten Modelle und Codeschnipsel zur Client-Einrichtung',
6: 'OpenAI-kompatible API',
7: 'Verbinde jeden OpenAI- oder Anthropic-SDK-Client mit dieser URL, um die privaten (TEE) Modelle von PPQ mit Ende-zu-Ende-Verschlüsselung zu nutzen',
8: 'PPQ.AI-API-Schlüssel',
9: 'Dein API-Schlüssel von ppq.ai (Einstellungen → API-Schlüssel). Leer lassen, um den bereits gespeicherten Schlüssel zu behalten.',
10: 'Ausführliche Protokollierung',
11: 'Protokolliert jede Anfrage, die der Proxy verarbeitet. Nützlich zur Fehlersuche.',
12: 'PPQ-API-Schlüssel konfigurieren',
13: 'Lege den PPQ.AI-API-Schlüssel fest, mit dem sich der Proxy authentifiziert. Anfragen werden diesem Schlüssel in Rechnung gestellt.',
14: 'Ein API-Schlüssel ist erforderlich. Erstelle einen auf ppq.ai unter Einstellungen → API-Schlüssel.',
15: 'Füge deinen PPQ.AI-API-Schlüssel hinzu, um den Proxy zu starten',
},
pl_PL: {
0: 'Uruchamianie PPQ Private Mode!',
1: 'Szyfrowany proxy',
2: 'Proxy jest gotowy — atestacja enklawy zweryfikowana',
3: 'Proxy nie jest gotowy (atestacja enklawy w toku)',
4: 'API zgodne z OpenAI',
5: 'Skieruj dowolnego klienta SDK OpenAI lub Anthropic na ten URL, aby korzystać z prywatnych modeli (TEE) PPQ z szyfrowaniem end-to-end',
6: 'Klucz API PPQ.AI',
7: 'Twój klucz API z ppq.ai (Ustawienia → Klucze API). Pozostaw puste, aby zachować już zapisany klucz.',
8: 'Szczegółowe logowanie',
9: 'Rejestruje każde żądanie obsługiwane przez proxy. Przydatne przy rozwiązywaniu problemów.',
10: 'Skonfiguruj klucz API PPQ',
11: 'Ustaw klucz API PPQ.AI, którym proxy się uwierzytelnia. Żądania są rozliczane na ten klucz.',
12: 'Wymagany jest klucz API. Utwórz go na ppq.ai w Ustawienia → Klucze API.',
13: 'Dodaj swój klucz API PPQ.AI, aby uruchomić proxy',
4: 'Strona stanu',
5: 'Stan atestacji enklawy, dostępne modele prywatne oraz fragmenty konfiguracji dla klientów',
6: 'API zgodne z OpenAI',
7: 'Skieruj dowolnego klienta SDK OpenAI lub Anthropic na ten URL, aby korzystać z prywatnych modeli (TEE) PPQ z szyfrowaniem end-to-end',
8: 'Klucz API PPQ.AI',
9: 'Twój klucz API z ppq.ai (Ustawienia → Klucze API). Pozostaw puste, aby zachować już zapisany klucz.',
10: 'Szczegółowe logowanie',
11: 'Rejestruje każde żądanie obsługiwane przez proxy. Przydatne przy rozwiązywaniu problemów.',
12: 'Skonfiguruj klucz API PPQ',
13: 'Ustaw klucz API PPQ.AI, którym proxy się uwierzytelnia. Żądania są rozliczane na ten klucz.',
14: 'Wymagany jest klucz API. Utwórz go na ppq.ai w Ustawienia → Klucze API.',
15: 'Dodaj swój klucz API PPQ.AI, aby uruchomić proxy',
},
fr_FR: {
0: 'Démarrage de PPQ Private Mode !',
1: 'Proxy chiffré',
2: "Le proxy est prêt — attestation de l'enclave vérifiée",
3: "Le proxy n'est pas prêt (attestation de l'enclave en attente)",
4: 'API compatible OpenAI',
5: "Pointez n'importe quel client SDK OpenAI ou Anthropic vers cette URL pour utiliser les modèles privés (TEE) de PPQ avec un chiffrement de bout en bout",
6: 'Clé API PPQ.AI',
7: 'Votre clé API de ppq.ai (Paramètres → Clés API). Laissez vide pour conserver la clé déjà enregistrée.',
8: 'Journalisation détaillée',
9: 'Journalise chaque requête traitée par le proxy. Utile pour le dépannage.',
10: 'Configurer la clé API PPQ',
11: "Définissez la clé API PPQ.AI avec laquelle le proxy s'authentifie. Les requêtes sont facturées sur cette clé.",
12: 'Une clé API est requise. Créez-en une sur ppq.ai dans Paramètres → Clés API.',
13: 'Ajoutez votre clé API PPQ.AI pour démarrer le proxy',
4: "Page d'état",
5: "État de l'attestation de l'enclave, les modèles privés disponibles et des extraits de configuration client",
6: 'API compatible OpenAI',
7: "Pointez n'importe quel client SDK OpenAI ou Anthropic vers cette URL pour utiliser les modèles privés (TEE) de PPQ avec un chiffrement de bout en bout",
8: 'Clé API PPQ.AI',
9: 'Votre clé API de ppq.ai (Paramètres → Clés API). Laissez vide pour conserver la clé déjà enregistrée.',
10: 'Journalisation détaillée',
11: 'Journalise chaque requête traitée par le proxy. Utile pour le dépannage.',
12: 'Configurer la clé API PPQ',
13: "Définissez la clé API PPQ.AI avec laquelle le proxy s'authentifie. Les requêtes sont facturées sur cette clé.",
14: 'Une clé API est requise. Créez-en une sur ppq.ai dans Paramètres → Clés API.',
15: 'Ajoutez votre clé API PPQ.AI pour démarrer le proxy',
},
} satisfies Record<string, LangDict>
+2 -5
View File
@@ -5,11 +5,8 @@ import { i18n } from '../i18n'
// The proxy cannot start without a PPQ.AI API key, so a critical task blocks
// startup until the user provides one.
export const taskConfigureApiKey = sdk.setupOnInit(async (effects, kind) => {
const apiKey = await configJson
.read((c) => c.apiKey)
.once()
.catch(() => undefined)
export const taskConfigureApiKey = sdk.setupOnInit(async (effects) => {
const apiKey = await configJson.read((c) => c.apiKey).once()
if (!apiKey) {
await sdk.action.createOwnTask(effects, configureApiKey, 'critical', {
+19 -10
View File
@@ -2,30 +2,39 @@ import { sdk } from './sdk'
import { apiPort } from './utils'
import { i18n } from './i18n'
// Host id (the sdk.MultiHost.of group) — distinct from the interface id exported on it.
export const apiHostId = 'api-multi'
export const apiInterfaceId = 'api'
export const setInterfaces = sdk.setupInterfaces(async ({ effects }) => {
const apiMulti = sdk.MultiHost.of(effects, apiHostId)
const apiMultiOrigin = await apiMulti.bindPort(apiPort, {
const multi = sdk.MultiHost.of(effects, 'main')
const origin = await multi.bindPort(apiPort, {
protocol: 'http',
})
const ui = sdk.createInterface(effects, {
name: i18n('Status Page'),
id: 'ui',
description: i18n(
'Enclave attestation state, the available private models, and client setup snippets',
),
type: 'ui',
masked: false,
schemeOverride: null,
username: null,
path: '',
query: {},
})
const api = sdk.createInterface(effects, {
name: i18n('OpenAI-Compatible API'),
id: apiInterfaceId,
id: 'api',
description: i18n(
'Point any OpenAI or Anthropic SDK client at this URL to use PPQ private (TEE) models with end-to-end encryption',
),
type: 'api',
masked: true,
masked: false,
schemeOverride: null,
username: null,
path: '',
query: {},
})
const apiReceipt = await apiMultiOrigin.export([api])
const receipt = await origin.export([ui, api])
return [apiReceipt]
return [receipt]
})
+7 -3
View File
@@ -17,7 +17,7 @@ export const main = sdk.setupMain(async ({ effects }) => {
subcontainer: sdk.SubContainer.of(
effects,
{ imageId: 'proxy' },
sdk.Mounts.of(),
null,
'proxy-sub',
),
exec: {
@@ -36,8 +36,12 @@ export const main = sdk.setupMain(async ({ effects }) => {
display: i18n('Encrypted Proxy'),
fn: () =>
sdk.healthCheck.checkPortListening(effects, apiPort, {
successMessage: i18n('The proxy is ready — enclave attestation verified'),
errorMessage: i18n('The proxy is not ready (enclave attestation pending)'),
successMessage: i18n(
'The proxy is ready — enclave attestation verified',
),
errorMessage: i18n(
'The proxy is not ready (enclave attestation pending)',
),
}),
},
requires: [],
+6 -3
View File
@@ -1,9 +1,12 @@
export const short = {
en_US: 'End-to-end encrypted proxy for PPQ.AI private (TEE) AI models',
es_ES: 'Proxy cifrado de extremo a extremo para los modelos de IA privados (TEE) de PPQ.AI',
de_DE: 'Ende-zu-Ende-verschlüsselter Proxy für private (TEE) KI-Modelle von PPQ.AI',
es_ES:
'Proxy cifrado de extremo a extremo para los modelos de IA privados (TEE) de PPQ.AI',
de_DE:
'Ende-zu-Ende-verschlüsselter Proxy für private (TEE) KI-Modelle von PPQ.AI',
pl_PL: 'Szyfrowany end-to-end proxy dla prywatnych modeli AI (TEE) PPQ.AI',
fr_FR: 'Proxy chiffré de bout en bout pour les modèles IA privés (TEE) de PPQ.AI',
fr_FR:
'Proxy chiffré de bout en bout pour les modèles IA privés (TEE) de PPQ.AI',
}
export const long = {
+1 -1
View File
@@ -5,7 +5,7 @@ export const manifest = setupManifest({
id: 'ppq-private-mode',
title: 'PPQ Private Mode',
license: 'MIT',
packageRepo: 'https://github.com/PayPerQ/ppq-private-mode-startos',
packageRepo: 'https://github.com/Start9-Community/ppq-private-mode-startos',
upstreamRepo: 'https://github.com/PayPerQ/ppq-private-mode-proxy',
marketingUrl: 'https://ppq.ai',
donationUrl: null,
+1 -1
View File
@@ -2,7 +2,7 @@ import { IMPOSSIBLE, VersionInfo } from '@start9labs/start-sdk'
export const current = VersionInfo.of({
// Tracks upstream ppq-private-mode-proxy (package.json version).
version: '0.3.2:0',
version: '0.4.1:0',
releaseNotes: {
en_US: 'Initial release for StartOS',
es_ES: 'Lanzamiento inicial para StartOS',