A source-available AI copilot that lets you talk to your Tableau dashboards.
"Nice charts. And what do they mean?" — "Just ask them."
OpenVizPilot is a Tableau dashboard extension with a chat UI that answers questions about the currently open dashboard. A lightweight Node.js middleware connects the extension to any existing OpenAI-compatible LLM endpoint (for example a LiteLLM proxy). The LLM queries dashboard data selectively via tool calling, and every data access happens in the viewer's own Tableau session, so nobody can ask for data they are not allowed to see.
For dashboard users
- Ask in plain language: the LLM reads worksheet data, filters, parameters and selections through 10 read-only tools (5 tool rounds per question in Ask mode, 12 when investigating, 24 across the estate), including aggregation drilldowns (
aggregate_summary_data: group by/sum/avg/min/max/count over summary data — no full-data permission required). - Action chips (Enterprise,
actions): the LLM proposes follow-up questions and dashboard actions — apply or clear filters, change parameters, highlight marks (for example “show me the top 3 regions”) and show or hide a dashboard zone. Actions run only on click, with the technical detail always shown in plain text — human-in-the-loop by design, which also reduces prompt injection risk. Without a license the model is not told the action syntax and never proposes one. - It knows what you are looking at: the context lists which views are currently hidden behind a show/hide zone, so the assistant can say “that view is closed — shall I open it?” instead of describing something you cannot see. It also names the real controls of the dashboard when you ask where to change something. Mark highlights are counted too, not just what you click. The chat panel inherits the workbook font and text color so it does not stick out on a dashboard with a corporate theme.
- Transparency: analysis trace (every tool call is visible and expandable), source references in answers, transcript export as Markdown.
- Personal context: an author-managed glossary for everyone; with an Enterprise license also user memory (name/preferences, visible and deletable by the user) and saved queries — answer-focus onboarding plus up to 5 standard questions per dashboard.
- Slash commands: German and English prompt playbooks (for example
/summaryand/compare) with a picker menu in the chat.
For administrators (/admin — the first visitor sets the admin password on first access, in a PaddleDoc-style flow; a static OVP_ADMIN_TOKEN also works; that initial admin can grant the Admin role to user accounts or SSO identities, which then sign in to /admin with their own account but cannot grant the role themselves)
- Extension manifest download: enter the public HTTPS URL, get the ready-made
openvizpilot.trex; the extension then talks to the origin it was loaded from, and nothing else has to be configured. - Model catalog: look up the models your endpoint offers and map them to friendly display names shown in the extension; the catalog is enforced on the chat endpoint.
- Enterprise MCP: connect approved read-only sources and web-search services in the admin UI, assign them to managed sites, dashboards and authenticated members, and require consent before external queries. See MCP setup and permission boundaries.
- Tableau Server integration (Enterprise): optional Connected-App/JWT sign-in, REST content search and Metadata API are implemented for Tableau Server 2024.2 or newer; status and scope are documented in docs/tableau-server.md.
- Tableau-MCP (Enterprise): the same Tableau-Server tools as an MCP server at
/api/tableau-mcpfor external agents such as Weave, VS Code or Claude Code — OAuth resource server, personal identity only, no service account; see docs/tableau-mcp.md. - Desktop app (Enterprise server side, client open source at bl0rb/OpenVizPilotDesktop): a macOS/Windows tray app that asks the Tableau estate without an open dashboard — same SSO, same Tableau-Server tools, agent loop server-side (
/api/desktop); see docs/desktop.md. - Slash-command management: edit, add or reset the global playbooks centrally.
- Standard analyses per dashboard: embedded extensions register automatically after sign-in. Select a dashboard in the admin portal to configure up to five starter questions and its own slash commands. Global commands remain available; open extensions refresh within a minute. See setup and workbook copies.
- Anonymous usage: counters per model, tool, command and error, plus a per-dashboard view (questions, number of users, average and maximum questions per user) — users are counted only as non-reversible pseudonyms, never names, IDs or content.
Built-in guardrails
- Topic guard: a cheap classifier model checks every question server-side before the main LLM call; off-topic questions are refused without ever reaching the main model (
OVP_SCOPE_GUARD, enabled by default) — on top of the scope rule in the system prompt. - Data isolation: see below — the middleware has no Tableau identity at all.
The extension executes the LLM's tool calls in the user's browser (Extensions API, viewer session); the middleware stays stateless, injects the system prompt and tool definitions, and streams via SSE.
Two further clients use the same middleware without an open dashboard (Enterprise): the desktop app talks to /api/desktop, where the agent loop runs server-side over the Tableau-Server tools, and external agents (Weave, VS Code, Claude Code) connect to /api/tableau-mcp, an MCP server that exposes the same tools. Both act strictly under the personal identity of the signed-in user — see docs/desktop.md and docs/tableau-mcp.md.
📖 User guide: the wiki explains the chat, slash commands, action chips and privacy for end users — in German and English.
Everything below happens inside the open dashboard, in the viewer's own Tableau session: the assistant can only read data that this user is allowed to see — row-level security and user filters apply unchanged. It never changes the dashboard on its own; every change is a chip the user clicks.
| Ask it | What happens |
|---|---|
| “Summarize the dashboard briefly.” | Reads the key figures and active filters through tool calls and answers with a few core statements plus a compact metrics table; the central figures name the worksheet they came from. |
| “What stands out in the data? Name the three most important points.” | Aggregates summary data across all reader pages (aggregate_summary_data) and names outliers, weak categories and unusual ratios — with figures, not impressions. |
/compare North South |
Groups both sides and returns a comparison table (metric · A · B · difference absolute and in %) plus a short reading of what drives the gap. Typed as a question it answers too, just without the fixed format. |
/top 5 products |
Produces a ranking with each entry's share of the total and a statement on concentration — how much the top entries actually account for. |
| “Which filters are active right now?” | Lists the filters per worksheet with their selected values, ranges and exclude mode — the answer says what the numbers are currently based on. |
| “Show only the North region.” | With an Enterprise license (actions), offers the filter as an action chip for the worksheet in question, spelled out in plain text; it is applied only when the user clicks. Chips set categorical values — date ranges are chosen in the dashboard itself. |
| “What have I selected right now?” | Reads the selected marks — and if nothing is selected but something is highlighted (highlighter, legend, highlight action), it uses that and says so. |
| “Where do I change the region?” | Names the actual control on the dashboard (“Region”, filter control) instead of guessing a field, because the context knows the dashboard's zones. |
| “What does ‘Order details’ show?” | If Tableau reports that view's zone as hidden, the assistant says so instead of describing something the user cannot see — and offers to show it as a chip. |
“Where does this number come from?” or /lineage Revenue |
Answers with a fixed provenance chain: dashboard → worksheet → field (formula if Tableau Server metadata is available) → catalogue definition → data source and connection → upstream tables → active filters and parameters → certification status. Nothing is invented: what the APIs do not provide is marked “not available”. No server addresses leave the browser. |
| Switch the composer to Investigate and ask “Why did margin drop in the South?” | The assistant first writes a 3–6 step analysis plan, works through it with more tool rounds (breakdown_by for shares and concentration, compare_periods for period-over-period differences, aggregations), and closes with Main cause, Evidence and Sources — every claim backed by a tool result shown in the trail. |
| “Why is our revenue dropping? — across all workbooks” | With an Enterprise license (serverData) and scope switched to Entire environment, the assistant searches other workbooks/views (tableau_server_search), reads at most 5 of them server-side on the user's behalf, prefers a server-side aggregation over raw rows, and closes with Main cause, Evidence and Sources (workbook · view · link per source). Without the license or the per-person grant it explains that plainly and investigates only the open dashboard instead. |
| “What does contribution margin II mean?” | Answers from the glossary the workbook author maintains — house definitions instead of textbook knowledge. |
| “How high is our DB II?” | If the admin maintains the metric in the company-wide catalogue (/admin → “Kennzahlen”: definition, synonyms, owner, data source, verified questions), the assistant looks it up before answering and the answer carries a “✓ Verified definition: Deckungsbeitrag II” note — shown only when the lookup actually happened. |
/exec-brief for the board |
Produces a management summary with a fixed structure: key statements, main metrics with change, anomalies, up to three recommendations, data basis (worksheets, filters, as-of). Every answer can be downloaded as Markdown. |
/ in the input box |
Opens the playbook menu: summary, findings, comparison, top-N, recommendations, report, data quality — admins can replace them and add their own per dashboard. |
| “Remember: numbers should always be presented as a table.” | With an Enterprise license and Tableau 2023.2 or newer, remembers the preference for this user; every stored fact stays visible and deletable in the settings panel. |
| “Let me know when margin drops below 20%.” | With an Enterprise license (watch, needs serverData), proposes a rule as a confirmation card (view, threshold, schedule, delivery channel) — nothing is created until the user confirms it. Once running, the middleware re-checks every guardrail on each evaluation and delivers a short message (webhook, Microsoft Teams or email) only on a state change. |
| “Write me a poem about cats.” | Declined with a short fixed message. The assistant answers dashboard questions only — the scope guard runs server-side, before the model sees the question. |
Every answer keeps its analysis trail: which tools ran on which worksheet, expandable down to the raw tool result — so a figure can be traced instead of believed.
A summary on request. One click on “Summarize the dashboard briefly.” reads the metrics via tool calls and returns a structured summary of a profitability dashboard, including an overview of the other worksheets:
An open question, answered with sources. “What stands out in the data? Name the three most important points.” — the assistant aggregates the summary data itself (the aggregate_summary_data call sits above the answer, expandable), names three findings with their figures and says for each one which worksheet it came from. The chips below continue the analysis; the badge in the header reports what changed in the dashboard — here the layout:
A filter as an action chip (Enterprise, actions). Asked to filter the order date to the last 90 days, the assistant does not touch the dashboard itself — it computes the date range, explains where the filter currently applies and offers the change as a chip. The filter is applied only when the user clicks it; the follow-up chips below continue the analysis on the filtered view:
First contact and the slash menu. With an Enterprise license (savedQueries), a new user is first asked which answer focus they want for this dashboard (management summary, detailed analysis, compact tables, recommendations — or none); without it the starter chips appear right away. Typing / opens the playbook menu with the built-in German and English prompt presets:
Settings panel. Backend URL (empty = same origin, the recommended production setup), optional API token, model selection with the admin’s display names, the author-managed glossary — and, with an Enterprise license, the user’s stored memory facts (viewable, deletable) plus the per-dashboard answer focus and standard questions:
memory, savedQueries and actions are Enterprise features and live in ee/ (actions gates the
prompt section and client-side rendering in the core; see packages/server/src/system-prompt.ts).
Without a license the core runs unchanged, only without personalization and action chips: nothing is extracted, the answer focus is ignored, /api/memory/prefs returns 402 license_required, the model is never told the action syntax and a chip never appears or executes. Reading and deleting already stored facts stays available regardless of the license (GET/DELETE /api/memory), so the rights of access and erasure never depend on a license key — and the settings panel keeps showing existing facts with their delete button.
Both need a user identity from Tableau (uniqueUserId, Extensions API 1.11), so they require Tableau 2023.2 or newer — on older versions the extension still runs, and the settings panel explains why the personal sections are missing instead of hiding them silently.
The middleware can remember personal facts per user (name, role, preferred views/formats) to personalize dashboard answers — identified via the obfuscated uniqueUserId of the Extensions API, stored in Postgres (on EKS via CloudNativePG; locally SQLite via OVP_DATABASE_PATH). A cheap model (OVP_MEMORY_MODEL) extracts the facts after each turn exclusively from the user’s messages — dashboard data and metrics never reach the extraction, and the prompt additionally forbids storing them. The topical scope stays strict: the assistant only answers dashboard questions. Users can view and delete their stored facts themselves in the settings panel (GET/DELETE /api/memory).
Saved queries are the second half: the answer focus a user picks for a dashboard and the standard questions they keep as start chips, stored per (user, dashboard) and served through GET/PUT /api/memory/prefs.
Every user can only query data they can see in Tableau. All data access runs client-side through the Extensions API in the Tableau session of the signed-in user — row-level security and user filters apply automatically. The middleware has no Tableau identity (no service account, no PAT), caches no dashboard data, keeps no chat history — conversations live in the user’s browser — and logs metadata only (never message content or dashboard data). What it does store is the application’s own state: sign-in accounts and sessions, admin settings, anonymous usage counters and, with an Enterprise license, personal facts and saved queries per user. Prerequisite: RLS is modeled in the Tableau data sources (user filters/entitlement table); hierarchies such as branch manager → sales partner are handled there, not in this application. Watch and cross-dashboard investigation need their own explicit opt-in (site switch, per-person grant, user consent — see docs/admin-deployment.md) for a bounded serverside read of another view's summary data; without it, everything stays in the browser as described above. The desktop app and the Tableau-MCP server follow the same rule: every call carries the user's own IdP token, Tableau applies permissions and RLS for that person, and the data tools appear only with the serverData licence, the per-person grant and the user's consent — there is no service account and no way to name another user (docs/tableau-mcp.md).
| Package | Contents |
|---|---|
packages/shared |
Contract between both sides: zod schemas, SSE protocol, tool definitions, Markdown helpers, .trex template |
packages/server |
Middleware (Hono): POST /api/chat (SSE streaming), GET /api/models, /api/desktop, admin API, GET /healthz |
packages/extension |
Dashboard extension (Vite + Preact): chat UI, context snapshot, tool executors, .trex manifest |
ee/ |
Enterprise Edition (stub in the public repo): SSO, licence, MCP sources, Tableau Server, Watch, the desktop agent (/api/desktop) and the Tableau-MCP server (/api/tableau-mcp) |
| bl0rb/OpenVizPilotDesktop | Separate open-source repository (MIT): the macOS/Windows tray app (Tauri 2) that talks to /api/desktop |
npm install
cp .env.example .env # set OVP_LLM_BASE_URL, OVP_LLM_API_KEY, OVP_DEFAULT_MODEL| Command | Purpose |
|---|---|
npm run dev |
Middleware (:3000) + extension (:5173) — for Tableau Desktop |
npm run dev:mock |
Same, but with a mock dashboard in the browser (no Tableau) |
npm run dev:demo |
Like dev:mock, plus a mock LLM server (:4010) — no LLM endpoint at all |
npm run dev:static-demo -w @openvizpilot/extension |
Extension only, in the browser: static demo mode (scripted answers, no middleware, no LLM) with the mock dashboard — see Static demo |
npm run dev:claude |
For Tableau Desktop, answers via the locally signed-in Claude Code CLI (:4020) — a real LLM without an API key (.env: OVP_LLM_BASE_URL=http://localhost:4020) |
npm test |
All unit/integration tests (vitest) |
npm run typecheck |
TypeScript across all packages |
npm run build |
Production build (server + extension) |
Testing with Tableau Desktop: run npm run dev, open a dashboard in Tableau, drag an “Extension” object onto the dashboard and pick packages/extension/public/openvizpilot.dev.trex — this one points at the Vite dev server. (The manifest from the admin UI points at the middleware, which only serves the extension in production.) Debugging: start Tableau Desktop with --remote-debugging-port=8696 and open Chrome at http://localhost:8696.
Testing without Tableau: run npm run dev:demo and open http://localhost:5173 — questions containing “Filter” or “Revenue” trigger tool calls in the mock LLM.
More for contributors (in German): architecture, development guide (test loops, helper scripts, production build) and contributing (checklists for adding a tool, a setting, an Enterprise feature or a UI text).
For trials and the Tableau Exchange listing the extension can run entirely in the browser: built with vite --mode demo, it answers every /api/* call itself (packages/extension/src/demo), so plain static hosting is all that is needed. The answers are scripted, not generated — but they are computed from the open workbook with the same dashboard tools the full product uses (active filters, parameters, selected marks, top groups via breakdown_by, rows of a worksheet, worksheet list), so users see the real look and feel on their own data. A banner says so, the model picker shows “Demo (no AI)”, three starter chips lead into the supported questions, and anything else gets an honest “demo mode” reply. Nothing leaves the browser: no server, no LLM, no logs, no data processing agreement required.
npm run build:static-demo -w @openvizpilot/extension # → packages/extension/dist-demo/ incl. openvizpilot-demo.trex
OVP_DEMO_URL=https://demo.example.com/ npm run build:static-demo -w @openvizpilot/extensionUpload dist-demo/ to any HTTPS static host (default manifest URL: https://demo.werkworks.de/). The demo manifest uses its own extension ID (com.openvizpilot.extension.demo) and the name “OpenVizPilot (Demo)”, so it can sit next to a production installation. Enterprise features that need a server (memory, saved queries, Watch, server-side data) are off; client-side dashboard actions stay on.
The middleware runs stateless on EKS and scales horizontally (HPA) and vertically — chat history lives in the extension, user memory in Postgres with DB-side version checking, no sticky sessions. It also serves the extension's static files — one origin, no CORS. Deployment via the Helm chart charts/openvizpilot, which optionally provisions a CloudNativePG Postgres cluster for user memory (operator required):
helm install openvizpilot oci://ghcr.io/bl0rb/charts/openvizpilot -f my-values.yamlWithout Kubernetes, deploy/compose runs the same image on a single Linux VM with Docker Compose (Postgres included, optional Caddy for HTTPS) — see docs/admin-deployment.md.
Image (ghcr.io/bl0rb/openvizpilot) and the chart are published by the GitHub workflows on v* tags (.github/workflows/: PR CI as the release gate, GHCR/OCI). Release images are signed keyless with Sigstore cosign (GitHub OIDC) and carry an SPDX SBOM attestation (signature and attestation are stored as Sigstore bundles next to the image, so use cosign 3.x), so you can check that an image was built by this repository's release workflow before deploying it:
cosign verify ghcr.io/bl0rb/openvizpilot:1.6.0 --certificate-oidc-issuer https://token.actions.githubusercontent.com --certificate-identity-regexp '^https://github.com/bl0rb/OpenVizPilot/'The production manifest for Tableau comes straight from the admin UI (/admin → “Extension for Tableau”); alternatively, generate it from a checkout:
npm run build:trex -w @openvizpilot/extension -- --url https://chat.example.com/Details (safelist, HTTPS, access protection, admin modes, memory and usage privacy): docs/admin-deployment.md. The extension needs no full-data permission (summary data only).
The chart never needs a secret in values.yaml: every sensitive value is read from an existing Kubernetes Secret (existingSecret + key), so a vault integration — External Secrets Operator, Vault Agent Injector, Secrets Store CSI — only has to materialise these keys. The plain-text fallbacks (llm.apiKey, app.authToken, app.adminToken) are for dev/CI only.
Secrets — keep in the vault
| Vault key → env var | values.yaml |
Required | Purpose |
|---|---|---|---|
OVP_LLM_API_KEY |
llm.apiKeySecret.{existingSecret,key} |
yes | API key for the OpenAI-compatible LLM endpoint |
OVP_API_AUTH_TOKEN |
app.authTokenSecret.{existingSecret,key} |
auth.mode=token |
Shared bearer token the extension sends to /api/* |
OVP_ADMIN_TOKEN |
app.adminTokenSecret.{existingSecret,key} |
token-mode admin | Initial admin for /admin; leave unset with memory enabled for password mode |
OVP_OIDC_CLIENT_SECRET |
oidc.clientSecretSecret.{existingSecret,key} |
confidential OIDC clients | Client secret for Entra ID / Keycloak (public PKCE clients need none) |
OVP_LICENSE |
license.{existingSecret,key} |
Enterprise | Signed licence key |
OVP_DATABASE_URL |
memory.database.external.{existingSecret,key} |
memory.database.mode=external |
Postgres URI (postgresql://user:pass@host:5432/db); with mode=cnpg the operator's <release>-db-app/uri is used |
OVP_SECRET_KEY |
app.secretKeySecret.{existingSecret,key} |
secrets entered in the admin UI | ≥ 32 characters (openssl rand -hex 32); encrypts Tableau Connected-App secrets at rest (AES-256-GCM) |
OVP_SMTP_URL |
smtp.urlSecret.{existingSecret,key} |
Watch email channel | SMTP URL for Watch alert emails, e.g. smtps://user:[email protected]:465 |
OVP_TABLEAU_<NAME> |
tableau.secretRefs[] (env, secretName, key) |
env-referenced site secrets | Connected-App secret per Tableau site, referenced by name in the admin UI instead of storing it in the DB |
OVP_MCP_<NAME> |
mcp.secretRefs[] (env, secretName, key) |
MCP servers with tokens | Bearer token per MCP server, referenced by name in the admin UI |
| registry pull credentials | imagePullSecrets (list of { name }) |
image.edition=enterprise |
kubernetes.io/dockerconfigjson secret with the customer's GHCR read token for the private ghcr.io/bl0rb/openvizpilot-enterprise package (kubectl create secret docker-registry …; access and instructions come with the licence) |
Plain configuration — values.yaml, no vault needed
| Env var | values.yaml |
Purpose |
|---|---|---|
OVP_LLM_BASE_URL |
llm.baseUrl |
LLM endpoint (required) |
OVP_DEFAULT_MODEL, OVP_MODEL_ALLOWLIST |
app.defaultModel, app.modelAllowlist |
Default model (required) and optional allow-list |
OVP_PUBLIC_URL |
app.publicUrl |
HTTPS origin of the middleware (SSO redirect URI, OAuth 2.0 Trust issuer) |
OVP_ENVIRONMENT |
app.environment |
production (default) | development | test | staging — counted during licence activation |
OVP_AUTH_MODE |
auth.mode |
none | token | local | oidc |
OVP_OIDC_PROVIDER, OVP_OIDC_ISSUER, OVP_OIDC_CLIENT_ID, OVP_OIDC_SCOPES |
oidc.* |
Identity provider (Enterprise); the issuer must be https:// (plain http:// only for localhost) |
OVP_OIDC_MCP_AUDIENCE, OVP_OIDC_MCP_SCOPES |
oidc.mcpAudience, oidc.mcpScopes |
Tableau-MCP server (Enterprise): audience of the MCP resource at the IdP (not the extension's client id) and required scopes (default tableau.read, never empty); unset = /api/tableau-mcp off |
OVP_SMTP_FROM |
smtp.from |
Sender address for Watch alert emails (Enterprise) |
OVP_WATCH_ENABLED |
app.watchEnabled |
Global switch for the Watch engine (default on; Enterprise) |
OVP_MEMORY_MODEL |
memory.model |
Model for memory summaries |
OVP_SCOPE_GUARD, OVP_SCOPE_MODEL |
app.scopeGuard, app.scopeModel |
Off-topic guard and its model |
OVP_LOG_LEVEL, PORT |
app.logLevel, containerPort |
Logging and container port |
Example with one Secret synced from the vault:
# my-values.yaml
llm:
baseUrl: http://litellm.llm.svc.cluster.local:4000
apiKeySecret: { existingSecret: openvizpilot-vault, key: OVP_LLM_API_KEY }
app:
defaultModel: gpt-4.1
publicUrl: https://chat.example.com
adminTokenSecret: { existingSecret: openvizpilot-vault, key: OVP_ADMIN_TOKEN }
secretKeySecret: { existingSecret: openvizpilot-vault, key: OVP_SECRET_KEY }
auth: { mode: oidc }
oidc:
provider: entra
issuer: https://login.microsoftonline.com/<tenant>/v2.0
clientId: <client-id>
clientSecretSecret: { existingSecret: openvizpilot-vault, key: OVP_OIDC_CLIENT_SECRET }
license:
existingSecret: openvizpilot-vault
key: OVP_LICENSE
memory:
enabled: true
database:
mode: external
external: { existingSecret: openvizpilot-vault, key: OVP_DATABASE_URL }
tableau:
secretRefs:
- { env: OVP_TABLEAU_SECRET_SALES, secretName: openvizpilot-vault, key: TABLEAU_SECRET_SALES }# External Secrets Operator: one ExternalSecret produces the Secret above
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata: { name: openvizpilot-vault }
spec:
secretStoreRef: { name: vault, kind: ClusterSecretStore }
target: { name: openvizpilot-vault }
dataFrom:
- extract: { key: openvizpilot/prod } # vault path holding the keys from the tableOpenVizPilot is source-available, not open source. Everything outside ee/ is the Core Edition under the PolyForm Noncommercial license — free for any noncommercial purpose; commercial use, including running it inside a company, requires an agreement. The Enterprise Edition — Single Sign-On (OIDC), user memory, saved queries, MCP sources, dashboard actions, the Tableau Server integration, Watch, the desktop endpoint, the Tableau-MCP server and license activation — lives in a private repository and is available to customers for source review under contract/NDA; ee/ in this (public) repository is a stub with the same package name and exports but no-op implementations, so the Core Edition builds and runs standalone. The Enterprise image is published as ghcr.io/bl0rb/openvizpilot-enterprise, a private GHCR package — customers receive a read-only token to pull it (imagePullSecrets in the chart). One licence covers one production installation; development, test and staging installations (OVP_ENVIRONMENT) are included. Enterprise features switch on once the installation has activated itself against WerkWorks (online at startup, or offline via the admin UI). Setup and feature details: docs/enterprise.md.
See docs/testing.md.
Core (everything outside ee/): PolyForm Noncommercial 1.0.0 — the full source is public and free for any noncommercial purpose. Any commercial use, including internal use in a company and any form of resale or hosting for others, requires an agreement with WerkWorks ([email protected]).
Enterprise Edition: proprietary — ee/ in this repository is a stub; the full source and its license live in the private repository, available for review under contract/NDA, contact [email protected]. Usable in production only with a valid license key.
This is deliberately source-available, not open source: the code is there to be read, audited and evaluated, not to be taken commercially without a contract.






