adopt 0.4's persistent key store and browser setup form

The earlier bump took 0.4.1 for its model catalog and status page but
left PPQ_DATA_DIR unset, which disabled the key form the release exists
to add. Enable it, and let the proxy own the key outright.

PPQ_API_KEY is no longer passed. The volume's `proxy/` subpath mounts at
/data as PPQ_DATA_DIR, so upstream's key store is the single source of
truth: the Status Page and the Configure PPQ API Key action write the
same config.json, and there is no StartOS-side copy to revert what the
browser saved. A chown oneshot hands /data to the image's `node` user so
the page can write there.

Verbose Logging moves to store.json outside the mount, because upstream
rewrites config.json wholesale when a key is saved and would drop it.

main.ts watches config.json — upstream loads it once at startup, so the
watch is what makes the action take effect: the write restarts the
daemon, which reloads the file. A key saved on the page applies
immediately and converges through the same restart.

The task drops from critical to important. A critical task suspends
every other control, so it would have left the user unable to start the
service and reach the page's own form — and with PPQ_DATA_DIR set the
proxy no longer exits keyless; it attests, serves the page, and answers
401 until a key exists. main.ts clears the task when a key appears,
since saving on the page never touches the action that would clear it.

The action's key field is now validated against upstream's own
^sk-[A-Za-z0-9]{16,64}$ shape and no longer refuses a blank submission,
a key having become optional.
This commit is contained in:
helix-nine committed 2026-08-12 09:58:35 -06:00
1 parent 42b2841945
commit 8397c7b1eb
10 files changed
+187 -114

No files matched your search

