Merge pull request #1 from Start9-Community/audit/upstream-0.4.1-and-conformance

bump upstream to 0.4.1, add the status page UI, fix CI branch triggers
This commit is contained in:
Matt Hill authored and GitHub committed 2026-08-12 10:16:45 -06:00
commit afce65a734
20 files changed
+347 -229

No files matched your search

+1 -3
View File
@@ -4,7 +4,7 @@ on:
workflow_dispatch: workflow_dispatch:
pull_request: pull_request:
paths-ignore: ['*.md'] paths-ignore: ['*.md']
branches: ['master'] branches: ['main']
concurrency: concurrency:
group: ${{ github.workflow }}-${{ github.head_ref || github.ref }} group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
@@ -14,6 +14,4 @@ jobs:
build: build:
if: github.event.pull_request.draft == false if: github.event.pull_request.draft == false
uses: Start9Labs/start-technologies/.github/workflows/build.yml@master 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. # 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*.*' - 'v*.*'
jobs: 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: release:
needs: guard
if: needs.guard.outputs.id != 'hello-world'
uses: Start9Labs/start-technologies/.github/workflows/release.yml@master uses: Start9Labs/start-technologies/.github/workflows/release.yml@master
with: with:
# FREE_DISK_SPACE: true
RELEASE_REGISTRY: ${{ vars.RELEASE_REGISTRY }} RELEASE_REGISTRY: ${{ vars.RELEASE_REGISTRY }}
S3_S9PKS_BASE_URL: ${{ vars.S3_S9PKS_BASE_URL }} S3_S9PKS_BASE_URL: ${{ vars.S3_S9PKS_BASE_URL }}
secrets: secrets:
+1 -15
View File
@@ -2,7 +2,7 @@ name: Tag and Release
on: on:
push: push:
branches: ['master'] branches: ['main']
paths-ignore: ['*.md'] paths-ignore: ['*.md']
concurrency: concurrency:
@@ -10,24 +10,10 @@ concurrency:
cancel-in-progress: true cancel-in-progress: true
jobs: 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: tag:
needs: guard
if: needs.guard.outputs.id != 'hello-world'
uses: Start9Labs/start-technologies/.github/workflows/tagAndRelease.yml@master uses: Start9Labs/start-technologies/.github/workflows/tagAndRelease.yml@master
with: with:
REFERENCE_REGISTRY: ${{ vars.REFERENCE_REGISTRY }} REFERENCE_REGISTRY: ${{ vars.REFERENCE_REGISTRY }}
# FREE_DISK_SPACE: true
RELEASE_REGISTRY: ${{ vars.RELEASE_REGISTRY }} RELEASE_REGISTRY: ${{ vars.RELEASE_REGISTRY }}
S3_S9PKS_BASE_URL: ${{ vars.S3_S9PKS_BASE_URL }} S3_S9PKS_BASE_URL: ${{ vars.S3_S9PKS_BASE_URL }}
secrets: secrets:
+76 -28
View File
@@ -46,44 +46,84 @@ Architectures: `x86_64`, `aarch64`.
## Volume and Data Layout ## Volume and Data Layout
One volume, `main`, holding only `config.json` (the StartOS-managed settings One volume, `main`, split so the container sees only what it owns:
file containing the API key and logging preference), read and written by the
SDK on the host side. The proxy itself is stateless and the volume is **not** | Host path | Container path | Written by |
mounted into the container — configuration reaches the daemon via environment | ------------------- | ------------------- | ------------------------------------------------ |
variables only. | `proxy/config.json` | `/data/config.json` | the proxy (Status Page) **and** the SDK (action) |
| `store.json` | not mounted | the SDK only |
`proxy/` is mounted at `/data` as the proxy's `PPQ_DATA_DIR`, and `config.json`
inside it is upstream's own file — the proxy rewrites it wholesale when a key is
saved from the Status Page, so nothing of ours may live there. The Verbose
Logging setting therefore lives in `store.json`, outside the mount.
A `chown` oneshot hands `/data` to the image's unprivileged `node` user before
the daemon starts, so the Status Page can write to it.
## Installation and First-Run Flow ## Installation and First-Run Flow
On install, a critical task prompts for a PPQ.AI API key. The service cannot On install, an **important** (non-blocking) task prompts for a PPQ.AI API key.
start until the key is provided (upstream exits immediately without There are two ways to satisfy it, and neither is required before starting:
`PPQ_API_KEY`). There is no other setup.
1. Run the **Configure PPQ API Key** action.
2. Start the service and save the key on the **Status Page**.
The proxy runs without a key — it completes attestation, serves the Status Page,
and answers `401` to inference requests until one is set. The task is
deliberately not critical: a critical task suspends every other control, which
would leave the user unable to start the service and reach the Status Page's own
key form.
## Configuration Management ## Configuration Management
All upstream configuration is via environment variables; StartOS manages them The API key is the proxy's to own. StartOS does **not** pass `PPQ_API_KEY`;
from `config.json`: instead it points `PPQ_DATA_DIR` at the mounted volume so upstream's key store
is the single source of truth, written by either the action or the Status Page
and read from the same file by both.
- `PPQ_API_KEY` — set from the **Configure PPQ API Key** action - `PPQ_DATA_DIR` — `/data`, enabling persistence and the Status Page's key form
- `DEBUG` — set from the same action's Verbose Logging toggle - `DEBUG` — set from the action's Verbose Logging toggle, via `store.json`
- `HOST` — fixed to `0.0.0.0` (container binding) - `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_API_BASE` — not set (upstream default `https://api.ppq.ai`)
Changing settings restarts the daemon (values are read reactively). The proxy loads `config.json` once at startup, so `main.ts` watches the file:
writing a key restarts the daemon, which reloads it. A key saved on the Status
Page takes effect immediately in the running proxy and then triggers that same
restart — brief, and it converges on the value just saved either way.
## Network Access and Interfaces ## Network Access and Interfaces
One interface, `api` (port 8787, HTTP): the upstream OpenAI-compatible API, Two interfaces on one HTTP host, port 8787, both served by the proxy:
shown as a copyable connection string. Endpoints: `GET /health`,
`GET /v1/models`, `POST /v1/chat/completions` (OpenAI format), - **Status Page** (`ui`) — upstream's server-rendered page at `/`: attestation
`POST /v1/messages` (Anthropic format). Availability on LAN/Tor is decided by state (enclave host and code fingerprint), API-key status, the private model
the user from the interface panel. 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.
**No endpoint is authenticated.** Upstream ships no auth on any route, so
whoever can reach the port can spend the user's PPQ.AI balance via
`/v1/chat/completions`, and — because this package sets `PPQ_DATA_DIR` — can
also replace the stored key via `POST /setup/api-key`
([upstream #23](https://github.com/PayPerQ/ppq-private-mode-proxy/issues/23)).
The billing exposure predates that endpoint and is inherent to the proxy; the
key-replacement one is enabled by our `PPQ_DATA_DIR` choice, and closes when
upstream's patch lands and this package bumps to it. `instructions.md` warns
the user to expose the interface accordingly.
## Actions (StartOS UI) ## Actions (StartOS UI)
- **Configure PPQ API Key** (`configure-api-key`) — sets the PPQ.AI API key - **Configure PPQ API Key** (`configure-api-key`) — visible and enabled at any
(masked, never echoed back) and the Verbose Logging toggle. Available at any service status. Inputs: the PPQ.AI API key (masked, validated against
service status. Also the target of the critical first-run task. upstream's `^sk-[A-Za-z0-9]{16,64}$` shape; left blank it keeps the key
already saved and is never echoed back into the form) and the Verbose Logging
toggle. No result output. Also the target of the first-run task.
## Backups and Restore ## Backups and Restore
@@ -108,16 +148,21 @@ None.
1. This service is a client-side encryption proxy, not a self-hosted model 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 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). 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. Saving a key on the Status Page restarts the daemon a few seconds later.
The proxy applies the key immediately; the restart is StartOS reacting to
the same file write, and is what makes the **Configure PPQ API Key** action
work at all (upstream reads `config.json` only at startup).
3. The upstream OpenClaw-plugin mode is not packaged; only the standalone
proxy runs on StartOS. proxy runs on StartOS.
3. The bind address and port are fixed (`0.0.0.0:8787` inside the container); 4. The bind address and port are fixed inside the container; upstream's
upstream's `HOST`/`PORT`/`PPQ_API_BASE` variables are not user-configurable. `HOST`/`PORT`/`PPQ_API_BASE` variables are not user-configurable.
## What Is Unchanged from Upstream ## What Is Unchanged from Upstream
- All API endpoints, request/response formats, and streaming behavior - All API endpoints, request/response formats, and streaming behavior
- The encryption and attestation flow (EHBP transport via the `tinfoil` client) - The encryption and attestation flow (EHBP transport via the `tinfoil` client)
- Model catalog and per-request `Authorization: Bearer` key override - Model catalog and per-request `Authorization: Bearer` key override
- The status page rendered at `/`, its API-key form included
## Contributing ## Contributing
@@ -131,12 +176,15 @@ See [AGENTS.md](AGENTS.md).
package_id: ppq-private-mode package_id: ppq-private-mode
architectures: [x86_64, aarch64] architectures: [x86_64, aarch64]
volumes: volumes:
main: /data main: /data # subpath `proxy/` only; `store.json` stays host-side
ports: ports:
api: 8787 main: 8787 # one host serving both interfaces
interfaces:
- ui
- api
dependencies: none dependencies: none
startos_managed_env_vars: startos_managed_env_vars:
- PPQ_API_KEY - PPQ_DATA_DIR
- HOST - HOST
- PORT - PORT
- DEBUG - DEBUG
-9
View File
@@ -1,9 +0,0 @@
# 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).
+15 -9
View File
@@ -2,14 +2,15 @@
Upstream is [PayPerQ/ppq-private-mode-proxy](https://github.com/PayPerQ/ppq-private-mode-proxy), 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 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 ## Determining the upstream version
```bash ```bash
git -C ppq-private-mode-proxy fetch origin git -C ppq-private-mode-proxy fetch origin --tags
git -C ppq-private-mode-proxy log --oneline HEAD..origin/main # anything new? git -C ppq-private-mode-proxy describe --tags HEAD # current pin
jq -r .version ppq-private-mode-proxy/package.json # 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: 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 ## Applying the bump
1. Advance the submodule: `git -C ppq-private-mode-proxy checkout origin/main` 1. Advance the submodule: `git -C ppq-private-mode-proxy checkout v<version>`
2. Update `version` in `startos/versions/current.ts` to the new upstream 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 `package.json` version with revision `:0` (bump only the revision for
packaging-only changes), and write release notes. packaging-only changes), and write release notes in every locale.
3. Rebuild and test: `make x86` (or `make arm`), install, verify attestation 4. Rebuild and test: `make x86` (or `make arm`), install, verify attestation
completes and a `/v1/models` request succeeds. completes, the Status Page loads, and a `/v1/models` request succeeds.
+53 -17
View File
@@ -5,21 +5,46 @@
- [Upstream proxy documentation](https://github.com/PayPerQ/ppq-private-mode-proxy) — endpoints, client examples, and how the encryption works - [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 - [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.
It is also where you can save your API key.
- **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 ## Getting set up
1. When the service is installed, you will be prompted to run **Configure PPQ You need a funded API key from [ppq.ai](https://ppq.ai) — create one under
API Key**. Paste an API key from [ppq.ai](https://ppq.ai) (create one under **Settings → API Keys**, since usage is billed per query to that key. You can
**Settings → API Keys** and fund the account — usage is billed per query to save it before or after starting the service; the proxy runs either way and
this key). simply refuses inference requests until it has one.
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.
## Using the proxy 1. Start the service. It performs a cryptographic attestation of the remote
enclave, which the health check reports as ready — usually within a few
seconds.
2. Open the **Status Page**, confirm attestation says _verified_, and paste your
key into the API key form. The proxy picks it up immediately, then restarts
once to persist it.
3. Copy the **OpenAI-Compatible API** address to point a client at it.
Point any OpenAI-compatible client at the interface address: If you would rather not start the service first, run the **Configure PPQ API
Key** action instead of step 2 — it does the same thing from the Actions tab.
## Using PPQ Private Mode
### Connecting a client
Point any OpenAI-compatible client at the API address:
``` ```
POST <api-address>/v1/chat/completions POST <api-address>/v1/chat/completions
@@ -34,16 +59,27 @@ export ANTHROPIC_BASE_URL="<api-address>"
export ANTHROPIC_MODEL="private/glm-5-2" export ANTHROPIC_MODEL="private/glm-5-2"
``` ```
`GET <api-address>/v1/models` lists the available private models. Every `GET <api-address>/v1/models` lists the available private models, and the Status
request is encrypted on your server before it leaves and is only decrypted Page shows the same list.
inside the attested enclave — neither PPQ.AI nor the model host can read your
queries.
Requests are billed to your saved API key by default. To bill a different 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. 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 ### Replacing the key
**Configure PPQ API Key** again from the service's Actions.
Either surface works, and both write the same place: **Replace key** on the
Status Page, or the **Configure PPQ API Key** action. The action is also where
you turn Verbose Logging on and off; leaving its key field blank keeps the key
you already saved.
## Limitations
**The proxy has no login of its own, so only expose it to people you trust.**
Anyone who can reach the address can send requests that are billed to your
PPQ.AI key, and can replace the stored key from the Status Page. On a LAN-only
address that means everyone on your network; if you enable a Tor or public
address, it means anyone with the address. Keeping it on the LAN, or on Tor with
the address kept private, is the safe default.
Backups of this service include your saved API key, and restoring a backup Backups of this service include your saved API key, and restoring a backup
restores it — keep that in mind when handling backup drives. restores it — keep that in mind when handling backup drives.
+17 -20
View File
@@ -1,5 +1,6 @@
import { sdk } from '../sdk' import { sdk } from '../sdk'
import { configJson } from '../fileModels/config.json' import { configJson } from '../fileModels/config.json'
import { storeJson } from '../fileModels/store.json'
import { i18n } from '../i18n' import { i18n } from '../i18n'
const { InputSpec, Value } = sdk const { InputSpec, Value } = sdk
@@ -8,12 +9,21 @@ const inputSpec = InputSpec.of({
apiKey: Value.text({ apiKey: Value.text({
name: i18n('PPQ.AI API Key'), name: i18n('PPQ.AI API Key'),
description: i18n( description: i18n(
'Your API key from ppq.ai (Settings → API Keys). Leave blank to keep the key already saved.', 'Your API key from ppq.ai (Settings → API Keys). Leave blank to keep the key already saved, or to set one later from the Status Page.',
), ),
required: false, required: false,
default: null, default: null,
masked: true, masked: true,
placeholder: 'sk-...', placeholder: 'sk-...',
// Upstream's own shape check, applied here too — the Status Page rejects a
// malformed key outright, but a key written straight to config.json would
// only surface as a 401 on the first request.
patterns: [
{
regex: '^sk-[A-Za-z0-9]{16,64}$',
description: i18n('A PPQ.AI key starts with "sk-".'),
},
],
}), }),
debug: Value.toggle({ debug: Value.toggle({
name: i18n('Verbose Logging'), name: i18n('Verbose Logging'),
@@ -41,27 +51,14 @@ export const configureApiKey = sdk.Action.withInput(
inputSpec, inputSpec,
// Prefill: the API key is never echoed back into the form. // Prefill: the API key is never echoed back into the form.
async ({ effects }) => { async ({ effects }) => ({
const debug = await configJson debug: (await storeJson.read((s) => s.debug).once()) ?? false,
.read((c) => c.debug) }),
.once()
.catch(() => false)
return { debug: debug ?? false }
},
async ({ effects, input }) => { async ({ effects, input }) => {
const existingKey = await configJson await storeJson.merge(effects, { debug: input.debug })
.read((c) => c.apiKey)
.once()
.catch(() => undefined)
const apiKey = (input.apiKey ?? '').trim() || existingKey const apiKey = (input.apiKey ?? '').trim()
if (!apiKey) { if (apiKey) await configJson.merge(effects, { apiKey })
throw new Error(
i18n('An API key is required. Create one at ppq.ai under Settings → API Keys.'),
)
}
await configJson.merge(effects, { apiKey, debug: input.debug })
}, },
) )
+5 -5
View File
@@ -1,15 +1,15 @@
import { FileHelper, z } from '@start9labs/start-sdk' import { FileHelper, z } from '@start9labs/start-sdk'
import { sdk } from '../sdk' import { sdk } from '../sdk'
// Package-owned settings file on the main volume. The upstream proxy is // Upstream's own persistent config, at <PPQ_DATA_DIR>/config.json. The proxy
// configured purely through environment variables; main.ts bridges these // loads the key from here at startup and rewrites the whole file when one is
// values into the daemon's env. // saved from the status page, so this shape must stay exactly upstream's and
// nothing else may live in it — see fileModels/store.json.ts.
const shape = z.object({ const shape = z.object({
apiKey: z.string().optional().catch(undefined), apiKey: z.string().optional().catch(undefined),
debug: z.boolean().catch(false),
}) })
export const configJson = FileHelper.json( export const configJson = FileHelper.json(
{ base: sdk.volumes.main, subpath: 'config.json' }, { base: sdk.volumes.main, subpath: 'proxy/config.json' },
shape, shape,
) )
+13
View File
@@ -0,0 +1,13 @@
import { FileHelper, z } from '@start9labs/start-sdk'
import { sdk } from '../sdk'
// Package-owned settings, kept outside the mounted PPQ_DATA_DIR subtree so the
// proxy neither sees them nor overwrites them.
const shape = z.object({
debug: z.boolean().catch(false),
})
export const storeJson = FileHelper.json(
{ base: sdk.volumes.main, subpath: 'store.json' },
shape,
)
+12 -10
View File
@@ -7,18 +7,20 @@ const dict = {
'The proxy is ready — enclave attestation verified': 2, 'The proxy is ready — enclave attestation verified': 2,
'The proxy is not ready (enclave attestation pending)': 3, 'The proxy is not ready (enclave attestation pending)': 3,
// interfaces.ts // interfaces.ts
'OpenAI-Compatible API': 4, 'Status Page': 4,
'Point any OpenAI or Anthropic SDK client at this URL to use PPQ private (TEE) models with end-to-end encryption': 5, '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 // actions/configureApiKey.ts
'PPQ.AI API Key': 6, 'PPQ.AI API Key': 8,
'Your API key from ppq.ai (Settings → API Keys). Leave blank to keep the key already saved.': 7, 'Your API key from ppq.ai (Settings → API Keys). Leave blank to keep the key already saved, or to set one later from the Status Page.': 9,
'Verbose Logging': 8, 'A PPQ.AI key starts with "sk-".': 10,
'Log every request the proxy handles. Useful for troubleshooting.': 9, 'Verbose Logging': 11,
'Configure PPQ API Key': 10, 'Log every request the proxy handles. Useful for troubleshooting.': 12,
'Set the PPQ.AI API key the proxy uses to authenticate. Requests are billed to this key.': 11, 'Configure PPQ API Key': 13,
'An API key is required. Create one at ppq.ai under Settings → API Keys.': 12, 'Set the PPQ.AI API key the proxy uses to authenticate. Requests are billed to this key.': 14,
// init/taskConfigureApiKey.ts // init/taskConfigureApiKey.ts
'Add your PPQ.AI API key to start the proxy': 13, 'Add your PPQ.AI API key here, or start the service and save one on the Status Page': 15,
} as const } as const
/** /**
+48 -40
View File
@@ -6,63 +6,71 @@ export default {
1: 'Proxy cifrado', 1: 'Proxy cifrado',
2: 'El proxy está listo — atestación del enclave verificada', 2: 'El proxy está listo — atestación del enclave verificada',
3: 'El proxy no está listo (atestación del enclave pendiente)', 3: 'El proxy no está listo (atestación del enclave pendiente)',
4: 'API compatible con OpenAI', 4: 'Página de estado',
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', 5: 'Estado de la atestación del enclave, los modelos privados disponibles y fragmentos de configuración para clientes',
6: 'Clave API de PPQ.AI', 6: 'API compatible con OpenAI',
7: 'Tu clave API de ppq.ai (Ajustes → Claves API). Déjalo en blanco para conservar la clave ya guardada.', 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: 'Registro detallado', 8: 'Clave API de PPQ.AI',
9: 'Registra cada solicitud que maneja el proxy. Útil para diagnosticar problemas.', 9: 'Tu clave API de ppq.ai (Ajustes → Claves API). Déjalo en blanco para conservar la clave ya guardada, o para configurar una más tarde desde la Página de estado.',
10: 'Configurar clave API de PPQ', 10: 'Una clave de PPQ.AI empieza por «sk-».',
11: 'Establece la clave API de PPQ.AI que el proxy usa para autenticarse. Las solicitudes se facturan a esta clave.', 11: 'Registro detallado',
12: 'Se requiere una clave API. Crea una en ppq.ai en Ajustes → Claves API.', 12: 'Registra cada solicitud que maneja el proxy. Útil para diagnosticar problemas.',
13: 'Añade tu clave API de PPQ.AI para iniciar el proxy', 13: 'Configurar clave API de PPQ',
14: 'Establece la clave API de PPQ.AI que el proxy usa para autenticarse. Las solicitudes se facturan a esta clave.',
15: 'Añade aquí tu clave API de PPQ.AI, o inicia el servicio y guárdala en la Página de estado',
}, },
de_DE: { de_DE: {
0: 'Starte PPQ Private Mode!', 0: 'Starte PPQ Private Mode!',
1: 'Verschlüsselter Proxy', 1: 'Verschlüsselter Proxy',
2: 'Der Proxy ist bereit — Enklave-Attestierung verifiziert', 2: 'Der Proxy ist bereit — Enklave-Attestierung verifiziert',
3: 'Der Proxy ist nicht bereit (Enklave-Attestierung ausstehend)', 3: 'Der Proxy ist nicht bereit (Enklave-Attestierung ausstehend)',
4: 'OpenAI-kompatible API', 4: 'Statusseite',
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', 5: 'Status der Enklave-Attestierung, die verfügbaren privaten Modelle und Codeschnipsel zur Client-Einrichtung',
6: 'PPQ.AI-API-Schlüssel', 6: 'OpenAI-kompatible API',
7: 'Dein API-Schlüssel von ppq.ai (Einstellungen → API-Schlüssel). Leer lassen, um den bereits gespeicherten Schlüssel zu behalten.', 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: 'Ausführliche Protokollierung', 8: 'PPQ.AI-API-Schlüssel',
9: 'Protokolliert jede Anfrage, die der Proxy verarbeitet. Nützlich zur Fehlersuche.', 9: 'Dein API-Schlüssel von ppq.ai (Einstellungen → API-Schlüssel). Leer lassen, um den bereits gespeicherten Schlüssel zu behalten oder später auf der Statusseite einen festzulegen.',
10: 'PPQ-API-Schlüssel konfigurieren', 10: 'Ein PPQ.AI-Schlüssel beginnt mit „sk-“.',
11: 'Lege den PPQ.AI-API-Schlüssel fest, mit dem sich der Proxy authentifiziert. Anfragen werden diesem Schlüssel in Rechnung gestellt.', 11: 'Ausführliche Protokollierung',
12: 'Ein API-Schlüssel ist erforderlich. Erstelle einen auf ppq.ai unter Einstellungen → API-Schlüssel.', 12: 'Protokolliert jede Anfrage, die der Proxy verarbeitet. Nützlich zur Fehlersuche.',
13: 'Füge deinen PPQ.AI-API-Schlüssel hinzu, um den Proxy zu starten', 13: 'PPQ-API-Schlüssel konfigurieren',
14: 'Lege den PPQ.AI-API-Schlüssel fest, mit dem sich der Proxy authentifiziert. Anfragen werden diesem Schlüssel in Rechnung gestellt.',
15: 'Füge deinen PPQ.AI-API-Schlüssel hier hinzu, oder starte den Dienst und speichere ihn auf der Statusseite',
}, },
pl_PL: { pl_PL: {
0: 'Uruchamianie PPQ Private Mode!', 0: 'Uruchamianie PPQ Private Mode!',
1: 'Szyfrowany proxy', 1: 'Szyfrowany proxy',
2: 'Proxy jest gotowy — atestacja enklawy zweryfikowana', 2: 'Proxy jest gotowy — atestacja enklawy zweryfikowana',
3: 'Proxy nie jest gotowy (atestacja enklawy w toku)', 3: 'Proxy nie jest gotowy (atestacja enklawy w toku)',
4: 'API zgodne z OpenAI', 4: 'Strona stanu',
5: 'Skieruj dowolnego klienta SDK OpenAI lub Anthropic na ten URL, aby korzystać z prywatnych modeli (TEE) PPQ z szyfrowaniem end-to-end', 5: 'Stan atestacji enklawy, dostępne modele prywatne oraz fragmenty konfiguracji dla klientów',
6: 'Klucz API PPQ.AI', 6: 'API zgodne z OpenAI',
7: 'Twój klucz API z ppq.ai (Ustawienia → Klucze API). Pozostaw puste, aby zachować już zapisany klucz.', 7: 'Skieruj dowolnego klienta SDK OpenAI lub Anthropic na ten URL, aby korzystać z prywatnych modeli (TEE) PPQ z szyfrowaniem end-to-end',
8: 'Szczegółowe logowanie', 8: 'Klucz API PPQ.AI',
9: 'Rejestruje każde żądanie obsługiwane przez proxy. Przydatne przy rozwiązywaniu problemów.', 9: 'Twój klucz API z ppq.ai (Ustawienia → Klucze API). Pozostaw puste, aby zachować już zapisany klucz lub ustawić go później na Stronie stanu.',
10: 'Skonfiguruj klucz API PPQ', 10: 'Klucz PPQ.AI zaczyna się od „sk-”.',
11: 'Ustaw klucz API PPQ.AI, którym proxy się uwierzytelnia. Żądania są rozliczane na ten klucz.', 11: 'Szczegółowe logowanie',
12: 'Wymagany jest klucz API. Utwórz go na ppq.ai w Ustawienia → Klucze API.', 12: 'Rejestruje każde żądanie obsługiwane przez proxy. Przydatne przy rozwiązywaniu problemów.',
13: 'Dodaj swój klucz API PPQ.AI, aby uruchomić proxy', 13: 'Skonfiguruj klucz API PPQ',
14: 'Ustaw klucz API PPQ.AI, którym proxy się uwierzytelnia. Żądania są rozliczane na ten klucz.',
15: 'Dodaj tutaj swój klucz API PPQ.AI albo uruchom usługę i zapisz go na Stronie stanu',
}, },
fr_FR: { fr_FR: {
0: 'Démarrage de PPQ Private Mode !', 0: 'Démarrage de PPQ Private Mode !',
1: 'Proxy chiffré', 1: 'Proxy chiffré',
2: "Le proxy est prêt — attestation de l'enclave vérifiée", 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)", 3: "Le proxy n'est pas prêt (attestation de l'enclave en attente)",
4: 'API compatible OpenAI', 4: "Page d'état",
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", 5: "État de l'attestation de l'enclave, les modèles privés disponibles et des extraits de configuration client",
6: 'Clé API PPQ.AI', 6: 'API compatible OpenAI',
7: 'Votre clé API de ppq.ai (Paramètres → Clés API). Laissez vide pour conserver la clé déjà enregistrée.', 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: 'Journalisation détaillée', 8: 'Clé API PPQ.AI',
9: 'Journalise chaque requête traitée par le proxy. Utile pour le dépannage.', 9: "Votre clé API de ppq.ai (Paramètres → Clés API). Laissez vide pour conserver la clé déjà enregistrée, ou pour en définir une plus tard depuis la Page d'état.",
10: 'Configurer la clé API PPQ', 10: 'Une clé PPQ.AI commence par « sk- ».',
11: "Définissez la clé API PPQ.AI avec laquelle le proxy s'authentifie. Les requêtes sont facturées sur cette clé.", 11: 'Journalisation détaillée',
12: 'Une clé API est requise. Créez-en une sur ppq.ai dans Paramètres → Clés API.', 12: 'Journalise chaque requête traitée par le proxy. Utile pour le dépannage.',
13: 'Ajoutez votre clé API PPQ.AI pour démarrer le proxy', 13: 'Configurer la clé API PPQ',
14: "Définissez la clé API PPQ.AI avec laquelle le proxy s'authentifie. Les requêtes sont facturées sur cette clé.",
15: "Ajoutez ici votre clé API PPQ.AI, ou démarrez le service et enregistrez-la sur la Page d'état",
}, },
} satisfies Record<string, LangDict> } satisfies Record<string, LangDict>
+10 -9
View File
@@ -3,17 +3,18 @@ import { configJson } from '../fileModels/config.json'
import { configureApiKey } from '../actions/configureApiKey' import { configureApiKey } from '../actions/configureApiKey'
import { i18n } from '../i18n' import { i18n } from '../i18n'
// The proxy cannot start without a PPQ.AI API key, so a critical task blocks // The proxy starts and serves its Status Page without a key, answering 401 to
// startup until the user provides one. // inference requests until one is set. So this prompt is important rather than
export const taskConfigureApiKey = sdk.setupOnInit(async (effects, kind) => { // critical: a critical task suspends every other control, which would leave the
const apiKey = await configJson // user unable to start the service and reach the Status Page's own key form.
.read((c) => c.apiKey) export const taskConfigureApiKey = sdk.setupOnInit(async (effects) => {
.once() const apiKey = await configJson.read((c) => c.apiKey).once()
.catch(() => undefined)
if (!apiKey) { if (!apiKey) {
await sdk.action.createOwnTask(effects, configureApiKey, 'critical', { await sdk.action.createOwnTask(effects, configureApiKey, 'important', {
reason: i18n('Add your PPQ.AI API key to start the proxy'), reason: i18n(
'Add your PPQ.AI API key here, or start the service and save one on the Status Page',
),
}) })
} }
}) })
+19 -10
View File
@@ -2,30 +2,39 @@ import { sdk } from './sdk'
import { apiPort } from './utils' import { apiPort } from './utils'
import { i18n } from './i18n' 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 }) => { export const setInterfaces = sdk.setupInterfaces(async ({ effects }) => {
const apiMulti = sdk.MultiHost.of(effects, apiHostId) const multi = sdk.MultiHost.of(effects, 'main')
const apiMultiOrigin = await apiMulti.bindPort(apiPort, { const origin = await multi.bindPort(apiPort, {
protocol: 'http', 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, { const api = sdk.createInterface(effects, {
name: i18n('OpenAI-Compatible API'), name: i18n('OpenAI-Compatible API'),
id: apiInterfaceId, id: 'api',
description: i18n( description: i18n(
'Point any OpenAI or Anthropic SDK client at this URL to use PPQ private (TEE) models with end-to-end encryption', 'Point any OpenAI or Anthropic SDK client at this URL to use PPQ private (TEE) models with end-to-end encryption',
), ),
type: 'api', type: 'api',
masked: true, masked: false,
schemeOverride: null, schemeOverride: null,
username: null, username: null,
path: '', path: '',
query: {}, query: {},
}) })
const apiReceipt = await apiMultiOrigin.export([api]) const receipt = await origin.export([ui, api])
return [apiReceipt] return [receipt]
}) })
+64 -34
View File
@@ -1,45 +1,75 @@
import { i18n } from './i18n' import { i18n } from './i18n'
import { sdk } from './sdk' import { sdk } from './sdk'
import { apiPort } from './utils' import { manifest } from './manifest'
import { apiPort, dataDir } from './utils'
import { configureApiKey } from './actions/configureApiKey'
import { configJson } from './fileModels/config.json' import { configJson } from './fileModels/config.json'
import { storeJson } from './fileModels/store.json'
export const main = sdk.setupMain(async ({ effects }) => { export const main = sdk.setupMain(async ({ effects }) => {
console.info(i18n('Starting PPQ Private Mode!')) console.info(i18n('Starting PPQ Private Mode!'))
// Read reactively so the daemon restarts when the user changes settings. // The proxy reads config.json once at startup, so watching it is what makes a
// key saved by the Configure PPQ API Key action take effect: the write
// restarts the daemon, which reloads the file. PPQ_API_KEY is left unset so
// the proxy's own key store is the only thing that owns the key.
const apiKey = await configJson.read((c) => c.apiKey).const(effects) const apiKey = await configJson.read((c) => c.apiKey).const(effects)
const debug = await configJson.read((c) => c.debug).const(effects) const debug = await storeJson.read((s) => s.debug).const(effects)
return sdk.Daemons.of(effects).addDaemon('proxy', { // Running the action clears its own task, but a key saved on the Status Page
// The proxy is stateless and fully configured via env — the 'main' volume // never touches the action — so clear it here, on the restart that same save
// (config.json, read host-side by the SDK) is never mounted into the // triggers. Otherwise StartOS keeps asking for a key the user already set.
// container. if (apiKey) {
subcontainer: sdk.SubContainer.of( await sdk.action.clearTask(effects, `${manifest.id}:${configureApiKey.id}`)
effects, }
{ imageId: 'proxy' },
sdk.Mounts.of(), const subcontainer = sdk.SubContainer.of(
'proxy-sub', effects,
), { imageId: 'proxy' },
exec: { sdk.Mounts.of().mountVolume({
command: ['node', '/app/dist/bin/server.js'], volumeId: 'main',
env: { subpath: 'proxy',
PPQ_API_KEY: apiKey ?? '', mountpoint: dataDir,
HOST: '0.0.0.0', readonly: false,
PORT: apiPort.toString(), }),
DEBUG: debug ? 'true' : 'false', 'proxy-sub',
)
return sdk.Daemons.of(effects)
.addOneshot('chown', {
subcontainer,
exec: {
command: ['chown', '-R', 'node:node', dataDir],
user: 'root',
}, },
}, requires: [],
// The proxy only binds its port after remote attestation of the enclave })
// succeeds, so a listening port means the encrypted channel is verified .addDaemon('proxy', {
// and ready. subcontainer,
ready: { exec: {
display: i18n('Encrypted Proxy'), command: ['node', '/app/dist/bin/server.js'],
fn: () => env: {
sdk.healthCheck.checkPortListening(effects, apiPort, { PPQ_DATA_DIR: dataDir,
successMessage: i18n('The proxy is ready — enclave attestation verified'), HOST: '0.0.0.0',
errorMessage: i18n('The proxy is not ready (enclave attestation pending)'), PORT: apiPort.toString(),
}), DEBUG: debug ? 'true' : 'false',
}, },
requires: [], },
}) // The proxy only binds its port after remote attestation of the enclave
// succeeds, so a listening port means the encrypted channel is verified
// and ready.
ready: {
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)',
),
}),
},
requires: ['chown'],
})
}) })
+6 -3
View File
@@ -1,9 +1,12 @@
export const short = { export const short = {
en_US: 'End-to-end encrypted proxy for PPQ.AI private (TEE) AI models', 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', es_ES:
de_DE: 'Ende-zu-Ende-verschlüsselter Proxy für private (TEE) KI-Modelle von PPQ.AI', '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', 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 = { export const long = {
+1 -1
View File
@@ -5,7 +5,7 @@ export const manifest = setupManifest({
id: 'ppq-private-mode', id: 'ppq-private-mode',
title: 'PPQ Private Mode', title: 'PPQ Private Mode',
license: 'MIT', 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', upstreamRepo: 'https://github.com/PayPerQ/ppq-private-mode-proxy',
marketingUrl: 'https://ppq.ai', marketingUrl: 'https://ppq.ai',
donationUrl: null, donationUrl: null,
+4
View File
@@ -2,3 +2,7 @@
// Port the proxy listens on inside the container (upstream default). // Port the proxy listens on inside the container (upstream default).
export const apiPort = 8787 export const apiPort = 8787
// Upstream's PPQ_DATA_DIR inside the container: where it persists the API key
// saved from the status page.
export const dataDir = '/data'
+1 -1
View File
@@ -2,7 +2,7 @@ import { IMPOSSIBLE, VersionInfo } from '@start9labs/start-sdk'
export const current = VersionInfo.of({ export const current = VersionInfo.of({
// Tracks upstream ppq-private-mode-proxy (package.json version). // Tracks upstream ppq-private-mode-proxy (package.json version).
version: '0.3.2:0', version: '0.4.1:0',
releaseNotes: { releaseNotes: {
en_US: 'Initial release for StartOS', en_US: 'Initial release for StartOS',
es_ES: 'Lanzamiento inicial para StartOS', es_ES: 'Lanzamiento inicial para StartOS',