passcontrol 0.1.2 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,183 +1,132 @@
1
1
  # PassControl
2
2
 
3
- **An identity & credential gateway for AI agents.** Stop pasting your OpenAI / Anthropic /
4
- Groq / Mistral / Together / DeepSeek keys into agent runtimes. Give each agent a cryptographic
5
- **passport**; it signs a challenge to mint a short-lived **work-visa**; the gateway injects your
6
- *real* provider key from a vault and proxies the call — so **the agent never holds the key**.
7
- You get per-agent budgets, capability scopes, an instant kill switch, and a per-agent audit trail.
3
+ **An identity & credential gateway for AI agents.** Stop pasting your OpenAI/Anthropic keys
4
+ into agent runtimes. Give each agent a cryptographic **passport**; it signs a challenge to
5
+ mint a short-lived **work-visa**; the gateway injects your *real* provider key from a vault
6
+ and proxies the call — so the agent never holds the key. You get per-agent budgets, scopes,
7
+ an instant kill switch, and a per-agent audit trail.
8
8
 
9
- A [Vertias](https://vertias.eu) project. **Bring-your-own-key** — your provider key stays in your
10
- own vault. Self-host it today; a managed version comes later.
9
+ A [Vertias](https://vertias.eu) project. **Bring-your-own-key** (you keep your provider key);
10
+ self-host it, or use the managed version when it's available.
11
11
 
12
12
  > ⚠️ **Status: early.** Built by a small team, **not yet independently audited.** It's
13
- > security-focused and test-covered, but treat it as beta — run it against a **non-critical key
14
- > first**, and see [Security](#security) for responsible disclosure. We'd rather you know than
13
+ > security-focused and test-covered, but treat it as beta — run it on a non-critical key
14
+ > first, and see [Security](#security) for responsible disclosure. We'd rather you know than
15
15
  > find out.
16
16
 
17
- **New here?** The [Getting Started tutorial](./TUTORIAL.md) takes you from install to a real
18
- governed agent in ~15 minutes.
19
-
20
- ```bash
21
- npm install -g passcontrol
22
- passcontrol setup # boots the self-hostable stack + opens the Control Tower
23
- ```
24
-
25
17
  ---
26
18
 
27
19
  ## Why
28
-
29
- A raw provider key handed to an autonomous agent **leaks** (logs, repos, prompts), **never
30
- rotates**, has **no per-agent spend cap**, **no off-switch**, and leaves **no record** of which
31
- agent did what. PassControl takes the key out of the agent entirely and puts a governed gateway
32
- in front of it.
20
+ A raw provider key handed to an autonomous agent leaks (logs, repos, prompts), never rotates,
21
+ has no per-agent spend cap, no off-switch, and no record of *which* agent did *what*.
22
+ PassControl removes the key from the agent entirely and puts a governed gateway in front.
33
23
 
34
24
  ## How it works
35
-
36
- 1. **Passport** — each agent holds only an Ed25519 private key. It *only ever signs*; the key
37
- never travels over the wire.
38
- 2. **Work-visa** — the agent signs a challenge (timestamp + single-use nonce) and mints a
39
- short-lived (~5 min) token carrying its identity, scope, and budget snapshot.
40
- 3. **Inject & proxy** — a request arrives bearing a visa. The gateway verifies it → checks the
41
- kill switch → checks scope (provider + model **and** endpoint) → reserves budget atomically →
42
- pulls your provider key from the vault → injects it → forwards to the provider and streams
43
- back. The agent never sees the key.
44
- 4. **Govern** — per-agent **token + dollar** budgets (enforced *before* the call), a layered kill
45
- switch (platform / tenant / per-agent), and an append-only audit log of every call.
46
-
47
- ```
48
- agent ──sign──▶ challenge ──visa──▶ ┌─────────── PassControl gateway ───────────┐
49
- │ verify · kill/scope/budget · inject key │ ──▶ provider
50
- (holds only a passport key) │ (real key from vault, never returned) │ ◀── stream
51
- └────────────────────────────────────────────┘
52
- ```
25
+ 1. **Passport** — each agent holds only an Ed25519 private key; it *only ever signs*, never travels.
26
+ 2. **Work-visa** — the agent signs a challenge (timestamp + single-use nonce) → mints a
27
+ short-lived (5 min) HS256 token carrying its identity, scope, and budget.
28
+ 3. **Inject & proxy** — a request arrives with a visa; the gateway verifies it → checks the
29
+ kill switch → checks scope → reserves budget → pulls your provider key from Supabase Vault
30
+ → injects it → forwards to the provider and streams back. The agent never sees the key.
31
+ 4. **Govern** — per-agent token/cost budgets (enforced), layered kill switch
32
+ (platform / tenant / per-agent), and an append-only audit log of every call.
53
33
 
54
34
  ## Features
35
+ - 🔑 Agents never hold your provider key (BYOK; key stays in the vault, injected in-flight)
36
+ - 🪪 Per-agent cryptographic identity (Ed25519), short-lived revocable visas
37
+ - 💸 Enforced per-agent token/cost budgets (reserved pre-flight, reconciled after)
38
+ - ⛔ Layered, per-tenant kill switch + per-agent suspend
39
+ - 📒 Per-agent / per-passport audit trail (append-only; direct `UPDATE` / `DELETE` /
40
+ `TRUNCATE` rejected by the database)
41
+ - 🧰 Drop-in: point your existing OpenAI/Anthropic/OpenAI-compatible SDK at the gateway
42
+ (OpenAI, Anthropic, Groq, Mistral, Together, DeepSeek)
43
+ - 🔌 MCP server: expose governed `chat` / `list_models` tools to Claude Desktop, Cursor &
44
+ Claude Code — same scope, budget, and kill switch (`passcontrol mcp`)
45
+ - 🖥️ Control Tower dashboard + a developer control-plane API + TOTP MFA
46
+
47
+ ## Quickstart (self-host)
48
+ Stack: **Next.js** (App Router, edge routes) · **Supabase** (Postgres + Vault + Auth) ·
49
+ **Upstash Redis**. Deploy on Vercel or any Node host (`next start`). No Vercel-proprietary
50
+ services are required — the kill switch is Redis-backed.
51
+
52
+ ### Try it in 60 seconds (no key, no signup)
53
+ The lowest-friction way to see what PassControl does — a **governed AI call and a live
54
+ kill switch, with no provider key and no account**. Enable demo mode when you bring the
55
+ local stack up:
55
56
 
56
- - 🔑 **Agents never hold your provider key** — BYOK; the key stays vaulted, injected in-flight only
57
- - 🪪 **Per-agent cryptographic identity** (Ed25519) with short-lived, revocable visas
58
- - 💸 **Enforced per-agent token + cost (USD) budgets** — reserved pre-flight, reconciled after
59
- - 🎯 **Capability scoping** — a visa is scoped to specific models *and* endpoints, so a
60
- chat-scoped agent can't reach files, fine-tuning, batches, embeddings, etc. with your key
61
- - ⛔ **Instant, layered kill switch** + per-agent suspend/revoke — stop a running agent mid-task
62
- - 📒 **Append-only audit trail** per agent/passport (direct `UPDATE`/`DELETE`/`TRUNCATE` rejected
63
- by the database)
64
- - 🧰 **Drop-in for your SDK** (OpenAI, Anthropic, and OpenAI-compatible Groq / Mistral / Together /
65
- DeepSeek) — **or any agent** via the visa sidecar (OpenHands, Aider, Cline, Continue…)
66
- - 🖥️ **Control Tower** dashboard (fleet, spend, budgets, audit, kill switch) + a developer
67
- control-plane API + TOTP MFA
57
+ ```bash
58
+ git clone https://github.com/<you>/passcontrol && cd passcontrol
59
+ npm install
60
+ PASSCONTROL_DEMO=1 npm run dev:stack # local stack + a keyless demo passport
61
+ PASSCONTROL_DEMO=1 npm run dev:docker & # run the gateway with demo mode on
62
+ npx passcontrol try # governed call → arm kill switch → blocked → disarm
63
+ ```
68
64
 
69
- ## Install & first run
65
+ `passcontrol try` runs the **real** pipeline (passport → work-visa → scope + budget
66
+ checks), returns a synthesized `[demo]` response instead of calling a provider, then arms
67
+ the kill switch and shows the same call get blocked — the whole PassControl story in one
68
+ command. Demo mode is **off by default and must never be enabled in production**: the
69
+ keyless `demo` provider is env-gated and never touches the Vault. Ready to use it for
70
+ real? Continue with the full quickstart below.
70
71
 
71
- **Global CLI (recommended):**
72
+ ### Local (Docker) quickstart
73
+ For the fastest local run, use the bundled Docker stack. It starts Supabase locally
74
+ (Postgres + Vault + Auth), Redis-over-REST, applies migrations inside the DB container, and
75
+ seeds a confirmed dev user. Prereqs: Docker Desktop and the Supabase CLI. No host `psql`
76
+ is required.
72
77
 
73
78
  ```bash
74
- npm install -g passcontrol
75
- passcontrol --version # 0.1.1
76
- passcontrol setup # prereq checks → fetches the stack → boots it → opens the dashboard
79
+ git clone https://github.com/<you>/passcontrol && cd passcontrol
80
+ npm install
81
+ npm run dev:stack # starts Supabase + Redis locally, migrates, seeds a dev user
82
+ npm run dev:docker # runs the app against the local stack (loads .env.docker)
77
83
  ```
78
84
 
79
- The published npm package is **just the CLI** (a handful of files, no provider keys). `passcontrol
80
- setup` detects the global install and offers to clone the self-hostable stack (Supabase + Redis +
81
- dashboard) into `~/passcontrol`, install its dependencies, and start it — one command from nothing
82
- to a running Control Tower. It first checks your prerequisites (Docker running, Supabase CLI, Node
83
- version, free ports) and tells you exactly what to fix if something's missing.
85
+ > Use **`npm run dev:docker`**, not `npm run dev`, for the local stack — plain `npm run
86
+ > dev` loads `.env.local` (your hosted Supabase), not the Docker stack's `.env.docker`.
84
87
 
85
- - Change the checkout location: `--app-dir <path>` or `PASSCONTROL_APP_ROOT=<path>`
86
- - Non-interactive: `--yes`
87
- - Skip opening the browser: `--no-open`
88
- - Ports already taken by another local Supabase? `passcontrol setup --port-offset 100`
89
- (offsets Supabase + Redis together, e.g. API `54421`, DB `54422`; the dashboard stays on `:3000`)
90
-
91
- Then log in to the Control Tower at **http://localhost:3000** with the seeded local dev user:
88
+ Open `http://localhost:3000` and log in with:
92
89
 
93
90
  ```text
94
91
  dev@passcontrol.local
95
92
  passcontrol-dev
96
93
  ```
97
94
 
98
- > ⚠️ This seeded user exists **only for the local Docker stack** (created by `scripts/seed.mjs`).
99
- > **Never deploy it or reuse these credentials.** Real deployments create accounts through normal
100
- > signup, gated by `INVITE_CODE`; no default credentials ship.
101
-
102
- Add a **non-critical** provider key in the Control Tower, issue a passport, and copy the one-time
103
- `PASSPORT_ID` / `PASSPORT_SECRET`. Then, in your project directory:
95
+ Then add a provider key in the Control Tower, issue a passport, and run:
104
96
 
105
97
  ```bash
106
- passcontrol init # gateway + passport + provider/model → writes .passcontrol
107
- passcontrol doctor --deep # verifies config, prerequisites, and mints a test visa
108
- passcontrol call "Say hello in 3 words"
109
- passcontrol spend # confirms governed spend
98
+ PASSPORT_ID=<passport_id> PASSPORT_SECRET=<passport_secret> \
99
+ node examples/chat-agent.mjs "Say hello in 3 words"
110
100
  ```
111
101
 
112
- You'll see a streamed response and an `ok` row in the dashboard Audit Log — the complete governed
113
- loop: **passport → visa → vault key injection → proxied call → audit**. That last call uses your
114
- real key from the local Vault, so start with a throwaway one.
102
+ The final agent call uses your real Anthropic/OpenAI key from the local Vault, so start
103
+ with a non-critical key.
115
104
 
116
- > Working from a **source clone** instead of the global install? Everything below works as
117
- > `npm run cli -- <command>`; after `npm link` in the clone, the short `passcontrol <command>` form
118
- > works too.
105
+ ### Manual self-host quickstart
119
106
 
120
- ## Real agents & the visa sidecar
121
-
122
- A visa is deliberately short-lived so it's revocable — but a real coding agent runs a **long,
123
- multi-call session** that would outlive a single visa. The **sidecar** solves this: a tiny local
124
- proxy that mints, caches, and auto-refreshes the visa (and re-mints instantly on expiry), so your
125
- agent points at one stable endpoint and **never times out mid-task**.
107
+ > **Supabase specifically** (not vanilla Postgres): the credential vault uses the
108
+ > `supabase_vault` extension, so you need a Supabase project (hosted or the self-hosted
109
+ > Supabase stack), not a plain Postgres database.
126
110
 
127
111
  ```bash
128
- passcontrol sidecar # http://127.0.0.1:8788
129
- passcontrol env openhands # prints ready-to-paste settings for your agent
112
+ git clone https://github.com/<you>/passcontrol && cd passcontrol
113
+ npm install
114
+ cp .env.example .env.local # fill in Supabase / Upstash / secrets
115
+ DATABASE_URL='postgresql://…' npm run migrate # applies db/migrations/*.sql in order, once each
116
+ npm run dev # or build + `next start` on any Node host
130
117
  ```
118
+ See `.env.example` for the full config (Supabase URL/keys, `VISA_SECRET`, `CACHE_ENC_KEY`,
119
+ Upstash, `CRON_SECRET`, `INVITE_CODE`). Apply migrations `0001 → …` in order;
120
+ `db/tests/rls_invariants.sql` checks tenant isolation on your database.
131
121
 
132
- Point any OpenAI/Anthropic-compatible agent at the sidecar with a **dummy** key:
133
-
134
- ```bash
135
- export ANTHROPIC_BASE_URL="http://127.0.0.1:8788/api/v1/anthropic" # or /api/v1/openai, /deepseek…
136
- export ANTHROPIC_API_KEY="passcontrol" # ignored — the sidecar injects a live visa
137
- ```
122
+ **Background reconcile job (required on non-Vercel hosts):** a periodic call to
123
+ `GET /api/cron/reconcile` (with header `Authorization: Bearer $CRON_SECRET`) corrects budget
124
+ drift and flushes last-seen. On Vercel it's wired via `vercel.json`. Self-hosting, schedule it
125
+ yourself (system `cron`, a GitHub Action, etc.) every few minutes — it's a correction layer,
126
+ not the hot path, so an occasional missed run is harmless.
138
127
 
139
- The agent never holds a real key or a long-lived token. Presets ship for **openhands, aider, cline,
140
- continue, litellm** (`passcontrol env <preset>`). A single long streaming completion also works
141
- directly — it's verified once at the start, so it finishes even if it runs past the visa TTL; only
142
- *multi-call* sessions need the sidecar's refresh. Raise `VISA_TTL_SECONDS` (300–900) to widen the
143
- window, but the sidecar is the real answer for long sessions.
144
-
145
- > If a client defaults to OpenAI `/responses` (some Continue configs for o-series/gpt-5), force
146
- > `/chat/completions` — PassControl intentionally proxies only chat/messages and model-listing
147
- > endpoints.
148
-
149
- ## CLI command center
150
-
151
- The primary interface is `passcontrol <command>`. Highlights:
152
-
153
- | Need | Command |
154
- |---|---|
155
- | Config, gateway status, suggested next steps | `passcontrol status` |
156
- | Check local setup / mint a test visa | `passcontrol doctor --deep` |
157
- | Make a governed model call | `passcontrol call "Summarize this"` |
158
- | Run the auto-refreshing bridge for an agent | `passcontrol sidecar` |
159
- | Print agent settings (OpenHands, Aider, Cline, Continue, LiteLLM) | `passcontrol env openhands` |
160
- | List / create agents | `passcontrol agent list` · `passcontrol agent create billing-bot` |
161
- | Suspend, resume, or revoke an agent | `passcontrol agent suspend <id>` |
162
- | Inspect spend, logs, and audit history | `passcontrol spend` · `passcontrol logs` · `passcontrol audit` |
163
- | Arm / release the tenant kill switch | `passcontrol kill on` · `passcontrol kill off` |
164
- | Prepare or repair local services | `passcontrol setup` · `passcontrol doctor --fix` |
165
- | Manage the local dashboard | `passcontrol start` · `passcontrol stop` · `passcontrol restart` |
166
- | Follow local dashboard logs | `passcontrol local-logs --follow` |
167
- | Open the Control Tower | `passcontrol open` |
168
- | Preview/write an agent config | `passcontrol configure aider` · `passcontrol configure aider --write` |
169
-
170
- Config resolves in order: **environment variables → project-local `.passcontrol` →
171
- `~/.config/passcontrol/config`**. `.passcontrol` holds a passport secret, is gitignored, and is
172
- written owner-only — never commit or share it.
173
-
174
- `passcontrol reset --local --confirm RESET` destroys and recreates local data — use it only for a
175
- clean slate.
176
-
177
- ## Using it from your own code
178
-
179
- The client SDK (vendored in [`./sdk`](./sdk)) hides the visa dance — point your provider SDK at the
180
- gateway and visas auto-refresh:
128
+ ## Using it from an agent
129
+ The client SDK hides the visa dance — point your provider SDK at the gateway:
181
130
 
182
131
  ```ts
183
132
  import OpenAI from "openai";
@@ -187,7 +136,10 @@ const pc = new PassControl({ gateway, passportId, passportSecret });
187
136
  const openai = new OpenAI(pc.clientOptions("openai")); // baseURL + auth wired; visas auto-refresh
188
137
  ```
189
138
 
190
- Manage the fleet programmatically with the control-plane SDK + an API key:
139
+ The SDK is vendored in this repo under `./sdk`; it is not a separately published npm package
140
+ yet.
141
+
142
+ Manage the fleet programmatically with the control-plane SDK + API key:
191
143
 
192
144
  ```ts
193
145
  import { ControlClient } from "./sdk";
@@ -196,92 +148,55 @@ await cp.agents.list();
196
148
  await cp.killSwitch.set(true);
197
149
  ```
198
150
 
199
- The SDK is not a separately published npm package yet. Full API reference:
200
- [`openapi.yaml`](./openapi.yaml) and [`DOCUMENTATION.md`](./DOCUMENTATION.md). Runnable example
201
- agents live in [`examples/`](./examples).
202
-
203
- ## Self-host
204
-
205
- Stack: **Next.js** (App Router, edge routes) · **Supabase** (Postgres + Vault + Auth) · **Upstash /
206
- any Redis**. Deploy on Vercel or any Node host (`next start`). No Vercel-proprietary services are
207
- required — the kill switch is Redis-backed.
151
+ Full API reference: [`openapi.yaml`](./openapi.yaml) and [`DOCUMENTATION.md`](./DOCUMENTATION.md).
152
+ Runnable example agents in [`examples/`](./examples).
208
153
 
209
- ### Local (Docker) — the fastest path
154
+ ## Use it from Claude Desktop, Cursor, or Claude Code (MCP)
155
+ `passcontrol mcp` runs a local [MCP](https://modelcontextprotocol.io) server that exposes two
156
+ tools — `chat` and `list_models` — to any MCP client. Every `chat` goes through the gateway,
157
+ so the provider key stays server-side and the passport's scope, budget, and kill switch all
158
+ apply. The client sees the model's response, never your key.
210
159
 
211
- `passcontrol setup` (above) is the one-command route. Under the hood it runs the bundled Docker
212
- stack: local Supabase (Postgres + Vault + Auth), Redis-over-REST, migrations applied inside the DB
213
- container, and a seeded dev user. Prereqs: **Docker Desktop, the Supabase CLI, Node 18+** — no host
214
- `psql` required.
215
-
216
- From a source checkout you can drive the same thing directly:
160
+ Set it up once. Your passport lives in a single trusted local file; the client config never
161
+ holds a secret:
217
162
 
218
163
  ```bash
219
- git clone https://github.com/Vertias3u/PassControl && cd PassControl
220
- npm install
221
- npm run cli -- setup # or: passcontrol setup after `npm link`
164
+ passcontrol init --global # store the passport once (~/.config/passcontrol)
165
+ passcontrol configure claude-desktop --write # merge a secret-free MCP entry into the client
166
+ # then restart Claude Desktop
222
167
  ```
223
168
 
224
- ### Manual self-host
225
-
226
- > **Supabase specifically** (not vanilla Postgres): the credential vault uses the `supabase_vault`
227
- > extension, so you need a Supabase project — hosted or the self-hosted Supabase stack — not a
228
- > plain Postgres database.
229
-
230
- ```bash
231
- git clone https://github.com/Vertias3u/PassControl && cd PassControl
232
- npm install
233
- cp .env.example .env.local # fill in Supabase / Redis / secrets
234
- DATABASE_URL='postgresql://…' npm run migrate # applies db/migrations/*.sql in order, once each
235
- npm run dev # or build + `next start` on any Node host
236
- ```
237
-
238
- See [`.env.example`](./.env.example) for the full config (Supabase URL/keys, `VISA_SECRET`,
239
- `CACHE_ENC_KEY`, Redis, `CRON_SECRET`, `INVITE_CODE`). Apply migrations `0001 → …` in order;
240
- [`db/tests/rls_invariants.sql`](./db/tests/rls_invariants.sql) checks tenant isolation and the
241
- privileged-column locks on your database.
242
-
243
- **Background reconcile job (required on non-Vercel hosts):** a periodic `GET /api/cron/reconcile`
244
- (header `Authorization: Bearer $CRON_SECRET`) corrects budget drift and flushes last-seen. On
245
- Vercel it's wired via `vercel.json`; elsewhere schedule it yourself (system `cron`, a GitHub
246
- Action…) every few minutes. It's a correction layer, not the hot path — an occasional missed run is
247
- harmless.
248
-
249
- ## Providers & endpoints
250
-
251
- Supported providers: **OpenAI, Anthropic, Groq, Mistral, Together, DeepSeek**. The gateway proxies
252
- **only chat and model-listing endpoints** — OpenAI-shaped chat completions + models, Anthropic
253
- messages + models, DeepSeek chat completions. It does **not** proxy embeddings, files, fine-tuning,
254
- batches, `/responses`, or token-counting endpoints (that's the point — a leaked visa can't reach
255
- your full provider surface).
169
+ Swap `claude-desktop` for `cursor`, or for Claude Code run the printed
170
+ `claude mcp add --scope user passcontrol -- passcontrol mcp`. Ask the client to use the `chat`
171
+ tool and the call is governed end-to-end — arm the kill switch and the next tool call is
172
+ refused. Run `passcontrol env claude-desktop` to preview the config without writing it.
256
173
 
257
174
  ## Limitations
258
-
259
- - A work-visa is a **bearer token**, reusable until it expires (≤5 min). Keep it out of logs and
260
- prompts; use suspend/kill to block future requests immediately.
261
- - **Pricing** is a best-effort in-code table and can lag provider price changes. Use it for budgets
262
- and monitoring, not billing reconciliation against provider invoices.
263
- - **Instant revocation** assumes Redis is configured for persistence / no-eviction. If Redis evicts
264
- suspend/kill keys, enforcement falls back to short visa TTLs and the durable agent-status check at
265
- the next mint.
175
+ - A work-visa is a bearer token and is reusable until it expires (≤5 minutes). Keep it out
176
+ of logs and prompts; use suspend/kill switches to block future requests.
177
+ - The gateway proxies only chat and model-listing endpoints: OpenAI/Groq/Mistral/Together
178
+ chat completions and models, Anthropic messages and models, and DeepSeek chat
179
+ completions. It does **not** proxy embeddings, files, fine-tuning, batches, responses, or
180
+ token-counting endpoints.
181
+ - Pricing is a best-effort in-code table and can lag provider price changes. Use it for
182
+ budgets and monitoring, not as billing reconciliation against provider invoices.
183
+ - Instant revocation assumes Redis is configured for persistence/no-eviction behavior. If
184
+ Redis evicts suspend/kill keys, enforcement falls back to short visa TTLs and durable agent
185
+ status checks at the next mint.
266
186
 
267
187
  ## Security
268
-
269
- Security is the whole point, so please report issues privately rather than opening a public issue:
270
- **security@vertias.eu**. We'll acknowledge and work with you on a fix + disclosure timeline.
271
-
272
- - It's **BYOK** — your provider key lives encrypted in your own Supabase Vault, decrypted only
273
- in-flight and cached briefly (encrypted) in your own Redis. It is never logged or returned.
274
- - Tenant isolation is enforced by Postgres **RLS on every table**; the sole decrypt path is a
275
- `SECURITY DEFINER`, service-role-only function.
188
+ Security is the point of this project, so please report issues privately rather than opening
189
+ a public issue: **security@vertias.eu**. We'll acknowledge and work with you on a fix +
190
+ disclosure timeline. Notes:
191
+ - It's **BYOK** — your provider key lives encrypted in your own Supabase Vault; it's
192
+ decrypted only in-flight and cached briefly (encrypted) in your own Redis.
276
193
  - It is **not yet independently audited.** If you find a hole, you're doing us a favor.
277
194
 
278
195
  ## License
279
-
280
196
  Source-available under the **Business Source License (BSL 1.1)** — read it, run it, modify it,
281
197
  self-host it. The one restriction: you may not offer it as a competing hosted/managed service.
282
198
  Converts to Apache 2.0 after the change date. See [`LICENSE`](./LICENSE).
283
199
 
284
200
  ## Contributing
285
-
286
201
  Issues and PRs welcome. Run `npm run typecheck && npm test && npm run build` before a PR (CI
287
- enforces it). Be kind — this is early.
202
+ enforces it). Be kind; this is early.