+46 -28
View File
@@ -46,33 +46,52 @@ Architectures: `x86_64`, `aarch64`.
## Volume and Data Layout
One volume, `main`, holding only `config.json` (the StartOS-managed settings
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**
mounted into the container — configuration reaches the daemon via environment
variables only.
One volume, `main`, split so the container sees only what it owns:
| Host path | Container path | Written by |
| ------------------- | ------------------- | ------------------------------------------------ |
| `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
On install, a critical task prompts for a PPQ.AI API key. The service cannot
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.
On install, an **important** (non-blocking) task prompts for a PPQ.AI API key.
There are two ways to satisfy it, and neither is required before starting:
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
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`.
The API key is the proxy's to own. StartOS does **not** pass `PPQ_API_KEY`;
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
- `DEBUG` — set from the same action's Verbose Logging toggle
- `PPQ_DATA_DIR` — `/data`, enabling persistence and the Status Page's key form
- `DEBUG` — set from the action's Verbose Logging toggle, via `store.json`
- `HOST` — fixed to `0.0.0.0` (container binding)
- `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).
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
@@ -91,10 +110,10 @@ Availability on LAN/Tor is decided by the user from the interface panel.
## Actions (StartOS UI)
- **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.
service status. Inputs: the PPQ.AI API key (masked, validated against
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
@@ -119,11 +138,10 @@ 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 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.
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.
4. The bind address and port are fixed inside the container; upstream's
@@ -134,7 +152,7 @@ None.
- 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
- The status page rendered at `/`, its API-key form included
## Contributing
@@ -148,7 +166,7 @@ See [AGENTS.md](AGENTS.md).
package_id: ppq-private-mode
architectures: [x86_64, aarch64]
volumes:
main: null # host-side config.json only; not mounted into the container
main: /data # subpath `proxy/` only; `store.json` stays host-side
ports:
main: 8787 # one host serving both interfaces
interfaces:
@@ -156,7 +174,7 @@ interfaces:
- api
dependencies: none
startos_managed_env_vars:
- PPQ_API_KEY
- PPQ_DATA_DIR
- HOST
- PORT
- DEBUG
+23 -17
View File
@@ -16,6 +16,7 @@ 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
@@ -23,14 +24,21 @@ setting.
## Getting set up
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. Open the **Status Page** to confirm attestation succeeded, or copy the
**OpenAI-Compatible API** address to point a client at it.
You need a funded 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
save it before or after starting the service; the proxy runs either way and
simply refuses inference requests until it has one.
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.
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
@@ -51,22 +59,20 @@ export ANTHROPIC_BASE_URL="<api-address>"
export ANTHROPIC_MODEL="private/glm-5-2"
```
`GET <api-address>/v1/models` lists the available private models, and the
Status Page shows the same list.
`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.
### Actions
### Replacing the key
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.
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 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.
+15 -13
View File
@@ -1,5 +1,6 @@
import { sdk } from '../sdk'
import { configJson } from '../fileModels/config.json'
import { storeJson } from '../fileModels/store.json'
import { i18n } from '../i18n'
const { InputSpec, Value } = sdk
@@ -8,12 +9,21 @@ const inputSpec = InputSpec.of({
apiKey: Value.text({
name: i18n('PPQ.AI API Key'),
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,
default: null,
masked: true,
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({
name: i18n('Verbose Logging'),
@@ -42,21 +52,13 @@ export const configureApiKey = sdk.Action.withInput(
// Prefill: the API key is never echoed back into the form.
async ({ effects }) => ({
debug: (await configJson.read((c) => c.debug).once()) ?? false,
debug: (await storeJson.read((s) => s.debug).once()) ?? false,
}),
async ({ effects, input }) => {
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.',
),
)
}
await storeJson.merge(effects, { debug: input.debug })
await configJson.merge(effects, { apiKey, debug: input.debug })
const apiKey = (input.apiKey ?? '').trim()
if (apiKey) await configJson.merge(effects, { apiKey })
},
)
+5 -5
View File
@@ -1,15 +1,15 @@
import { FileHelper, z } from '@start9labs/start-sdk'
import { sdk } from '../sdk'
// Package-owned settings file on the main volume. The upstream proxy is
// configured purely through environment variables; main.ts bridges these
// values into the daemon's env.
// Upstream's own persistent config, at <PPQ_DATA_DIR>/config.json. The proxy
// loads the key from here at startup and rewrites the whole file when one is
// 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({
apiKey: z.string().optional().catch(undefined),
debug: z.boolean().catch(false),
})
export const configJson = FileHelper.json(
{ base: sdk.volumes.main, subpath: 'config.json' },
{ base: sdk.volumes.main, subpath: 'proxy/config.json' },
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,
)
+7 -7
View File
@@ -13,14 +13,14 @@ const dict = {
'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': 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,
'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,
'A PPQ.AI key starts with "sk-".': 10,
'Verbose Logging': 11,
'Log every request the proxy handles. Useful for troubleshooting.': 12,
'Configure PPQ API Key': 13,
'Set the PPQ.AI API key the proxy uses to authenticate. Requests are billed to this key.': 14,
// init/taskConfigureApiKey.ts
'Add your PPQ.AI API key to start the proxy': 15,
'Add your PPQ.AI API key here, or start the service and save one on the Status Page': 15,
} as const
/**
+28 -28
View File
@@ -11,13 +11,13 @@ export default {
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',
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: 'Una clave de PPQ.AI empieza por «sk-».',
11: 'Registro detallado',
12: 'Registra cada solicitud que maneja el proxy. Útil para diagnosticar problemas.',
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: {
0: 'Starte PPQ Private Mode!',
@@ -29,13 +29,13 @@ export default {
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',
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: 'Ein PPQ.AI-Schlüssel beginnt mit „sk-“.',
11: 'Ausführliche Protokollierung',
12: 'Protokolliert jede Anfrage, die der Proxy verarbeitet. Nützlich zur Fehlersuche.',
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: {
0: 'Uruchamianie PPQ Private Mode!',
@@ -47,13 +47,13 @@ export default {
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',
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: 'Klucz PPQ.AI zaczyna się od „sk-”.',
11: 'Szczegółowe logowanie',
12: 'Rejestruje każde żądanie obsługiwane przez proxy. Przydatne przy rozwiązywaniu problemów.',
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: {
0: 'Démarrage de PPQ Private Mode !',
@@ -65,12 +65,12 @@ export default {
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',
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: 'Une clé PPQ.AI commence par « sk- ».',
11: 'Journalisation détaillée',
12: 'Journalise chaque requête traitée par le proxy. Utile pour le dépannage.',
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>
+8 -4
View File
@@ -3,14 +3,18 @@ import { configJson } from '../fileModels/config.json'
import { configureApiKey } from '../actions/configureApiKey'
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.
// The proxy starts and serves its Status Page without a key, answering 401 to
// inference requests until one is set. So this prompt is important rather than
// 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.
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', {
reason: i18n('Add your PPQ.AI API key to start the proxy'),
await sdk.action.createOwnTask(effects, configureApiKey, 'important', {
reason: i18n(
'Add your PPQ.AI API key here, or start the service and save one on the Status Page',
),
})
}
})
+38 -12
View File
@@ -1,29 +1,55 @@
import { i18n } from './i18n'
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 { storeJson } from './fileModels/store.json'
export const main = sdk.setupMain(async ({ effects }) => {
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 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', {
// The proxy is stateless and fully configured via env — the 'main' volume
// (config.json, read host-side by the SDK) is never mounted into the
// container.
subcontainer: sdk.SubContainer.of(
// Running the action clears its own task, but a key saved on the Status Page
// never touches the action — so clear it here, on the restart that same save
// triggers. Otherwise StartOS keeps asking for a key the user already set.
if (apiKey) {
await sdk.action.clearTask(effects, `${manifest.id}:${configureApiKey.id}`)
}
const subcontainer = sdk.SubContainer.of(
effects,
{ imageId: 'proxy' },
null,
sdk.Mounts.of().mountVolume({
volumeId: 'main',
subpath: 'proxy',
mountpoint: dataDir,
readonly: false,
}),
'proxy-sub',
),
)
return sdk.Daemons.of(effects)
.addOneshot('chown', {
subcontainer,
exec: {
command: ['chown', '-R', 'node:node', dataDir],
user: 'root',
},
requires: [],
})
.addDaemon('proxy', {
subcontainer,
exec: {
command: ['node', '/app/dist/bin/server.js'],
env: {
PPQ_API_KEY: apiKey ?? '',
PPQ_DATA_DIR: dataDir,
HOST: '0.0.0.0',
PORT: apiPort.toString(),
DEBUG: debug ? 'true' : 'false',
@@ -44,6 +70,6 @@ export const main = sdk.setupMain(async ({ effects }) => {
),
}),
},
requires: [],
requires: ['chown'],
})
})
+4
View File
@@ -2,3 +2,7 @@
// Port the proxy listens on inside the container (upstream default).
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'