Required
The app needs all of these. The Temporal Worker and the realtime server read the same DATABASE_URL, ENCRYPTION_KEY, and INTERNAL_API_SECRET. Realtime also needs BETTER_AUTH_SECRET.
| Variable | Description |
|---|---|
DATABASE_URL | PostgreSQL connection string. docker/selfhost/compose.yml assembles it from POSTGRES_USER, POSTGRES_PASSWORD, and POSTGRES_DB |
BETTER_AUTH_SECRET | Auth secret (32 hex chars): openssl rand -hex 32. Must be identical on the app and realtime |
BETTER_AUTH_URL | Your app URL |
ENCRYPTION_KEY | Encryption key (32 hex chars): openssl rand -hex 32 |
INTERNAL_API_SECRET | Internal API secret (32 hex chars): openssl rand -hex 32 |
NEXT_PUBLIC_APP_URL | Public app URL. The server reads it at runtime to set the browser origin allowed credentialed CORS on /api/* and the app origin in the Content-Security-Policy |
The production Compose file layers these on top:
| Variable | Description |
|---|---|
TEMPORAL_WORKER_BROKER_SECRET | Separate 32+ byte secret used only between web and the Temporal Worker credential broker. Compose exits without it |
TEMPORAL_WORKER_APP_URL | HTTPS URL of the app as seen from the Worker. Compose passes it to the Worker as APP_URL and exits without it |
NEXT_PUBLIC_SOCKET_URL | WebSocket URL (default: http://localhost:3002) |
TEMPORAL_ADDRESS, TEMPORAL_NAMESPACE, TEMPORAL_SERVER_NAME, TEMPORAL_AUTH_ISSUER, TEMPORAL_AUTH_JWKS_URL, TEMPORAL_BUILD_ID | No default. The Worker fails at startup when any of them is empty. See Temporal |
Separate API and site hosts
Most deployments serve everything from NEXT_PUBLIC_APP_URL and leave these unset. Set them only when outside callers or marketing pages use a different host from the app.
| Variable | Description |
|---|---|
PUBLIC_API_URL | Stable URL that outside systems call (default: the app URL). It is the Temporal token issuer and JWKS host, the MCP OAuth issuer and resource URLs, the webhook and Slack event URLs registered with providers, and the default URL in exported workflow clients. Changing it later breaks running workflows, connected MCP clients, and registered webhooks |
NEXT_PUBLIC_API_URL | Browser copy of PUBLIC_API_URL, used for the MCP and webhook URLs shown in the UI. Set it to the same value |
NEXT_PUBLIC_SITE_URL | Marketing site URL (default: the app URL). Used for the privacy and terms links in emails, robots.txt, sitemap.xml, llms.txt, and canonical links on public pages |
Changing the public application URL
Set NEXT_PUBLIC_APP_URL, BETTER_AUTH_URL, and the Worker's public APP_URL consistently. Organization URL previews and generated form links use the configured application host; form links preserve its scheme and port. Keep the email sender domain configured separately from the application hostname.
Keep TEMPORAL_AUTH_ISSUER stable across the app, Workers and Temporal server when changing the public URL. Keep JWKS retrieval, MCP resources, and provider webhook destinations on PUBLIC_API_URL. Set NEXT_PUBLIC_API_URL to that same stable API URL, and NEXT_PUBLIC_SITE_URL to the marketing host. Update login and integration OAuth callback registrations for the application host, retaining old callbacks during the transition where supported.
The hosted production migration activates only when the configured app URL is exactly https://app.steelengine.com. GET/HEAD requests reaching the application on steelengine.com or www.steelengine.com for authentication, invitations, app entry pages and valid non-reserved organization paths temporarily redirect to the app host before cookies are set. The new host's / uses /app; the apex keeps its marketing pages and canonical URLs. New password-reset links requested on those old production hosts also use the app host. API callbacks, OAuth consent, public embeds, assets and non-GET/HEAD requests retain their handlers. This policy does not activate for self-hosted or development app URLs. Old-host traffic must continue reaching the application, and any proxy in front of it must preserve the original Host header; X-Forwarded-Host is not used.
MCP OAuth uses the stable public API origin as its issuer and resource audience. Moving only the application host does not change existing MCP resource URLs or require an issuer migration; continue using the API host for MCP connections. App-host resource aliases are rejected. Keep Temporal's separate issuer stable. Browser sessions and local storage do not transfer between unrelated origins, so users should expect to sign in again.
Temporal
Every deployment runs its own Temporal server. See Temporal. The app and the Worker share the connection settings:
| Variable | Description |
|---|---|
TEMPORAL_ADDRESS | gRPC frontend as host:port, no scheme |
TEMPORAL_NAMESPACE | Namespace created during bootstrap (app default: steelengine-local) |
TEMPORAL_TLS_ENABLED | true in production. Compose and Helm default to true |
TEMPORAL_SERVER_NAME | TLS name on the server certificate. Requires TEMPORAL_TLS_ENABLED |
TEMPORAL_TLS_CA_PEM, TEMPORAL_TLS_CA_PATH | Private CA for the frontend certificate, inline (PEM or base64 PEM) or as a file path |
TEMPORAL_AUTH_ISSUER | Issuer written into every token. The app defaults to PUBLIC_API_URL, then BETTER_AUTH_URL. The Worker has no default, so set it on both |
TEMPORAL_AUTH_AUDIENCE | Transport audience (default: steelengine-temporal-rpc) |
TEMPORAL_IDENTITY | SDK identity of this process. The Worker's value must equal its token subject |
TEMPORAL_ALLOW_INSECURE_AUTH | Tokens over plaintext. Loopback development only. Rejected together with TEMPORAL_TLS_ENABLED=true |
App only:
| Variable | Description |
|---|---|
TEMPORAL_WORKER_IDENTITY | Exact Worker subject the credential broker will issue tokens for (default in Compose: steelengine-temporal-worker) |
TEMPORAL_WORKER_BROKER_SECRET | Broker proof secret. The broker returns 503 until this and TEMPORAL_WORKER_IDENTITY are set |
TEMPORAL_EXECUTION_MODE | per_block, the only supported value |
TEMPORAL_AUTH_PRIVATE_KEY_FILE | Development-only local signing key. Production signs with the Better Auth JWKS key pair |
Worker only:
| Variable | Description |
|---|---|
APP_URL | App URL for the credential broker and internal callbacks. Must be HTTPS in production |
TEMPORAL_WORKER_CREDENTIAL_BROKER_ENABLED | true to fetch short-lived tokens from the app (Compose sets it). Mutually exclusive with TEMPORAL_API_KEY and TEMPORAL_API_KEY_FILE |
TEMPORAL_API_KEY, TEMPORAL_API_KEY_FILE | A worker token you issued, inline or as a file. The Worker re-reads the file every TEMPORAL_API_KEY_REFRESH_INTERVAL_MS (default 30,000). Set one, not both |
TEMPORAL_AUTH_JWKS_URL, TEMPORAL_AUTH_JWKS_FILE | Where the Worker verifies tokens. Set exactly one. Production requires the HTTPS URL |
TEMPORAL_REQUIRE_EXECUTION_IDENTITY | Verify the signed execution identity on every Activity. Defaults to true in production and cannot be turned off there |
TEMPORAL_DEPLOYMENT_NAME | Worker deployment name (default: steelengine-temporal-worker) |
TEMPORAL_BUILD_ID | Build identifier for Worker versioning. Change it with every new Worker image |
TEMPORAL_WORKER_PORT | Health server port (default: 3003) |
TEMPORAL_ACTIVITY_MEMORY_TARGET | Optional fraction greater than 0 and less than 1, for example 0.85. At or above this fraction of the container's memory limit, the Worker pauses new Activity slot reservations above a minimum of one per queue. Already-reserved slots and running Activities are retained. When unset or no container memory limit can be read, only the per-queue concurrency counts apply |
TEMPORAL_MAX_ACTIVITY_TASK_POLLERS | Most Activity Task polls each queue Worker holds open at once, for every queue in the process. When unset, the workflows queue holds up to 30 and the other queues up to 10, or fewer when the queue has fewer Activity slots. Every poll counts toward the Temporal server's per-namespace poll limit, so lower it before adding Worker replicas. See Temporal → Scaling Workers |
TEMPORAL_MAX_WORKFLOW_TASK_POLLERS | Most Workflow Task polls each queue Worker holds open at once, sticky and normal together, for every queue in the process. At least 2. When unset, up to 10, or fewer when the queue has fewer Workflow Task slots |
TEMPORAL_POLLER_AUTOSCALING | true to let each queue Worker scale its Activity and Workflow Task polls from the server's feedback, from 1 (2 for Workflow Tasks) up to the maximums above, instead of always holding the maximum open (default: false). Idle queues then hold fewer polls. With a maximum unset, the limit is the default maximum above |
TEMPORAL_SHUTDOWN_GRACE_TIME_MS, TEMPORAL_SHUTDOWN_FORCE_TIME_MS | Drain window on shutdown (defaults 30,000 and grace + 30,000). Once shutdown starts, the Worker lets blocks that are already running finish but starts no new ones, so each run continues from its last finished block on another Worker |
TEMPORAL_PARALLEL_RECORD_CHAINS | true to let a parallel branch run its following blocks in the same Activity, up to the next Wait, approval, Response, child workflow call, loop or nested parallel, instead of one Workflow round per block (default: false). Each block is still claimed and recorded before the branch's results are merged, so retries and effect fencing are unchanged. Enable it only after every Worker runs a release that includes it: an older Worker merging the branch would miss the blocks it ran and run them again |
TEMPORAL_PARALLEL_WINDOW_CHAINS | true to let a child workflow called inside a Parallel Window run its following blocks in the same Activity, up to its return, a nested child call, a loop, a Parallel or a failed block, instead of one window round per block (default: false). Each block is still claimed and recorded before the window merges it, and the window's concurrency limit, results, logs and order are unchanged. Enable it only after every Worker runs a release that includes it: an older Worker merging the item would miss the blocks it ran and run them again |
TEMPORAL_PARALLEL_WINDOW_INLINE_CHAINS | true, together with TEMPORAL_PARALLEL_WINDOW_CHAINS, to also let a Parallel Window item run its own following blocks in the same Activity, not only a child workflow's, instead of one window round per block (default: false; it has no effect while TEMPORAL_PARALLEL_WINDOW_CHAINS is off). A run stops at the end of the item, a loop iteration's start or end (unless TEMPORAL_PARALLEL_WINDOW_CHAIN_LOOP_CONTROL is on), a child workflow call, an excluded block such as Wait or Response, or a failed block. Each block is still claimed and recorded before the window merges it, and the window's concurrency limit, results, logs and order are unchanged. Enable it only after every Worker runs a release that folds inline chains: an older Worker merging the item would miss the blocks it ran and run them again |
TEMPORAL_PARALLEL_WINDOW_CHAIN_LOOP_CONTROL | true, together with TEMPORAL_PARALLEL_WINDOW_CHAINS, to let a Parallel Window item's run of blocks continue through the loops inside the item (a loop's start, each next iteration and its end) instead of stopping at every one and waiting for the window's next round (default: false; it has no effect while TEMPORAL_PARALLEL_WINDOW_CHAINS is off, and loops directly in the item also need TEMPORAL_PARALLEL_WINDOW_INLINE_CHAINS). Each loop decision, including a While or Do While condition, is evaluated once and recorded; merging the item reuses the recorded decision and never evaluates the condition again. A run still stops after 64 blocks, at a Wait, approval, Parallel, document generation or failed block, at a child workflow call or return, at the end of the item, and on a retried attempt. Results, logs, per-item order, the concurrency limit and exactly-once handling of external calls are unchanged. Every Worker of this release merges recorded loop decisions whatever this setting says, so roll out in steps: deploy the release to every Worker with the setting off, wait until no run still holds loop decisions recorded by an older release (or none were ever recorded), confirm every Worker runs this release, and only then turn it on. An older Worker merging the item could not use the recorded decisions: a release without loop control would run the next iteration's blocks again, and the first release with it would fail the run |
TEMPORAL_STREAK_INTO_CHILD_WORKFLOWS | true to let a loop inside a child workflow (a Workflow block's called workflow) run its next iteration in the same Activity, instead of returning to the Workflow once per iteration (default: false). The same rules as for loops in the calling workflow apply: the loop and every Workflow block that leads to it must be outside any Parallel or Parallel Window, and the Activity still stops at a Wait, approval, parallel, document generation block, the block after a single-attempt block, after 64 blocks, and on a retried attempt. Every block still commits its own checkpoint, so outputs, logs, order and recovery are unchanged, and Workers with and without the setting can run side by side |
TEMPORAL_PARALLEL_WINDOW_CHILD_SCOPES | true to schedule a Parallel Window inside a child workflow (a Workflow block that is not itself inside a Parallel Window) the same way as a window in the calling workflow: items are admitted up to the window's concurrency limit, a finished item's slot is refilled at once, and TEMPORAL_PARALLEL_WINDOW_CHAINS applies. Without it such a window runs in lockstep rounds, where every round waits for its slowest item (default: false). It applies to windows whose items settle on error and whose body calls no other workflow; other child windows keep the round-based schedule. Results, logs and per-item order are unchanged. Enable it only after every Worker runs a release that includes it: an older Worker cannot advance a window inside a child workflow |
TEMPORAL_PARALLEL_WINDOW_ITEM_STATE | How a Worker folds each Parallel Window item's recorded blocks and advances its loops (default: off). off replays them on the whole window state. on replays them on that item's own share of the run state (its blocks, loops and inputs, without the other items') and merges the item's changes back into the window, so window advancement costs the size of one item rather than of every item in flight, and a window with large items or higher concurrency advances faster. shadow does both, keeps the whole-state result and logs the first difference as an error; use it to check on against live runs, at more cost than either. shadow-strict fails the run on a difference instead, and is meant for tests. true, 1 and yes mean on; false, 0, no or an empty value mean off; any other value stops the Worker at startup. Results, logs, per-item order and checkpoints are the same in every mode, every block runs on the same input, and Workers in different modes can advance the same run, so the setting can be changed at any time. Checkpoints written by the version 1 format always use off |
Docker → Temporal Worker lists the per-queue concurrency variables. Task Queue names are fixed and cannot be renamed. Isolate environments with TEMPORAL_NAMESPACE.
Scheduled Assistant Configuration
Scheduled Sub Agents run model and tool calls inside the Temporal Worker. Configure the model-provider environment keys you use on that service as well as on the app. Stored BYOK keys and integration credentials require the same database and encryption settings; file tools require matching storage settings. The task saves model and reasoning choices, not a copy of the credential.
The Worker needs APP_URL, INTERNAL_API_SECRET, and TEMPORAL_WORKER_BROKER_SECRET when assistant tools request scoped credentials to start Temporal workflows. This requirement also applies when TEMPORAL_API_KEY_FILE or TEMPORAL_API_KEY supplies the Worker's polling token. The assistant credential broker does not issue worker or operator tokens. Keep Temporal signing private keys on the app.
See Scheduled Sub Agents for Activity timeouts, retry behavior, and the remaining app dependencies.
Apprise Order-Creation CLI
These settings apply to the source-checkout Apprise CLI. Order creation is not a workflow operation.
| Variable | Description |
|---|---|
APPRISE_APPROVAL_SECRET | Separate HMAC signing secret of at least 32 characters for CLI approval tokens. Required to mint or verify an approval. Keep separate from application authentication secrets |
APPRISE_APPROVAL_NONCE_DIR | Absolute path to shared persistent nonce storage, required for CLI commits. All processes and hosts using the same approval secret must share this directory on a filesystem supporting atomic exclusive creation. No default or in-memory fallback |
AI Providers
| Variable | Provider |
|---|---|
OPENAI_API_KEY | OpenAI |
ANTHROPIC_API_KEY_1 | Anthropic Claude |
GEMINI_API_KEY_1 | Google Gemini |
XAI_API_KEY_1 | xAI Grok |
MISTRAL_API_KEY | Mistral |
FIREWORKS_API_KEY | Fireworks AI |
OPENROUTER_API_KEY | OpenRouter. Unset hides OpenRouter models from the picker |
OLLAMA_URL | Ollama (default: http://localhost:11434) |
For load balancing, add multiple keys with _1, _2, _3 suffixes (e.g., OPENAI_API_KEY_1, OPENAI_API_KEY_2). Works with OpenAI, Anthropic, Gemini, and xAI.
In Docker, use OLLAMA_URL=http://host.docker.internal:11434 for host-machine Ollama.
Azure OpenAI
| Variable | Description |
|---|---|
AZURE_OPENAI_API_KEY | Azure OpenAI API key |
AZURE_OPENAI_ENDPOINT | Azure OpenAI endpoint URL |
AZURE_OPENAI_API_VERSION | API version (e.g., 2024-02-15-preview) |
AZURE_ANTHROPIC_API_KEY, AZURE_ANTHROPIC_ENDPOINT, AZURE_ANTHROPIC_API_VERSION | Anthropic models through Azure AI Foundry |
NEXT_PUBLIC_AZURE_CONFIGURED | true hides the Azure endpoint, key, and version fields in the Agent block once they are set server-side |
SteelEngine calls Azure OpenAI with the model ID minus its azure/ prefix as the deployment name, so each deployment must be named exactly like the catalog model (for example, deploy gpt-6-sol for azure/gpt-6-sol). The default Azure OpenAI model is azure/gpt-6-sol; gpt-6-astra and gpt-6-luna are also available.
Once AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY are set, GPT-6 Sol, Luna and Astra (Azure) also appear in the Chat model picker.
Google Vertex AI and AWS Bedrock
| Variable | Description |
|---|---|
VERTEX_PROJECT | Google Cloud project ID for Vertex AI |
VERTEX_LOCATION | Vertex AI region (default: us-central1). The Gemini 4 models are served only from global, us and eu (Gemini 4 Argon also from europe-west2 and asia-southeast1). With no location set, or a us-* region such as the default, they run in the us multi-region; any other location that does not serve the model is refused with an error naming the ones that do |
NEXT_PUBLIC_BEDROCK_DEFAULT_CREDENTIALS | true hides the Bedrock access-key fields when the deployment uses the AWS default credential chain (instance profile, task role, IRSA) |
vLLM (Self-Hosted)
| Variable | Description |
|---|---|
VLLM_BASE_URL | vLLM server URL without the /v1 suffix (e.g., http://localhost:8000). SteelEngine appends it |
VLLM_API_KEY | Optional bearer token for vLLM |
Laya Decision Server
The Laya Decision block calls a Laya decision server (laya-serve) that you deploy yourself: docker/selfhost/compose.laya.yml for Docker, or laya.enabled in the Helm chart. Set both variables on the app and the Temporal Worker; Laya blocks run in the Worker during workflow runs. Without LAYA_URL the block is hidden from the toolbar, search, and Mothership, Laya does not appear in the model controls, and existing Laya blocks fail with Laya is not available in this environment.
| Variable | Description |
|---|---|
LAYA_URL | Base URL of the Laya server, without /v1/systemone (e.g., http://laya:8000) |
LAYA_API_KEY | Bearer key; the same value the Laya server runs with |
LAYA_CAPACITY_URL | Optional. Capacity endpoint of an autoscaled Laya deployment (its /_capacity URL). When Laya answers busy or has no healthy host yet, the app or Worker asks it for more hosts (at most once a minute per process) while the block retries |
LAYA_CAPACITY_TOKEN | Bearer token for LAYA_CAPACITY_URL |
Model and Integration Restrictions
| Variable | Description |
|---|---|
BLACKLISTED_PROVIDERS | Comma-separated provider IDs to hide (e.g., openai,anthropic) |
BLACKLISTED_MODELS | Comma-separated model names or prefixes to hide (e.g., gpt-4,claude-*) |
ALLOWED_INTEGRATIONS | Comma-separated block types users may add (e.g., slack,github,agent). Empty allows all |
ALLOWED_MCP_DOMAINS | Comma-separated hostnames workspaces may add as MCP servers. Empty permits public destinations and explicit localhost/loopback URLs. Configured hosts may resolve to private addresses, but metadata and other absolute-deny addresses remain blocked. Other hosts fail with is not allowed by the server's ALLOWED_MCP_DOMAINS policy |
ELEVENLABS_API_KEY | Enables voice input (speech-to-text) in Chat |
The Chat model picker lists models whose provider has a server key or a workspace key, excluding blocked providers and models. When claude-opus-5 is not available, Chat defaults to the first model in the picker; on an Azure-only deployment that is azure/gpt-6-sol. A saved model that loses its provider key or is blocked resolves to that default in Chat, scheduled Sub Agents, and SQL Console AI generation. Reasoning-effort, provider, and organization access checks still apply. An empty roster requires provider configuration before these features can run.
MCP HTTP connections validate and pin every resolved address before connecting, including reconnects. A hostname resolving to loopback is rejected unless the URL explicitly uses localhost or a loopback IP. Redirects are rejected; configure the final MCP endpoint URL. This policy is separate from EGRESS_ALLOWLIST. Set MCP policy on the app and Temporal Worker when both execute MCP tools.
OAuth Providers
Each integration that connects with OAuth reads a <PROVIDER>_CLIENT_ID and <PROVIDER>_CLIENT_SECRET pair. Register an OAuth app in the provider's console. Use the redirect URI <NEXT_PUBLIC_APP_URL>/api/auth/oauth2/callback/<providerId>. Without the pair, the connect button renders but the flow fails with client_id=undefined. Among OAuth providers, only Google can sign in to SteelEngine; email/password and SSO sign-in are unaffected. Every other provider here, GitHub included, only connects an integration to an account that is already signed in, and cannot start a sign-in through either /sign-in/social or the OAuth callback.
| Variable | Description |
|---|---|
GOOGLE_CLIENT_ID | Google OAuth client ID (Calendar, Gmail, Drive, Sheets, Docs, Tasks, Contacts share one app) |
GOOGLE_CLIENT_SECRET | Google OAuth client secret |
GITHUB_CLIENT_ID | GitHub OAuth client ID for the GitHub integration. GitHub is not a sign-in method |
GITHUB_CLIENT_SECRET | GitHub OAuth client secret |
MICROSOFT_CLIENT_ID, MICROSOFT_CLIENT_SECRET | Outlook, Excel, Teams, and SharePoint share one app |
ATLASSIAN_CLIENT_ID, ATLASSIAN_CLIENT_SECRET | Jira and Confluence share one app. JIRA_* and CONFLUENCE_* override per product |
DISABLE_GOOGLE_AUTH | true turns off Google sign-in even when its credentials are set. Google integrations keep working |
The same pattern applies to SLACK, NOTION, MONDAY, LINEAR, ASANA, AIRTABLE, HUBSPOT, SALESFORCE, PIPEDRIVE, ATTIO, WEALTHBOX, DROPBOX, BOX, DOCUSIGN, WEBFLOW, WORDPRESS, LINKEDIN, X, REDDIT, SHOPIFY, SPOTIFY, ZOOM, SUPABASE, and DISCORD. CALCOM_CLIENT_ID, TRELLO_API_KEY, and APOLLO_API_KEY are single keys with no secret. apps/web/.env.example groups them by category.
Slack Events
These variables configure the deployment-wide hosted Slack app. Custom Slack apps store their configuration in Settings → Integrations → Custom apps instead; see Custom Apps.
| Variable | Description |
|---|---|
SLACK_SIGNING_SECRET | Signing secret for verifying hosted Slack events. No default |
SLACK_BOT_EVENTS | Comma-separated supported bot events enabled in the hosted app's manifest. The Secrets Manager seed script defaults missing values to the seven events below; unset or empty values disable hosted subscriptions. Does not update Slack subscriptions |
SLACK_USER_EVENTS | Retained configuration key with no effect. Managed workflow triggers accept bot events only |
Set the hosted app's Events API request URL to {{API_URL}}/api/integrations/slack/events. The endpoint returns 404 until SLACK_SIGNING_SECRET is set. The hosted app ID is read from the signature-verified event payload; no separate App ID setting is required. Declare only events enabled in the hosted manifest. Bot installation, channel permissions, and workflow deployment are still required before events can start workflows.
The seed script's default event list is:
app_mention,message.channels,message.groups,message.im,message.mpim,reaction_added,reaction_removedEnable these events under Event Subscriptions → Subscribe to Bot Events. Their bot permissions include app_mentions:read, chat:write, files:read, reactions:read, channels:history, groups:history, im:history, and mpim:history. Channel discovery also needs channels:read, groups:read, im:read, and mpim:read. Reconnect existing installations to authorize newly added scopes. The seed script preserves existing values, including an explicitly empty event list, and does not change settings in Slack.
For local Slack setup through ngrok or another HTTPS tunnel, see Local Development with a Tunnel.
Source Control
These server-side variables configure the deployment-wide GitHub App used by Workspace Source Control. They are separate from the personal GitHub OAuth variables above.
| Variable | Description |
|---|---|
GITHUB_APP_ID | Source Control GitHub App identifier |
GITHUB_APP_CLIENT_ID | GitHub App OAuth client ID used to browse repositories during setup |
GITHUB_APP_CLIENT_SECRET | GitHub App OAuth client secret; separate from workflow-action OAuth credentials |
GITHUB_APP_PRIVATE_KEY | GitHub App PEM private key; escaped \n newlines are supported |
GITHUB_APP_WEBHOOK_SECRET | GitHub webhook signing secret (minimum 16 characters) |
Hosted customers do not set these variables. SteelEngine manages the platform GitHub App; organization admins only install it and choose repository access.
Self-Hosted Promotion
These server-side settings enable self-hosted organization Git releases and the restricted signed-file workflow promotion API/CLI when the remaining promotion configuration is provisioned. They do not enable Kubernetes blue/green cutover. See Organization Releases for availability and Kubernetes Setup for the Helm overlay.
| Variable | Description |
|---|---|
PROMOTION_ENABLED | Defaults to false. Set true only for a configured self-hosted installation; hosted detection always rejects promotion |
PROMOTION_DEPLOYMENT_ID | Required when enabled. Persistent, unique installation UUID; web and both worker roles must agree |
PROMOTION_ENVIRONMENT_KEY | Required when enabled. Lowercase environment key such as dev or prod; starts with a letter and contains only letters, digits, or hyphens, up to 63 characters |
Configure compatible promotion workers, organization policy, independently provisioned trust, target-local assignments, and the authenticated promotion-notification scheduler before enrollment. The flag does not grant access. Disabling it does not remove an enrolled target's managed-write guards.
Workflow Egress Allowlist
By default, workflow HTTP calls (the API block and fetch inside function blocks) cannot reach private or reserved addresses, and hostnames that resolve to them are rejected the same way. On a self-hosted deployment this means workflows cannot call systems on your own network. EGRESS_ALLOWLIST opens specific destinations without changing the default for anything else.
| Variable | Description |
|---|---|
EGRESS_ALLOWLIST | Comma-separated destinations workflows may reach on private networks. Empty by default. Set it on every service that executes workflows: the app and the Temporal Worker. |
Each entry is scheme://host:port, optionally followed by =CIDR:
EGRESS_ALLOWLIST="https://erp.corp.internal:8443=10.0.42.0/24,http://legacy-tickets.corp:8080"- Exact host. No wildcards and no paths.
erp.corp.internaldoes not coverapi.erp.corp.internal. - Port required. An entry authorises one port. A URL with no port matches on the scheme default (443 or 80).
- Scheme is explicit. An
http://entry allows plaintext to that destination only. Usehttps://wherever the service supports it. - CIDR pin, recommended. When present, the address the host resolves to must fall inside it. This is what stops a DNS change for an allowlisted name from redirecting workflow traffic somewhere else.
An entry can never:
- reach instance metadata (
169.254.0.0/16,fe80::/10,fd00:ec2::254), loopback, unspecified, multicast, or broadcast addresses, even when DNS for the allowlisted name points there - open a blocked port (22, 23, 25, 3306, 5432, 6379, 27017, 9200) through an HTTP entry
- relax anything for a destination that is not listed
A malformed value stops the app and the Worker at startup with a message naming the bad entry, so a typo cannot widen the list or silently disable it.
Every request an entry permits is logged by the EgressAudit logger with the workflow id, workspace id, host, port, resolved IP, and the matching entry. Watch that log after enabling an entry. A destination you did not expect is the signal that something is wrong.
Workflow code is written by workspace users. Every destination in this list is reachable from every workflow on the deployment, including function blocks run from the editor. On a multi-tenant deployment, leave it empty unless a destination is meant to be shared with all tenants.
Private PostgreSQL and MSSQL databases
On self-hosted deployments, the PostgreSQL and MSSQL blocks also accept operator-configured entries in the same variable. Use postgres:// or mssql://, an exact hostname, an explicit port, and a required CIDR pin:
EGRESS_ALLOWLIST="https://erp.corp.internal:8443=10.0.42.0/24,postgres://warehouse.corp:5432=10.0.50.0/24,mssql://sql.corp:1433=10.0.60.0/24"- Database entries apply only to the named database provider. They do not permit HTTP requests, and HTTP entries do not permit database connections. The HTTP blocked-port list still applies to HTTP entries; a PostgreSQL entry can explicitly permit port 5432.
- Every resolved address must be covered by a CIDR for the same scheme, host, and port. Add separate entries for IPv4 and IPv6 when needed. Mixed public/private DNS answers are rejected, as are metadata, loopback, and other reserved addresses, regardless of the pins.
- Every database socket uses the validated addresses, retaining the original hostname for TLS. Existing TLS settings continue to apply. MSSQL private redirects require an entry for the routed host and port, including redirects that change only the port.
- Database exceptions are ignored on hosted SaaS deployments. A SteelEngine-hosted deployment dedicated to one customer can opt in with
EGRESS_ALLOWLIST_HOSTED_DATABASES=trueon the app and the Worker; self-hosted deployments never need it. MySQL, MongoDB, Neo4j, Redis, SFTP, SSH, SMTP, and IMAP remain outside this feature because their connection pinning has not been verified here. - Allowed database connections emit
Database egress allowlist permitted connectionthroughEgressAuditat INFO, with scheme, host, port, all resolved addresses, matching entries, and workflow/workspace identity when supplied by the execution context. No database credentials are logged.
Set the same value on the web app and Temporal Worker, then restart both. A missing database CIDR or unsupported scheme fails startup. Verify a connection from each execution service and inspect the audit log; then verify that another private host or port remains blocked. Remove a database entry and restart both services to revoke the exception. INTERNAL_TARGET_ALLOWLIST is not used.
Authentication and Access
Sign-up is invitation-only and has no setting. An account is created from an invitation link, by an administrator (the admin API with ADMIN_API_KEY), or by SSO just-in-time provisioning. The invitee opens the emailed link, then signs up with the invited address by email or with Google; the invitation must still be pending. On a new install with no accounts, the first sign-up needs no invitation, so you can create the first admin. DISABLE_INVITATIONS controls workspace invitations; it is not a global switch that disables account creation from every invitation type.
This also accepts active credential-set invitations addressed to a specific email: the invitee opens /credential-account/<token> and signs up with that address. Shared credential invitation links without an addressee require an existing account. The browser's proof of opening an invitation lasts one hour; reopen the link if it expires. The invitation itself must still be pending and unexpired when the account is created.
Email and password, Google, and SSO are the sign-in methods. Other OAuth providers, GitHub included, only connect integrations to a signed-in account.
| Variable | Description |
|---|---|
API_ENCRYPTION_KEY | Encrypts stored API keys (32 hex chars): openssl rand -hex 32. Set the same value on the app and the Worker |
ADMIN_API_KEY | Admin API key for GitOps and organization management (32+ chars). Sent as x-admin-key |
WORKLOAD_AUTH_ENABLED | Defaults to false. Set true on web and all workers to enable self-hosted Entra application authentication. Configure trust before enabling; redeploy both processes after changes. See Entra workload identities |
WORKLOAD_AUTH_PROFILE | JSON with exactly id, tenantId, audience, applicationIdUri, role. One global/commercial Entra tenant, resource API audience and required app role per installation. Required when workload auth is enabled; independent of human SSO/SCIM. Keep web and worker values consistent. The organization dashboard manages application bindings and local grants |
DISABLE_AUTH | true bypasses authentication and gives every request an anonymous session. Use it on private networks only. Ignored when the app URL is a steelengine.com host. Set it on realtime too |
ALLOWED_LOGIN_DOMAINS | Optional; only for single-customer deployments. Comma-separated email domains allowed to sign up and sign in, by every method, including Google and SSO, on top of the invitation rule. Matching ignores case; a domain entry does not include its subdomains. Existing users outside the list can no longer sign in. A session they already hold keeps working until it is revoked or goes 30 days unused, so revoke those sessions after narrowing the list. Leave it unset to allow any domain. Admins can still create accounts and impersonate users outside the list |
SIGNUP_EMAIL_VALIDATION_ENABLED | true rejects disposable email domains at signup |
EMAIL_PASSWORD_SIGNUP_ENABLED, NEXT_PUBLIC_EMAIL_PASSWORD_SIGNUP_ENABLED | false disables email/password sign-in and sign-up on the server and hides the email/password form. Disabled authentication requests return 403. Use with SSO |
TURNSTILE_SECRET_KEY, NEXT_PUBLIC_TURNSTILE_SITE_KEY | Cloudflare Turnstile keys. Leave both unset to disable the captcha |
ADDITIONAL_TRUSTED_ORIGINS | Comma-separated extra browser origins. Better Auth trusts them, /api/* allows them for credentialed CORS alongside the app URL, and /api/mcp/serve/* allows them for CORS |
ALLOWED_ORIGINS | Realtime server only. Comma-separated extra CORS origins beyond the app URL |
Removed in this release
These variables no longer do anything. A deployment that still sets them starts normally and ignores them; remove them when convenient.
DISABLE_REGISTRATION: nothing to replace it. Sign-up is always invitation-only.ALLOWED_LOGIN_EMAILS: invite those people instead. To limit a single-customer deployment to its company, setALLOWED_LOGIN_DOMAINS.BLOCKED_SIGNUP_DOMAINS: nothing to replace it. Nobody signs up without an invitation.EMAIL_VERIFICATION_ENABLED: nothing to replace it. Opening the invitation link proves the address, so verification codes and the/verifypage are gone.DISABLE_GITHUB_AUTH: nothing to replace it. GitHub is not a sign-in method;GITHUB_CLIENT_IDandGITHUB_CLIENT_SECRETconfigure only the GitHub integration. An account that only ever signed in with GitHub resets its password from the login page, or signs in with Google when Google uses the same address.
Feature Toggles
Hosted plans gate these features by subscription. A self-hosted deployment enables them directly. Each server-side flag has a NEXT_PUBLIC_ twin that shows the matching UI. See Enterprise for what each feature does.
| Variable | Description |
|---|---|
ORGANIZATIONS_ENABLED, NEXT_PUBLIC_ORGANIZATIONS_ENABLED | Organizations. Also on when BILLING_ENABLED or ACCESS_CONTROL_ENABLED is on |
ACCESS_CONTROL_ENABLED, NEXT_PUBLIC_ACCESS_CONTROL_ENABLED | Permission groups. Turns organizations on as well |
CREDENTIAL_SETS_ENABLED, NEXT_PUBLIC_CREDENTIAL_SETS_ENABLED | Credential sets for email polling triggers |
INBOX_ENABLED, NEXT_PUBLIC_INBOX_ENABLED | SteelEngine Mailer on self-hosted, regardless of plan. The NEXT_PUBLIC_ twin shows Mailer in Settings. Needs AGENTMAIL_API_KEY |
SSO_ENABLED, NEXT_PUBLIC_SSO_ENABLED | Single sign-on. See SSO |
DISABLE_INVITATIONS, NEXT_PUBLIC_DISABLE_INVITATIONS | true turns off workspace invitations everywhere |
DISABLE_PUBLIC_API, NEXT_PUBLIC_DISABLE_PUBLIC_API | true removes the public API toggle from workflows |
E2B_ENABLED, E2B_API_KEY, NEXT_PUBLIC_E2B_ENABLED | Remote E2B sandboxes for Python Function blocks and JavaScript that imports packages. Set E2B_ENABLED and E2B_API_KEY on both the app and the Worker, since Function blocks run in the Worker. Without E2B, those blocks fail; plain JavaScript runs in a local VM |
CODE_RUNNER_URL, CODE_RUNNER_TOKEN | Worker only. Runs Python Function blocks and JavaScript that imports packages in your own code runner service (docker/code-runner.Dockerfile) instead of E2B, so the code and its data stay in your environment. CODE_RUNNER_TOKEN is required with the URL and must match the runner's RUNNER_TOKEN. The runner has Python's standard library plus requests, and Node's built-in modules; code that needs other packages still needs E2B. Copilot's table files always use E2B. Run the runner under a VM-isolating runtime such as Kata Containers or gVisor |
BILLING_ENABLED, NEXT_PUBLIC_BILLING_ENABLED | Billing enforcement and usage tracking. See Billing and Email |
Landing Pages
| Variable | Description |
|---|---|
NEXT_PUBLIC_LANDING_ENABLED | false redirects the homepage and marketing routes such as /blog, /integrations, and /models to /login. true enables them. When unset, enabled for steelengine.com and its subdomains except customer hosts matching sig-*.steelengine.com; disabled for other hosts. The host comes from NEXT_PUBLIC_APP_URL |
Set this under app.env in Helm. It controls the marketing pages; authentication and registration use the separate settings above.
SSO
SSO_ENABLED and NEXT_PUBLIC_SSO_ENABLED turn the feature on. Register the provider itself with bun run packages/db/scripts/register-sso-provider.ts. The script reads:
| Variable | Description |
|---|---|
SSO_PROVIDER_TYPE | oidc or saml |
SSO_PROVIDER_ID | Identifier used in callback URLs |
SSO_ISSUER | Identity provider issuer URL |
SSO_DOMAIN | Email domain routed to this provider |
SSO_USER_EMAIL | Existing user who owns the registration |
SSO_ORGANIZATION_ID | Optional organization to attach the provider to |
SSO_OIDC_CLIENT_ID, SSO_OIDC_CLIENT_SECRET | OIDC client. Endpoints come from discovery unless SSO_OIDC_*_ENDPOINT overrides them |
SSO_SAML_ENTRY_POINT, SSO_SAML_CERT | SAML IdP SSO URL and signing certificate. SSO_SAML_CALLBACK_URL, SSO_SAML_AUDIENCE, and metadata are optional |
SSO_MAPPING_ID, SSO_MAPPING_EMAIL, SSO_MAPPING_NAME, SSO_MAPPING_IMAGE | Claim mappings. Defaults fit standard OIDC and SAML claims |
Set SSO_ENABLED=true after the script succeeds. packages/db/scripts/deregister-sso-provider.ts removes a provider.
In the app, only platform admins (users whose role is admin) can register, change, or remove a provider, whether in Organization Settings → SSO or through the /api/auth/sso/* endpoints that write providers. Organization admins see the active connection but cannot edit it.
Database, Redis, Realtime, and Storage
| Variable | Description |
|---|---|
DATABASE_POOL_MAX | Connections per process. Compose sets 20 for the app and 25 for the Worker |
DATABASE_LOCK_TIMEOUT_MS, DATABASE_STATEMENT_TIMEOUT_MS | Per-session PostgreSQL timeouts. Compose sets 5,000 and 30,000 for the app, 5,000 and 60,000 for the Worker |
DATABASE_MAX_LIFETIME_SECONDS | Seconds before each pooled connection is closed and replaced, after any running query finishes (1 to 86,400). Unset keeps the client default of 30 to 60 minutes. Behind PgBouncer, set it well below pgbouncer.terminationGracePeriodSeconds so connections leave a stopping PgBouncer pod before it is killed |
DATABASE_SESSION_URL | Direct database URL for work that needs one server session, such as advisory locks. Set it when DATABASE_URL goes through a transaction pooler. The Helm chart sets it on the app when pgbouncer.enabled is on |
REDIS_URL | Optional. Enables the cross-pod Socket.IO adapter on realtime and caching on the app and Worker. Temporal, not Redis, carries the job queues |
SOCKET_SERVER_URL | Server-side URL the app uses to reach realtime (Compose default: http://realtime:3002) |
INTERNAL_API_BASE_URL | Server-side base URL for the app's own API calls. The Helm chart requires it when the Worker is enabled. Must be HTTPS with the production credential broker |
STEELENGINE_LOCAL_STORAGE_ROOT | Directory for uploads when neither S3 nor Azure is configured (default: ./uploads in the process working directory) |
AWS_REGION, S3_BUCKET_NAME | Both set selects S3 storage. Credentials come from S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY (storage-scoped), AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or the AWS default chain |
S3_ENDPOINT, S3_FORCE_PATH_STYLE | S3-compatible endpoint such as MinIO. Path style defaults to on when an endpoint is set |
S3_KB_BUCKET_NAME, S3_EXECUTION_FILES_BUCKET_NAME, S3_CHAT_BUCKET_NAME, S3_PROFILE_PICTURES_BUCKET_NAME, S3_OG_IMAGES_BUCKET_NAME | Per-purpose buckets. Execution files default to steelengine-execution-files |
AZURE_STORAGE_CONTAINER_NAME with AZURE_ACCOUNT_NAME and AZURE_ACCOUNT_KEY, or AZURE_CONNECTION_STRING | Selects Azure Blob storage. Azure wins when both S3 and Azure are configured |
AZURE_STORAGE_KB_CONTAINER_NAME, AZURE_STORAGE_EXECUTION_FILES_CONTAINER_NAME, AZURE_STORAGE_CHAT_CONTAINER_NAME, AZURE_STORAGE_PROFILE_PICTURES_CONTAINER_NAME, AZURE_STORAGE_OG_IMAGES_CONTAINER_NAME | Per-purpose containers, mirroring the S3 buckets |
The published images run with NODE_ENV=production. The database pool then requires TLS unless DATABASE_URL carries ?sslmode=disable. Storage variables must match on the app and the Worker. The Worker writes execution files and knowledge base content with the same rules.
Limits and Timeouts
The execution timeout variables below provide defaults for workflows whose Execution timeout setting is blank. A per-workflow override replaces that execution budget with a hard elapsed-time limit, including waits and approval pauses. Clearing it restores the defaults for new runs.
Defaults are shown per plan tier. Values are strings. When billing is disabled, plan tiers do not apply. Every execution uses the enterprise rate limits (defaults: 600 sync, 5000 async, and 500 API endpoint requests per minute; RATE_LIMIT_ENTERPRISE_SYNC and RATE_LIMIT_ENTERPRISE_ASYNC override the first two). Workflows without a timeout override use the enterprise execution timeouts. Every workspace gets the enterprise table limits (10,000 tables of up to 1,000,000 rows each), storage caps are off, and workspace concurrency uses WORKSPACE_CONCURRENCY_ENTERPRISE (default 200). Raise EXECUTION_TIMEOUT_ENTERPRISE or EXECUTION_TIMEOUT_ASYNC_ENTERPRISE if runs need longer. Workflows the Chat assistant or an MCP client runs and waits on are limited to 10 minutes; set COPILOT_MCP_SYNC_TIMEOUT_MS (milliseconds) to change that.
| Variable | Description |
|---|---|
RATE_LIMIT_WINDOW_MS | Rate limit window (default: 60000) |
RATE_LIMIT_FREE_SYNC, RATE_LIMIT_FREE_ASYNC | API executions per window (defaults: 50, 200) |
RATE_LIMIT_PRO_SYNC, RATE_LIMIT_PRO_ASYNC | Defaults: 150, 1000 |
RATE_LIMIT_TEAM_SYNC, RATE_LIMIT_TEAM_ASYNC | Defaults: 300, 2500 |
RATE_LIMIT_ENTERPRISE_SYNC, RATE_LIMIT_ENTERPRISE_ASYNC | Defaults: 600, 5000 |
MCP_RATE_LIMIT_BURST, MCP_RATE_LIMIT_PER_MINUTE | SteelEngine MCP requests per user: how many can arrive at once, then how many per minute after that (defaults: 60, 30). Over the limit, the MCP endpoint returns HTTP 429 with Retry-After |
EXECUTION_TIMEOUT_FREE, EXECUTION_TIMEOUT_PRO, EXECUTION_TIMEOUT_TEAM, EXECUTION_TIMEOUT_ENTERPRISE | Default synchronous execution timeout in seconds when the workflow has no override (defaults: 300, then 3000) |
EXECUTION_TIMEOUT_ASYNC_FREE and the _PRO, _TEAM, _ENTERPRISE variants | Default asynchronous execution timeout in seconds when the workflow has no override (default: 5400) |
WORKSPACE_CONCURRENCY_FREE, _PRO, _TEAM, _ENTERPRISE | Concurrent executions per workspace (defaults: 5, 50, 200, 200) |
ADMISSION_GATE_MAX_INFLIGHT | In-flight execution requests per app process (default: 500) |
EXECUTION_ADMISSION_POLICY_MODE, EXECUTION_ADMISSION_FIXED_PROFILE, EXECUTION_ADMISSION_ROLLOUT_MODE, EXECUTION_ADMISSION_CONCURRENCY_ENABLED | Execution admission policy. Set identical values on the app and the Worker. helm/steelengine/values.yaml lists the accepted values |
FREE_STORAGE_LIMIT_GB, PRO_STORAGE_LIMIT_GB, TEAM_STORAGE_LIMIT_GB, ENTERPRISE_STORAGE_LIMIT_GB | Storage caps in GB (defaults: 5, 50, 500, 500) |
IVM_POOL_SIZE, IVM_MAX_FETCH_RESPONSE_BYTES, IVM_MAX_STDOUT_CHARS | Function block sandbox pool size (default 4), fetch response cap (default 32 MiB), and captured stdout (default 200000 chars) |
IVM_MAX_TOTAL_WORKERS | Function block sandbox processes, counting ones being recycled (default: twice IVM_POOL_SIZE). A recycled process finishes its running code while a replacement takes new work; this caps how many exist at once. Values below IVM_POOL_SIZE are raised to it, and a value equal to it makes new work wait for recycled processes to finish |
IVM_CANCEL_GRACE_MS | Milliseconds to wait for a local JavaScript worker to acknowledge cancellation, including cancellation after an execution deadline (default 1000). Set 0 to skip the grace period; negative values are treated as 0. If acknowledgement does not arrive in time, the worker is terminated and its other running executions also fail. This does not extend the code execution timeout |
Local JavaScript execution capacity stays reserved until cancellation is acknowledged, the execution returns a result, or its worker exits. A worker that misses the parent execution deadline stops accepting new work; after acknowledging cancellation, it lets its other executions finish before retiring. A worker awaiting forced termination counts against IVM_MAX_TOTAL_WORKERS until its exit is confirmed. The local pool does not automatically replay failed executions. See Function block cancellation and recovery.
Run History Retention
Cron routes delete old run history, one bounded batch per call, so a large backlog clears over many runs. Runs that are paused or waiting for an approval are never deleted, and audit logs are not touched.
/api/logs/cleanupdeletes execution logs with their traces and outputs. Workflow snapshot cleanup is suspended: root and child graph snapshots remain stored, including after their logs expire, so retained runs keep their child-workflow views. Both live cleanup and dry-run responses reportresults.snapshots.skipped: true. With S3 or Azure Blob storage it also deletes the files each run produced, underexecution/<workspace>/<workflow>/<execution>/, and archives theirexecutionfile records. Files a run only referenced, such as workspace documents, are never deleted, and their records are never changed. Before deleting a run it writes a copy tologs/archived/<date>/<log id>.jsonin the files bucket; nothing reads those copies, so give that prefix a lifecycle rule that expires it (SteelEngine Cloud uses 7 days)./api/cron/execution-retentiondeletes old Temporal journals and finished checkpoint chains and does nothing else./api/cron/cleanup-stale-executionsruns the same journal and checkpoint retention, plus the stale-run and admission reconcilers.
In Helm, cronjobs.jobs.cleanupExecutionLogs runs /api/logs/cleanup and is off by default; cleanupStaleExecutions runs /api/cron/cleanup-stale-executions every five minutes. Retention runs under a Postgres advisory lock in every route, so a run that overlaps another skips it; /api/logs/cleanup and /api/cron/execution-retention then return {"skipped": true}. Each retention statement waits at most 5 seconds for a row lock and runs at most 60 seconds, whatever DATABASE_LOCK_TIMEOUT_MS and DATABASE_STATEMENT_TIMEOUT_MS say. A row another session holds makes that batch give up with a warning, and a later run retries it. Add ?dryRun=1 to /api/logs/cleanup or /api/cron/execution-retention to see what the next run would delete without deleting anything, and check that before enabling a schedule:
curl -H "Authorization: Bearer $CRON_SECRET" "$APP_URL/api/logs/cleanup?dryRun=1"A journal is the detailed execution record behind a run. Once it is deleted, GET /api/jobs/{id} answers from run history, and promotion validation can no longer cite the run.
| Variable | Description |
|---|---|
LOG_RETENTION_DAYS | Days to keep run history after a run finishes, for every workspace (default 90, from 1 to 3650) |
TEMPORAL_EXECUTION_CHECKPOINT_RETENTION_DAYS | Days to keep a finished run's checkpoint chain (default 90, minimum 30). A chain that a kept log's trace view still reads stays until that log is deleted |
TEMPORAL_EXECUTION_JOURNAL_RETENTION_DAYS | Days to keep a finished run's private Temporal journal (default 30, minimum 7). Cleanup first copies the run's version label onto its log, so the Logs page still shows it |
TEMPORAL_EXECUTION_JOURNAL_CLEANUP_BATCH_SIZE, TEMPORAL_EXECUTION_CHECKPOINT_CLEANUP_BATCH_SIZE | Journals (default 250, at most 1000) and checkpoint chains (default 25, at most 100) one cleanup run may delete |
An organization can keep run history longer than LOG_RETENTION_DAYS, never shorter: cleanup applies whichever is longer. Set it from packages/db with DATABASE_URL pointing at the deployment's database:
bun run ./scripts/run-history-retention.ts set <organizationId> 365
bun run ./scripts/run-history-retention.ts status <organizationId>
bun run ./scripts/run-history-retention.ts clear <organizationId>FREE_PLAN_LOG_RETENTION_DAYS was removed. It shortened retention for Community-plan workspaces when billing was enabled. A deployment that still sets it starts normally; cleanup ignores it and logs a warning.
Billing and Email
| Variable | Description |
|---|---|
BILLING_ENABLED, NEXT_PUBLIC_BILLING_ENABLED | Turn on Stripe billing and usage enforcement, including plan-tier rate limits and timeouts. With billing disabled, every workspace gets the enterprise limits. Most self-hosted deployments leave both unset |
STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET | Stripe API and webhook credentials |
STRIPE_PRICE_TIER_BUILDER_MO, STRIPE_PRICE_TIER_TEAM_MO, STRIPE_PRICE_TIER_SCALE_MO and the _YR variants | Stripe price IDs for the self-serve plans |
COST_MULTIPLIER | Multiplier for cost calculations |
SENDGRID_API_KEY | SendGrid API key. When set, every email SteelEngine sends goes through SendGrid, including workflow notification emails from the Temporal Worker. It takes precedence over Resend and Azure, and there is no fallback: a failed SendGrid send is logged and not retried on another provider. Verify the FROM_EMAIL_ADDRESS (or noreply@ your EMAIL_DOMAIN) and PERSONAL_EMAIL_FROM senders in SendGrid, or authenticate their domain |
RESEND_API_KEY | Resend API key for transactional email |
AZURE_ACS_CONNECTION_STRING | Azure Communication Services. Used as the fallback when Resend fails, or alone when Resend is unset |
FROM_EMAIL_ADDRESS | Complete sender address, e.g. SteelEngine <noreply@yourdomain.com> |
EMAIL_DOMAIN | Sender domain used when FROM_EMAIL_ADDRESS is not set |
PERSONAL_EMAIL_FROM | Sender for personalized emails |
EMAIL_FROM | Sender for workflow notification emails the Temporal Worker sends through Resend (default: SteelEngine <noreply@steelengine.app>). Ignored when SENDGRID_API_KEY is set. docker/selfhost/compose.yml sets it to FROM_EMAIL_ADDRESS when you leave it unset |
TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE_NUMBER | SMS sending |
AGENTMAIL_API_KEY | AgentMail API key for the SteelEngine Mailer. Mailer fails with AGENTMAIL_API_KEY is not configured without it |
AGENTMAIL_DOMAIN | Optional domain for Mailer inbox addresses (default: agentmail.to) |
With none of SENDGRID_API_KEY, RESEND_API_KEY or AZURE_ACS_CONNECTION_STRING set, SteelEngine sends no email. It logs Email not sent (no email service configured) together with any verification or reset link. Copy the link from the logs.
SteelEngine turns off SendGrid click, open, subscription and Google Analytics tracking on its emails, so verification and reset links reach recipients unchanged.
The Temporal Worker reads the same SENDGRID_API_KEY, FROM_EMAIL_ADDRESS and EMAIL_DOMAIN. The Helm chart and docker/selfhost/compose.yml pass them to the Worker for you. Compose also passes RESEND_API_KEY to the app and the Worker, and EMAIL_FROM to the Worker. If you use app.secrets.existingSecret or External Secrets, add SENDGRID_API_KEY to that Secret; both pods load it.
Branding
All branding variables are NEXT_PUBLIC_ values. The Helm chart sets them under app.env. Colors must be six-digit hex.
| Variable | Description |
|---|---|
NEXT_PUBLIC_BRAND_NAME | Product name shown in the UI (default: SteelEngine) |
NEXT_PUBLIC_BRAND_LOGO_URL | Square icon for the collapsed sidebar |
NEXT_PUBLIC_BRAND_WORDMARK_URL | Wide wordmark for the expanded sidebar |
NEXT_PUBLIC_BRAND_FAVICON_URL | Favicon |
NEXT_PUBLIC_BRAND_PRIMARY_COLOR, NEXT_PUBLIC_BRAND_PRIMARY_HOVER_COLOR | Primary color and hover state, #RRGGBB |
NEXT_PUBLIC_BRAND_ACCENT_COLOR, NEXT_PUBLIC_BRAND_ACCENT_HOVER_COLOR | Accent color and hover state, #RRGGBB |
NEXT_PUBLIC_BRAND_BACKGROUND_COLOR | Background color, #RRGGBB |
NEXT_PUBLIC_CUSTOM_CSS_URL | Extra stylesheet loaded after the app's own |
NEXT_PUBLIC_SUPPORT_EMAIL | Support address shown in the UI (default: support@steelengine.com) |
NEXT_PUBLIC_DOCUMENTATION_URL, NEXT_PUBLIC_TERMS_URL, NEXT_PUBLIC_PRIVACY_URL | Replace the documentation, terms, and privacy links |
On Kubernetes, branding.enabled in the Helm chart mounts logo and CSS files at /app/public/branding so these URLs can point at the app itself.
Example .env
BETTER_AUTH_SECRET=<openssl rand -hex 32>
ENCRYPTION_KEY=<openssl rand -hex 32>
INTERNAL_API_SECRET=<openssl rand -hex 32>
TEMPORAL_WORKER_BROKER_SECRET=<a different openssl rand -hex 32 value>
POSTGRES_PASSWORD=<openssl rand -hex 16>
NEXT_PUBLIC_APP_URL=https://steelengine.yourdomain.com
BETTER_AUTH_URL=https://steelengine.yourdomain.com
NEXT_PUBLIC_SOCKET_URL=https://steelengine.yourdomain.com
TEMPORAL_WORKER_APP_URL=https://steelengine.yourdomain.com
TEMPORAL_ADDRESS=temporal.yourdomain.com:7233
TEMPORAL_NAMESPACE=steelengine-production
TEMPORAL_SERVER_NAME=temporal.yourdomain.com
TEMPORAL_AUTH_ISSUER=https://steelengine.yourdomain.com
TEMPORAL_AUTH_JWKS_URL=https://steelengine.yourdomain.com/api/auth/jwks
TEMPORAL_BUILD_ID=<image digest or git sha>
OPENAI_API_KEY=sk-...See apps/web/.env.example for more options.