Primora/CHANGELOG.md

Changelog

All notable changes to Primora. Format follows Keep a Changelog; versions follow SemVer.

[Unreleased]

Fixed

• Self-hosted sign-up works on any origin — trusted origins are now derived from the request's public host (forwarded by nginx), so browsing the instance via a LAN IP, hostname, or custom port no longer fails every auth POST with a 403. Static VITE_APP_URL/AUTH_BASE_URL origins and BETTER_AUTH_TRUSTED_ORIGINS still apply.
• Sign-up/sign-in failures are surfaced, not swallowed — better-auth resolves { data, error } instead of throwing, so a failed request previously showed "Account created — signing you in" and bounced back to the bootstrap screen. The real server error (invalid origin, rate limit, disabled sign-up) is now displayed.
• Mail probe can no longer break auth — hasMailTransport degrades to "no transport" instead of throwing when core.settings is unreadable, and the no-transport startup backfill is best-effort. Previously, auth could crash-loop while the backend was still migrating on a fresh volume — every sign-up 502'd during the window.

[0.8.1] - 2026-09-28

Fixed

• SMTP-less instances no longer involve email at all — when no mail transport is configured (no Resend key, no SMTP_HOST), new accounts are created emailVerified=true, the verification send is skipped entirely, and existing unverified users are marked verified on startup. .env.example no longer defaults SMTP_HOST to the dev-only mailpit service, which left production deploys pointing at a transport that does not exist.

[0.8.0] - 2026-09-28

Added

• Agent setup prompt — a "Set up with an AI agent" dialog that mints a fresh write-scoped API key (ingest + reads + non-admin mutations, never key-minting) and renders a copyable prompt handing a coding agent everything it needs: the deployment endpoint, project id, the key itself, plus tasks to instrument error/metric/log/heartbeat reporting per component (POST /api/v1/ingest — works from any language), register the app's databases via db-connections (postgres → cassandra), wire the MCP server / CLI for future agents, and verify with a test event + deploy marker. Opens at the end of the new-project onboarding and is re-reachable from the project dashboard and Projects page; keys are shown only inside the prompt (revoke under Settings → API keys).
• Local secrets vault in the CLI (@primora/cli 0.6.0) — primora vault init/status and primora secrets set|get|list|rm|import manage an encrypted ~/.config/primora/vault.bin (Argon2id 64 MiB/3/4 → XChaCha20-Poly1305, header bound as AEAD AAD, atomic writes). Entries carry value + optional url/notes metadata. Password via PRIMORA_VAULT_PASSWORD, --password-file, or hidden prompt; file path overridable with PRIMORA_VAULT. Clean-room format — no external vault compatibility.
• Vault sessions — primora vault unlock --ttl 900 proves the password once and writes a TTL'd vault.session (0600); agents and scripts use the vault without the password. primora vault lock revokes immediately.
• primora agent credential broker — wraps a child process with dummy tokens and a loopback base URL; the proxy attaches the real secret on the wire per grant (TTL, cap 3600 s). Presets: anthropic, openai, openrouter, groq, deepseek, xai, github, npm; --upstream name=https://… covers arbitrary Bearer APIs. Base-URL broker, not TLS MITM — tools must honor a base-URL override.
• primora inject — runs a child process with vault secrets in its environment (--all, or --env-file templates containing primora://NAME refs). Nothing on disk, nothing in argv.
• primora stack:* operator group — up, down, status, logs [service], pull, backup wrap docker compose in --dir (default cwd). stack up --vault materializes .env from the vault for the duration of the run (refuses to clobber an existing .env without --force, which swaps and restores it). stack backup writes a pg_dump -Fc of the platform database to ./backups.
• Vault MCP tools (@primora/mcp) — primora_vault_status, primora_vault_list (metadata only — values are never returned), and primora_vault_exec which runs primora commands with a secret injected into the child environment; vault/secrets/inject/agent/login/logout/use and keys:create are denied so no response can carry a credential. (Hardened to a strict allow-list — see Security.)
• Secrets Vault window in the desktop app (@primora/desktop) — tray "Secrets Vault…" opens a dedicated window (ui/vault.html) covering init, timed unlock/lock with live countdown, secret list with copy-to-clipboard (values never displayed), add/delete, and .env import. IPC shells out to the primora binary (PRIMORA_CLI overrides), so desktop and terminal share one vault file and one crypto implementation; a missing CLI shows install guidance. Also reachable from the connect screen.
• Project vault — server-side secrets (core.project_secrets, migration 00011) — per-project secrets encrypted AES-256-GCM at rest via the existing encryptor. API: GET/PUT/DELETE /projects/:projectID/secrets[/:name] plus POST …/reveal. Lists return metadata only (name, url, notes, timestamps); reveal decrypts explicitly and is audit-logged (secret.set/secret.revealed/secret.deleted). Scheduled-job payloads reference secrets as secret://NAME, resolved to plaintext at delivery — refs are stored, values are not; unresolved or unconfigured refs fail the run loudly.
• Vault page in the dashboard — project secrets table with create/update, .env import, delete, and copy-to-clipboard reveal; plus a "This machine" card when running inside the desktop shell that drives the local vault through the same Tauri IPC commands as the vault window.
• CLI remote mode — primora secrets set|get|list|rm|import --remote operates on the project vault via the existing API auth (--project overrides). get --remote is the explicit reveal path; list --remote never returns values.
• Project-vault MCP tools — primora_secrets_list (metadata only) and primora_secrets_set (write-only). No reveal or delete tools — agents consume secrets through secret://NAME references in job payloads without holding plaintext.
• Realtime channel subscriptions (@primora/client) — createRealtimeClient({ endpoint, key, projectId }) opens the project SSE stream (/realtime/stream) via fetch + ReadableStream (EventSource can't send X-API-Key). channel("documents").on("created", cb) subscribes by event namespace (document/object/issue/deploy, "*" for all); auto-reconnects with capped exponential backoff; onStateChange reports connecting|open|reconnecting|closed.
• Telemetry alert rules (core.alert_rules, migration 00012) — heartbeat_silence (component quiet for N minutes) and error_spike (≥N errors in a sliding window) rules per project, evaluated every 60 s. Rules fire on state transitions only: alert.fired once when breached, alert.resolved on recovery — both are first-class webhook event types and ride the existing signed dispatcher + realtime stream. API: GET/POST /projects/:id/alerts, PUT/DELETE …/alerts/:ruleID; dashboard manages them from Integrations → Webhooks; firing shows the breached components.
• Inbound webhooks (core.inbound_hooks, migration 00013) — public ingest endpoints POST /api/v1/hooks/<token> (the token is the credential). event mode republishes the body as inbound.received domain events through the signed dispatcher + realtime; job mode triggers a scheduled-job run with the received body as its payload (triggered_by: "hook"). Optional secret requires X-Primora-Signature HMAC-SHA256 — the same scheme outbound deliveries use. Bodies capped at 256 KiB. Managed from Integrations → Webhooks.
• Document filtering and ordering — GET /collections/:id/documents accepts filter (comma-separated field.op.value; ops eq neq gt gte lt lte like in is; dotted paths index into document data, id/created_at/updated_at filterable) and order (field.asc|field.desc list). Whitelisted parsing + parameterized values; plain lists unchanged. CLI: primora documents list --collection <slug> --filter … --order ….
• HA scheduler leadership — the job scheduler and alert evaluator each hold a session-scoped PostgreSQL advisory lock on a dedicated pinned connection, so multiple backend replicas scan for due work exactly once; manual and hook-triggered runs remain available on any replica. Leadership is released on shutdown and fails over automatically when a replica dies — verified live with a two-replica test.
• Email templates + send log (core.email_log, migration 00014) — the mailer renders registered templates (currently invitation) and every send — successful or failed — is recorded with template, recipient, subject, status, and error text. GET /projects/:id/emails lists recent sends; the Members page shows an "Email log" card under pending invitations.
• S3-compatible object storage backend — BACKEND_STORAGE_DRIVER=s3 swaps the local disk store for any S3-compatible API (AWS, MinIO, Garage, R2) via a stdlib-only SigV4 implementation — no AWS SDK dependency. S3_ENDPOINT/S3_REGION/S3_BUCKET/credentials configure it; S3_PATH_STYLE (default on) covers MinIO/Garage, off for AWS virtual-hosted. The configured bucket is created on startup if missing; objects stream with computed SHA-256, storage_path records s3://bucket/key. Verified live end-to-end (bucket → put → get → copy → list → delete).
• Functions (core.functions + core.function_runs, migration 00015) — project-scoped JS/TS executed by a runtime binary on the backend host (bun or deno, per function). The JSON payload arrives on stdin and as PRIMORA_PAYLOAD; stdout/stderr are captured per run (capped at 64 KiB) with status, exit code and duration — FUNCTIONS_RUNTIME/FUNCTIONS_TIMEOUT_SECONDS/FUNCTIONS_MAX_OUTPUT_BYTES configure the runner. API: CRUD under /projects/:id/functions, POST …/invoke (502 + recorded run on failure), GET …/runs. Dashboard gains a Functions page: code editor, JSON payload invoke, live result, run history. Code executes with backend privileges — the documented self-hosted trust model.
• Presigned object URLs — POST /buckets/:bucketID/object-presigns mints SigV4 query-signed GET/PUT URLs (60 s–1 h TTL) so clients transfer large objects directly against S3 without proxying through the backend. Read role for downloads (object must exist — no key probing), write role for uploads. S3_PUBLIC_ENDPOINT rewrites the client-facing host for internal S3_ENDPOINTs; signatures bind the host so URLs are valid only where they were minted. The local driver returns a clear error — a presigned URL needs a real object API.
• Desktop auto-updater — tauri-plugin-updater wired end to end: minisign keypair, createUpdaterArtifacts, latest.json manifest built from signed artifacts on every release, and a silent background check on the connect screen offering "Update & restart" (download → verify → install → relaunch). Unsigned artifacts can never install — missing signature means no manifest, not a bypass. CI signs via TAURI_SIGNING_PRIVATE_KEY secrets; OS-level signing (notarization/Authenticode) remains open.
• Release SBOMs — CycloneDX SBOM for each published GHCR image (backend/auth/frontend) plus one for the source tree, attached to every GitHub Release via anchore/sbom-action.
• Sandboxed function driver — FUNCTIONS_DRIVER=docker runs every invoke in an ephemeral locked-down container: no network, read-only rootfs, 128 MiB memory, 0.5 CPU, 64 pids, non-root, all capabilities dropped. Source is injected via base64 env (no bind mount — works on Docker Desktop and remote daemons); timeout force-removes the container so nothing lingers. Verified live: code runs, network is unreachable inside, and deadline kills land.
• Client events + presence — POST /projects/:id/events publishes client-authored events (custom.* namespace enforced — system types can't be spoofed) through the same fan-out as system events: realtime subscribers, matching webhooks, and event_pattern functions all fire. Realtime now tracks presence: presence.update {online} broadcasts on every subscribe/unsubscribe (stream-only — never reaches webhooks or functions), GET …/realtime/presence reads the count. Client SDK gains publish() and presence(); CLI gains events:send.
• Function triggers (migration 00016) — three new ways to run a function, all through the same executor and run log. Scheduled jobs accept function_id instead of url (run status mirrors the exit code); inbound hooks gain mode: "function" — the received body becomes the function's stdin payload, acked immediately with the run recorded async; and event_pattern on a function (document.*, *, or an exact type) fires it detached whenever a matching domain event publishes — {event, project_id, occurred_at, data} as payload. Runs record trigger source: manual/schedule/hook/event. Dashboard: function event-trigger field, job target picker (URL or function), and inbound-hook function mode.
• GET /api/v1/context — actor self-discovery: for API keys returns scopes, key prefix, and the resolved organization + project (id/slug/name). Fixes the API-key onboarding dead end: primora login --api-key now validates the key against the instance before saving and seeds org/project context automatically; primora use, context, and whoami work under API-key auth via this endpoint.
• CLI orgs:rm / projects:rm / buckets:rm — destructive deletes gated behind --yes in non-interactive mode, interactive confirm otherwise. buckets:rm resolves id/slug/name.
• Webhook wildcard subscriptions — events accepts *, <namespace>.*, and custom.* patterns, matched at dispatch time via SQL LIKE — the same semantics function event_pattern already used. Client-published custom.* events can now be webhooked.

Security

• primora_vault_exec rewritten as an allow-list — the deny-list was bypassed by colon-form commands (["secrets:get","X"] as a single token evaded the pair check), exposing every vault secret; --remote variants revealed project secrets; and the secret param was used verbatim as an env name, allowing NODE_OPTIONS=--require <file> host code execution. Now only a fixed read-mostly command set runs (whoami, context, orgs:list, projects:list, buckets:list, objects:list, documents:list, jobs:list, jobs:runs, audit:list, keys:list, events:send), path/file flags and .. args are rejected, injected env names must match ^[A-Z_][A-Z0-9_]{0,63}$, and loader-hook names (NODE_*, LD_*, DYLD_*, PATH, BASH*, PYTHON*, GIT_*, SSL_CERT*, XDG_*, …) are blocked. Verified: every prior bypass denied, allowed commands still inject.
• SSRF hardening on webhook/job URLs — cloud metadata endpoints (169.254.169.254, fd00:ec2::254) are excluded from the link-local/private allowance, and pure decimal/hex "bare hostnames" (2130706433, 0x7f000001 — non-canonical IP encodings of loopback) are no longer treated as Docker service names.
• Path params now encodeURIComponent in all generated-client consumers (CLI, MCP, dashboard) — encodeURI left ?#& intact, smuggling query segments through {name} params (e.g. secrets/a?reveal=1).
• Strict base64 in primora_upload_object — Buffer.from(b64) silently drops invalid characters; contentBase64 is now validated (whitespace-tolerant) so corrupt input can't silently store garbage bytes.
• MCP no-creds startup — a missing config/API key previously threw inside configureClient, killing the process mid-handshake (protocol hang, stack on stderr). Startup now degrades: initialize/tools/list answer normally and every tool call returns the actionable error.

Fixed

• Silent CLI dispatch — unknown commands, a bare primora, and group names without a verb exited 0 with no output. Now: unknown input errors with exit 1 (bare groups list their verbs), bare primora prints help.
• Arg-parser numeric coercion — cac/mri coerced numeric-looking flag values (--value "007" → 7, --value "" → 0), corrupting secrets and keys. Parsed options are now re-read as raw strings from argv for every non-boolean flag; --value 007 round-trips intact.
• pgx.ErrNoRows → 404 in the shared error mapper — missing resources returned raw "no rows in result set" 500s across all handlers.
• Structured error hygiene — pgconn.PgError codes map to clean statuses (23505 → 409 "resource already exists", 23503 → 409, 22001/54000 → 400 "value too large", 22021 → 400) instead of leaking SQLSTATE/constraint names; validator failures report field is required/field failed <tag> validation; a new services.InputError type maps service-layer input failures to 400 (webhook URL/event-type errors were 500s). Presign on the local driver returns presign_unsupported 400.
• fetch failed polish — connection failures report the cause code and suggest primora context instead of bare undici errors.
• login --json — the flag now emits JSON on both the session and API-key paths.
• Dashboard fonts vendored — Geist/Geist Mono now ship via @fontsource inside the bundle instead of a Google Fonts <link> the nginx CSP blocked (style-src 'self'). Removes the runtime Google dependency, works airgapped, and eliminates the console CSP violation.
• Release image builds moved off QEMU — arm64 npm ci under docker/setup-qemu-action SIGILLed on current node:20-alpine layers (uncaught target signal 4) and wedged the build step for over an hour. Images now build per-arch on native runners (ubuntu-24.04-arm for arm64) and a manifests job joins them into the multi-arch :<version>/:latest tags.

[0.7.1] - 2026-09-23

Fixed

• Self-hosted sign-up no longer requires mail infrastructure — sendTransactionalEmail warned-and-returned when no transport was configured instead of throwing, so SMTP-less instances 500'd on sign-up. sendVerificationEmail now also catches transport failures; a broken SMTP cannot block account creation (verification stays optional).
• Password managers detect the login form — the email/password fields gained id/name attributes and label for/id pairing, and the email input uses autocomplete="username" (Proton Pass et al.).
• Installer prebuilt path strips build blocks — install.sh previously kept *-build compose blocks when pulling prebuilt GHCR images.

Added

• Static landing page (landing/) — self-contained marketing site with bundled Geist fonts and product screenshots; deployed separately from the app artifacts.

Infrastructure

• Automatic releases on merge — merges to master whose root package.json version has no matching v* tag now trigger the full release pipeline (GHCR images, CLI binaries, desktop bundles, npm tarballs, GitHub Release). Tag pushes still work as before.

[0.7.0] - 2026-09-21

Changed

• Public sign-up closes by default after the first account. On upgrade, existing instances keep their users but new public sign-ups are rejected until an admin enables them (Settings → Instance or SIGNUP_ENABLED=true). The oldest existing account is not automatically promoted — set AUTH_ADMIN_EMAILS or update user.role to admin manually if no platform admin exists.
• OAuth providers require PRIMORA_MANAGED=true. Self-hosted deployments are email/password only; GitHub/Google/Discord/Microsoft env keys are ignored without the flag.

Added

• Instance administration — core.settings (migration 00010) stores in-app overrides that resolve ahead of .env and built-in defaults. New endpoints: GET /instance/public (unauthenticated login-page state), GET/PUT/DELETE /instance/settings[/key] (platform admin only — better-auth user.role, not org role). Manageable keys cover public sign-up, mail transport (Resend or SMTP), and API/user rate limits. Secrets are AES-256-GCM encrypted at rest, never returned by the API, and decryptable by the auth service via the shared PRIMORA_ENCRYPTION_KEY.
• Bootstrap + sign-up gating — the first public sign-up becomes the instance admin; afterwards public sign-up is closed unless SIGNUP_ENABLED=true or the admin reopens it in Settings → Instance. databaseHooks.user.create.before gates only /sign-up/email, so admin-created users and OAuth flows bypass it.
• Managed-tier OAuth gate — PRIMORA_MANAGED=true is now required for GitHub/Google/Discord/Microsoft sign-in; self-hosted instances are email/password only. The login page hides the sign-up tab and social buttons according to GET /instance/public.
• Settings → Instance tab — platform admins edit sign-up, mail, and rate-limit settings in-app with source badges (in-app/env/default) and per-key reset.

[0.6.0] - 2026-09-21

Added

• Scheduled jobs — core.scheduled_jobs + core.scheduled_job_runs (migration 00009). Cron expressions and descriptors (@hourly, @daily, @every 30m, */15 * * * *) parsed via robfig/cron; an in-process JobScheduler scans every 15 s, queues due jobs through a buffered channel, and collapses missed schedules into a single run. Endpoints under /projects/:id/jobs: list/create/update/delete, GET …/jobs/:id/runs, POST …/jobs/:id/run (manual execution). Jobs deliver a JSON envelope (event type, project/job/run IDs, trigger source, timestamp, static payload) via POST with X-Primora-Signature: sha256=<hmac-sha256(body)>, X-Primora-Event, X-Primora-Job, X-Primora-Run headers and a 10 s timeout. Secrets are AES-256-GCM sealed at rest; a generated secret is returned exactly once on create/rotate (has_secret thereafter). Run records carry status, trigger, HTTP status, duration, error text, and timestamps; history is pruned by retention. Reads require viewer+, writes admin/developer.
• Domain events + realtime stream — PlatformService.publishEvent fans project mutations out to realtime subscribers and matching webhooks through one path. New webhook event types: job.run, document.created/updated/deleted, object.created/updated/deleted. GET …/projects/:projectID/realtime/stream serves an SSE feed with 25 s keepalives and ?token=/?api_key= query auth for EventSource clients.
• Automation page — SolidJS view with a Schedules tab (job table, create modal with schedule helper text, expandable run history, manual Run, enable/disable, delete, secret-shown-once banner) and a Live events tab (live/offline badge, pause, clear, auto-reconnect). Sidebar + command palette entries; demo-mode seeds and stubs included.
• primora jobs:* CLI group — jobs:list, jobs:create <name> --schedule --url [--payload --secret --disabled], jobs:run <job>, jobs:runs <job> --limit, jobs:rm <job> --yes. Both jobs list and jobs:list spellings.
• New primora_* MCP tools — primora_list_jobs, primora_create_job, primora_update_job, primora_delete_job, primora_list_job_runs, primora_run_job. Webhook event schema extended to all new event types.

Fixed

• SSE broken by gzip middleware — Compression() wrapped every Accept-Encoding: gzip response, and the gzip buffer swallowed each Flush(), so EventSource received headers then silence and closed. Paths ending in /stream now bypass compression; this repaired the pre-existing telemetry stream too.
• Event payloads serialized as base64 — document/object fields inside domain-event envelopes were json.RawMessage placed into map[string]any, which marshals as base64. They're now wrapped so the raw document embeds in the event JSON.
• Auth trusted origins ignored the configured public URL — docker-compose.yml hardcoded http://localhost for BETTER_AUTH_URL, AUTH_BASE_URL, and VITE_APP_URL, so any non-default NGINX_PORT or domain broke sign-in with a 403. All three now read .env with localhost defaults.
• Frontend auth base URL on non-default ports — the bundled default baked http://localhost; auth-client now resolves /auth against window.location.origin (absolute, as better-auth requires) when VITE_AUTH_BASE_URL is unset.

Security

• Managed platform connections removed — platform-postgres/platform-dragonfly seeds carried the backend's own DATABASE_URL/DRAGONFLY_URL into every project, where any member could run arbitrary queries through DBX against core tables. The seeds are gone and migration 00008 deletes existing managed rows. Operators keep direct psql/redis-cli access.
• Connection passwords encrypted at rest — core.db_connections.config.password is now AES-256-GCM sealed (enc:v1: marker) via PRIMORA_ENCRYPTION_KEY; decrypted only when registering the connection with DBX. Migration 00008 strips pre-existing plaintext passwords.
• DBX naming — connection names now prefix the full project UUID; the previous 8-hex prefix could collide across projects and alias the wrong credentials.

Infrastructure

• One-line installer — install.sh (curl | bash) fetches the compose files, generates secrets, pulls prebuilt GHCR images, and falls back to a source-tarball build when packages aren't published.
• CI image pipeline — per-app buildx matrix with GHA layer cache, container-contents smoke checks, Trivy scans, docker compose config validation, and edge/sha-* GHCR publishing on master.
• Fixed release image pushes — tags were rendered with the mixed-case owner (ghcr.io/Dvorinka/...), which GHCR rejects; owner is now lowercased, unblocking tagged releases.

[0.5.0] - 2026-09-16

Added

• Desktop app (apps/desktop) — Tauri 2 thin shell for Linux/Windows/macOS. First run shows a connect screen asking for the deployment URL (validated, stored in ~/.config/dev.tdvorak.primora/config.json); the webview then renders the same SolidJS bundle the server serves. System-tray icon (Show / Change Server / Quit), close-to-tray, single-instance. No embedded backend or database — the self-hosted model is preserved.

• PWA support — vite-plugin-pwa generates a Workbox service worker and manifest.webmanifest in every frontend build. The app shell (JS/CSS/icons/index.html) is precached; /api, /auth, and /mailpit are NetworkOnly and excluded from the SPA navigation fallback; Google Fonts assets are cached for a year. Installability icons (192/512/maskable + apple-touch-icon) rasterized from the existing SVG mark.

• Install prompt — PwaInstallBanner captures beforeinstallprompt and offers an in-app install action inside the shell; dismissal persists in localStorage.

• Desktop release artifacts — release.yml gains a desktop job (ubuntu/macos/windows matrix) producing AppImage/deb/rpm, dmg, and msi/nsis bundles, attached to the GitHub Release alongside the existing images and CLI binaries.

• Connector framework — core.integrations (migration 00005) stores per-project external services with type, base URL, has_credentials flag, health status/last_health_at. Credentials are AES-256-GCM encrypted at rest (PRIMORA_ENCRYPTION_KEY, hex/base64, 32 bytes; dev fallback outside production) and are never serialized to the client. Endpoints under /projects/:id/integrations: list, create, delete, POST …/test (5s health check against the base URL with stored credentials).

• Rybbit connector — GET …/integrations/:id/analytics proxies a self-hosted Rybbit instance server-side (/api/organizations site discovery, /api/sites/:site/overview, time series, top pages/referrers) and returns a normalized shape. The API key never leaves the server; read-only, no tracking proxy. Site selection via ?site= or the integration's configured site_id.

• Outbound webhooks — core.webhooks + core.webhook_deliveries. Endpoints: list/create/update/delete under /projects/:id/webhooks, GET …/deliveries, POST …/test. Events: issue.created (new error fingerprint on ingest), deploy.marker (POST …/deploy-markers, records version/ref/environment/note in the audit log), webhook.test. HTTPS required for public targets; plain HTTP allowed for private/self-hosted sinks. Deliveries are signed X-Primora-Signature: sha256=<hmac-sha256(body)> and retried by an in-process dispatcher (buffered queue, 3 attempts, quadratic backoff, 10s timeout, crash recovery on boot). Generated secrets are returned exactly once.

• Integrations page — SolidJS view (Connectors + Webhooks tabs): connector table with status/test/inline Rybbit analytics panel, webhook table with per-endpoint delivery log, secret-shown-once banner, deploy-marker form. Demo-mode stubs included.

• New primora_* MCP tools — primora_list_integrations, primora_create_integration, primora_delete_integration, primora_test_integration, primora_integration_analytics, primora_list_webhooks, primora_create_webhook, primora_update_webhook, primora_delete_webhook, primora_list_webhook_deliveries, primora_test_webhook, primora_create_deploy_marker.

• Telemetry (IMS merge) — POST /api/v1/ingest accepts a single event or a ≤500-event batch, authenticated by existing project prm_ API keys via X-Primora-Key (or X-API-Key); OPTIONS preflight + permissive CORS for browser SDKs. Components auto-register on first use (frontend, backend, database, android, desktop, web, other). Event types: error, metric, log, heartbeat, event; missing fingerprints are derived from component + first message line.

• Issue grouping — GET /projects/:id/issues groups errors by fingerprint (count, severity, first/last seen, latest component).

• Telemetry read APIs — GET …/events (type/component/fingerprint filters, before cursor), GET …/components, DELETE …/components/:id, GET …/telemetry/stats (bucketed series + component health + totals + metric names over 1h/24h/7d/30d), GET …/telemetry/metrics/series (avg/p50/p95/max per bucket).

• Live SSE stream — GET …/telemetry/stream pushes inserted events through an in-process hub (buffered subs, drop-on-slow, 25s keepalives). ?api_key=/?token= query auth for EventSource clients.

• Telemetry page — SolidJS view: health tab (totals, activity histogram, component status table), issues with drill-through to filtered events, event list with payload modal, metric series table, and an Integrate tab with SDK/cURL snippets. Live badge driven by the SSE stream; demo-mode stubs included.

• @primora/client SDK — createPrimoraClient({ endpoint, key, component, kind, base }) with captureError, captureMetric, captureLog, captureEvent, heartbeat, installAuto, queued batching and keepalive flushes.

• New primora_* MCP tools — primora_list_issues, primora_list_events, primora_telemetry_stats, primora_metric_series.

Fixed

• Workspace dependency pins updated to 0.3.0 (@primora/api-client, @primora/shared-types) — npm ci in the frontend image was resolving the unpublished 0.2.0 spec from the registry.

[0.3.0] - 2026-09-16

Added

• Databases (DBX integration) — the Go backend keeps dbx-mcp as a persistent stdio subprocess (internal/dbx, lazy start, one retry on failure) and exposes its tools as REST under /projects/:id/db-connections/* (list/create/delete/test, databases, tables, describe, schema context, SQL query, Redis command). DBX tool/subprocess failures surface as 502.
• Connection registry — core.db_connections (migration 00003). Credentials are stored server-side and never serialized to the browser (has_password flag only). Non-default ssl, driver_profile supported.
• First-party connections — platform-postgres and platform-dragonfly auto-register on every project (derived from DATABASE_URL/DRAGONFLY_URL) and cannot be deleted (409 managed_connection).
• Databases page — SolidJS view with connection list, database/schema/table browser, column inspector, SQL editor (⌘/Ctrl+Enter), result grid with row-detail modal, and a Redis console. Demo mode stubs included.
• Backend image now Debian-based — dbx-mcp requires glibc; the Dockerfile installs the pinned packages-v0.4.88 release with SHA256 verification.

[0.2.0] - 2026-09-15

Added

• primora CLI (apps/cli) — cac-parsed, @clack/prompts interactive UX. Login (session or API key), org/project context, orgs, projects, buckets, objects (list/upload/download/rm), keys, audit list --follow. Every command accepts --json. Both primora orgs list and primora orgs:list spellings.
• @primora/mcp server (apps/mcp) — stdio MCP server exposing 14 primora_* tools (whoami, orgs, projects, buckets, objects up/download/delete, API keys, audit query) over the generated client. Shares the CLI's ~/.config/primora/config.json credentials.
• Authentication → Users panel — better-auth admin plugin on the auth service (list/set-role/ban/unban/remove users) plus a dashboard view with search, role selects, and ban/delete actions. Bootstrap admins with AUTH_ADMIN_EMAILS in .env.
• Mobile bottom navigation — Instagram-style tab bar below 1024px (Overview · Storage · Collections · Auth · Menu), safe-area aware; Menu opens the full drawer. Fixes a dead-navigation gap at 768–1023px.
• Release pipeline — semver tag → GitHub Release with changelog notes, GHCR images (primora-backend/auth/frontend), compiled primora/primora-mcp binaries for Linux/macOS/Windows, npm tarballs, optional npm publish via NPM_TOKEN secret.

Fixed

• Object downloads broken for all gzip-negotiating clients — the compression middleware left the handler's Content-Length (raw size) on gzipped bodies, so undici/browsers saw truncated streams. gzipWriter.Write now drops Content-Length.
• nginx 502s after every container restart — upstreams were resolved once at startup. nginx now resolves backend/auth/frontend/mailpit through Docker's embedded DNS (127.0.0.11) per request.

Changed

• API keys now document the real prm_<prefix>_<secret> format (README previously claimed pk_live_).

[0.1.0] - Initial commit

• Phase 0 foundation: Go/Gin backend, Better Auth service, SolidJS dashboard, Postgres + Dragonfly, nginx gateway, Docker Compose stack.