NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
Go modules
Go modules, #1875 by repository stars
Latest stable
v0.20.15
Last release 17 days ago
05 Nov 2026
Ships on a steady schedule
a new release about every 9 days
Nearly every release is documented
notes for 56 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
1 years old
180 releases · first in 2025
Drag across the ruler to compare, or tap a release to open it.
13ef597 : Pin SDK modules to v0.20.15 for release ( @akclace )
Your coding agent can read these notes before it upgrades. Set up the MCP server →
app.stage.example.com for app.example.com, instead of stage.app.example.com. The staging apps of *.example.com are then all under *.stage.example.com, so one wildcard DNS record and one wildcard certificate cover them. This is the new stage_at mode domain_suffix, which is now the default for system.stage_at.
example.org stage where they did before (stage.<domain>).stage_at = "domain" in the [system] config, or pass --stage-at domain / stage_at="domain" per app.stage.<domain> and *.stage.<domain> entries for new subdomain apps.default_domain, OpenRun assumes you control the parent of the app's hostname (registrable domains are detected with the Public Suffix List). If the hostname is the only name you control, such as tools.customer.com pointed at your server, set the staging location explicitly with --stage-at. See the staging domain docs.domain_suffix is now a reserved stage_at value and can no longer name a custom staging domain.domain_suffix and treat it as a staging domain name. If you set stage_at = "domain_suffix" explicitly (in openrun.toml, dynamic config or an apply file), change it to domain or remove it before running an older version. The built-in default needs no action.429fc2a : Pin SDK modules to v0.20.14 for release ( @akclace )
19c5175 : Fix pod restart handling on Kubernetes ( @akclace )
kubectl scale) no longer keeps proxying to it with 502 errors until the next deploy. A refused connection to a scaled-down workload now returns 503 with Retry-After: 1 and closes the instance, so the retried request restarts the app. The background health check catches the case when no request does. A workload that is unhealthy or mid-rollout keeps its replicas and is left to Kubernetes readiness, as before.min_replicas) instead of always one. The count is recorded in a dev.openrun.replicas annotation on the Deployment; Deployments created by an earlier version wake with one replica until their next deploy.use_node_port, so the first request after a deploy no longer races kube-proxy's routing update.kubernetes.namespace) instead of the apps namespace, where it always found none. Kaniko rows no longer link to the container detail page, which cannot open them.http: proxy error: ... lines from the Go standard library logger. Requests cancelled by the client are logged at debug level.e31d375 : Pin SDK modules to v0.20.12 for release ( @akclace )
Release pkg/plugin/v0.20.11
Release pkg/plugin/v0.20.11
f4bcbf109d868acea086139acf0e151759ed7ec1: Pin SDK modules to v0.20.10 for release (@akclace)
trust_unverified_email = true on an [auth.oidc_<name>] entry makes the signed ID token's email the user identity when the identity provider sends no email_verified claim at all, for a single-tenant IdP whose directory admins own the email attribute (Microsoft Entra ID never sends the claim, nor do ADFS and OneLogin by default). An explicit false still drops the email, an address that only appears in or differs in the UserInfo response is never trusted, and the server logs a warning at every start while the option is on. The option is refused on the named provider types (#117).oidc provider accepts Microsoft Entra ID's xms_edov ("email domain owner verified") optional claim as email verification, so an Entra app registration that emits it keeps email identities with no OpenRun setting. If the registration already emits xms_edov, Entra users switch from subject to email identities at their next login: re-key subject-based grants first (see the Authentication docs, "Identity providers that do not send email_verified").oidc provider keeps separate email verification verdicts for the ID token and the UserInfo response: a false from either, or a value that is neither true nor false, now drops the email even when the other source says true. Previously a UserInfo email_verified: true overrode an ID token false.332c5bafb26f7ad7bc71fa03c677fdf25f05c609: Fix action selection dropdown (@akclace)
f69ed94d1af862a7bc53975dd58cda0366be01bd: Add d2 diagrams and restucture public docs (@akclace)
security.login_failure_rate_limit (default 100 per minute), across HTTP Basic, the login form and the OAuth authorization server password page. A wrong admin username now costs the same bcrypt check as a wrong password.fs.serve_tmp_file download refuses a registered path which has since become a symlink, and checks the opened file is the one that was checked. An app could otherwise replace a served file with a link to any file the server can read. The download file name is now encoded with mime.FormatMediaType.fs.list and fs.find refuse a path with a .. element, so a permission argument pattern such as regex:^/data/ cannot be bypassed with /data/../etc.client_name is capped at 200 bytes and redirect_uris at 20 entries.azuread and microsoftonline OAuth providers, including named instances such as azuread_corp, take the user email from the userPrincipalName (bound to a domain the tenant verified) instead of the free-text mail attribute, so a user of another tenant cannot log in as an address of this organisation. A guest (#EXT#) principal gets no email identity and is identified by its principal name.clientAuth extended key usage is now accepted, and a server certificate from the same CA is refused.service:update on a service, service listings redact secret-named config values, show a connection url only as its scheme, username, host and path (the query is replaced by a marker), and redact any other value with connection string syntax entirely. Sync listings no longer return the webhook secret.- or contain whitespace, since they are positional arguments of the container command.--build-arg values (which can hold resolved secrets) are redacted in the debug log of image builds. A delegated build context is capped at 4 GiB decompressed (an archive reaching the cap is refused, not truncated) and 200000 entries, and extracted files keep no setuid bits and no group or other write access.? or control characters, in addition to a quote. The audit log query binds app ids as parameters. A sqlite binding path is limited to letters, digits and _ . - /.security.login_start_rate_limit. The form login always starts a fresh pre-auth session.ReadHeaderTimeout. The self-signed certificate key is written with mode 0600. The OpenTelemetry resource no longer includes the server's command line or process owner.1f9edcaabbc92ee2ee98cc85da01a539866b9586: Add checks for redacted fields (@akclace)
[builder_agent.*] entry set through the console or the dynamic config can only mount config_files from within security.allowed_mounts, and its dockerfile must be under security.remote_disk_read_paths when set over the remote API.{{secret}} parameters and binding credentials) is stored in a <workload>-env Secret loaded with envFrom instead of as literal values in the Deployment and Job pod templates. The Secret has the workload's ownership labels and follows its lifecycle; a job run's Secret is owned by its Job.HTTPS_PROXY too), follow at most three redirects and refuse an https to http redirect; [auth.*] and [saml.*] entries are dynamically settable, so the server could be steered into fetching internal services. An IdP on a private or local address needs the new static setting security.sso_allow_private_hosts = true. The SAML metadata error no longer echoes the IdP's response body.daisyui_url downloads from the server config may still reach an internal mirror.get_config_version also redact fields named like API keys (api_key, access_key, credential, a _key suffix), so a literal ANTHROPIC_API_KEY in a [builder_agent.*] env is no longer returned in plain text. History snapshots are redacted the same way as the current config.fs.serve_tmp_file records the symlink-resolved path which passed the fs.file_access check, and the download and expiry deletion refuse a path which has since gained a symlink component, so a served file cannot be redirected to delete a file outside the allowed directories.security.allowed_container_args regex: patterns must now match the whole flag value (anchored as \A(?:...)\z); a pattern relying on a substring match no longer accepts extra text around the allowed form.input.css and tailwind.config.js refuse style themes, custom_themes names, property names and values, and routing.template_locations containing { } ; @ " ' \ or newlines. system.tailwindcss_command is the tailwindcss executable only; arguments (such as npx tailwindcss) are no longer passed through.api.access_token_ttl, api.refresh_token_ttl and app_config.security.default_secrets_provider.fetch or EventSource poller of a tab whose session expired, a prefetch) reaches the app while the user is at the identity provider (#116).Nothing published for this version
2e4298ad6f2f69ca9649533334fc579ebd12af41: Add limits on resource usage by starlark functions and limit login attempts (@akclace)
oidc provider uses the email as the user identity only when the email_verified claim is true; an absent claim no longer counts as verified. Users of identity providers that omit the claim (Microsoft Entra ID, ADFS, OneLogin) or send false (Keycloak LDAP or brokered users, Cognito federated users) are identified as <provider>:<sub> from this version on, so email-keyed grants, the X-Openrun-User header and apps keyed on the email stop matching at their next login. See "Identity providers that do not send email_verified" in the Authentication docs for the per-IdP remedies, and the xms_edov support and trust_unverified_email option added after this release.builtin_users table instead of [builtin_auth.*] config entries. openrun user update gains --disable/--enable (a disabled user cannot log in, and its sessions, API keys and scheduled job authority stop) and --unlock; openrun user show <name> and the user_get API/MCP tool report a user's groups, state, creation and last login. After ten consecutive wrong passwords an account is locked for 15 minutes. A password change, disable or delete signs the user out of existing browser sessions immediately, and deleting a user revokes their API keys and OAuth tokens.admin:manage: changing who holds the admin permission (the grants and roles that confer it or admin:manage, and the membership of the groups those grants reference) through a dynamic config update, and placing a builtin user in such a group, now requires admin:manage or admin in addition to config:update / user:update. Previously any config:update holder (such as openrun-operator) could add themselves to an admin group. admin:manage is never matched by role or API key scope globs.user:read, user:create, user:update, user:delete and user:manage govern builtin user management (previously config:update/config:read). openrun-operator includes user:manage, openrun-monitor includes user:read. The write permissions are never matched by API key scope globs, like config:update.max_request_body_bytes (an [app_config] setting, 10MB by default) is refused with 413. int() refuses a string over 4096 characters; list, tuple, set, sorted, reversed, enumerate and zip refuse an iterable of over 16777216 known elements; a handler recursing over 10000 frames fails. The template functions until, untilStep and seq refuse over 1000000 items, and repeat, indent, nindent and the rand* functions an output over 16MB. system.memory_high_water_bytes (0 by default, which uses 90% of the Go memory limit when GOMEMLIMIT is set) cancels running Starlark handlers while the server's memory in use is over the mark.security.login_start_rate_limit (60 by default, 0 disables) caps the login handshakes (form login, OAuth/OIDC, SAML) a client IP may start per minute; further starts get a 429 response. The form login state of an expired login is kept for an hour after its deadline (was a day).openrun user commands send the password as entered, the /_openrun/user API field password and the MCP user_add tool field password (was password_hash) take the plaintext. The server enforces a password policy (8 to 128 characters, not equal to the username) and a username syntax (letters, digits and . _ @ + -; admin, anonymous and the openrun- prefix are reserved).config:update need user:manage (or the individual user:* permissions) now.[builtin_auth.*] section of openrun.toml is deprecated: its entries are imported as users at startup when no user of that name exists, an existing user is never changed from the file, and the section will be removed in a later release. A dynamic config document (openrun server update-config) carrying entries.builtin_auth is rejected. openrun user list no longer reports a static/dynamic source._created_by and _updated_by fields of an entry (anonymous when the request has no authenticated user); earlier versions always stored admin.print() output from app.star during app load and audit, and the tailwindcss watcher messages of dev apps, go to the server log instead of the server's stdout.test1/test1 and test2/test2, which v0.20.0 to v0.20.5 created on every install, are no longer created. On upgrade they are removed unless their password or groups were changed; a changed test1 or test2 is kept as an ordinary user. Create the users you need with openrun user add.routing.base_templates and the template locations) of apps served from disk now also match files supplied by the app spec, as the other file reads already did.Content-Length header instead of chunked transfer encoding, like the other body types.sp_key_file/sp_cert_file now also serves as the decryption key (an EncryptedAssertion from the IdP failed with "no decryption certs available") and signs the response to an IdP-initiated logout. A signed AuthnRequest over the HTTP-Redirect binding signs the query string (SigAlg/Signature) instead of embedding an XML signature the binding does not allow. Logout to an IdP single logout endpoint no longer panics without an SP keypair (the request is sent unsigned), and over the HTTP-Redirect binding the LogoutRequest signs the query string rather than embedding an XML signature. The SP metadata endpoint works without an SP keypair, lists the single logout endpoint, and is valid for seven days rather than 24 nanoseconds.security.auth_callback_domain, default auth.<system.default_domain>), where no app is ever served, and the AS metadata names that endpoint.Host header, and the OAuth callback, the SAML ACS and the login form submit send their single-use completion token only to a host the server serves./_openrun/auth/<provider>/redirect, /_openrun/sso/<provider>/redirect) no longer delete the browser session when a check fails: they are GET requests any site can navigate to, so a crafted link could log the user out. The single-use login state is consumed atomically and the pre-login nonce is dropped from the session once logged in.verified_email claim of the userinfo document. An identity row pre-provisioned by an API key takes the IdP subject on the first login; a login with a different real subject never replaces the recorded one.security.admin_password_bcrypt from the effective config on every check instead of caching the credential at startup, and the OAuth/SAML providers are rebuilt whenever a config re-apply carries a different security.callback_url. Both settings remain static config (openrun.toml, restart to change). A wrong admin username takes as long to reject as a wrong password.groups_attr is authoritative and no longer falls back to other attributes when the user has no values in it. The client metadata SSRF guard also blocks 0.0.0.0/8 and NAT64 (64:ff9b::/96) addresses that embed a private IPv4.builtin_users table (DB version 33) and the builtin_auth entries are scrubbed from the stored config history. Replacing the dynamic config (openrun server update-config --force) or restoring an old version can no longer delete or resurrect users.5fcef6ca04f5c7403dd389a9294705bc61ee234b: Evaluate string template for param static values only (@akclace)
settings.webhook_tokens, the credentials of the reload and promote webhook endpoints, which run without further authorization) were returned by the app get and list APIs to every caller with app:read_detail, while the token list API requires app:token_read; the built-in openrun-monitor role and the default read-only MCP scope have the former without the latter. The tokens are now returned only to a caller holding app:token_read on the app.fs.serve_tmp_file files at the default visibility (fs.USER) were served to any user of the app: the download handler compared the visibility with a value the plugin never stored. The file is now served to the registering user only, unless registered with fs.APP; the visibility value is validated. A file was also served through the download route of any app on the server, since the file store is shared; it is now served by the app that registered it only.http.in calls could reach a url the approved argument patterns and the disallow list never saw. The params values are merged into the url's query after the checks ran on the url argument, so a call could add or replace query values (http.get("https://api.example.com/items?mode=safe", params={"mode": "admin"})) past a pattern that constrained them; the url the request goes out with is now checked the same way a redirect target is.permissions.disallow argument patterns were matched against positional arguments only, so a call passing the restricted argument by keyword (http.get(url = ...)) skipped every deny rule with argument patterns; an entry with argument patterns now blocks a call that passes keyword arguments in place of the positional arguments it covers. Argument patterns were also matched against the raw argument text, and {{secret ...}} templates were resolved afterwards, so a template (a secret call in a branch that never runs is enough to make a string a template, and needs no secret grant) could assemble a value the checks never saw, for example a cloud metadata address a deny rule blocks. The disallow list and the argument patterns of the permission that approved the call are now checked again on the resolved values.http.in plugin followed redirects without re-checking the target, so a permitted host could redirect the request, with the app's custom headers, to a host the disallow list or the approved patterns exclude. Each redirect target is now checked as if the app had called the plugin with it, under the method of the redirected request (a 303 after a post is checked as a get), and a redirect is refused when the check fails.method of a permissions.allow or permissions.disallow entry accepts a regex: pattern. The default http.in entry, which auto-allows calls to the app's own container, used method = "regex:.*" but methods were compared as plain strings, so the entry never matched and the documented behavior did not exist. The http.in <CONTAINER_URL> placeholder is also validated after it is replaced by the container address: the url must stay on the container's scheme and host, so a suffix such as <CONTAINER_URL>@other-host/ can no longer redirect an auto-allowed container call to another host.{{secret ...}} template engine, with no way to tell a string the app wrote from one taken out of a request. Any user of an app that passed request text to a plugin (a query param into an http call, a form field into a command) could submit {{secret "NAME"}} for a secret the call was approved for and read it back from whatever the plugin returned or sent. Now only template values are evaluated, at any depth in list, tuple and dict arguments: an app level param value containing {{ (the params.star default or the --param value, both static) is such a value automatically, so apps passing param.NAME to a plugin keep working unchanged; a template built in app code is wrapped explicitly with ace.eval("..."), which is a no-op on a value which is already a template. Plain strings, request data and the values a caller supplies for an action or job run pass through literally. A template value supports + with strings (the strings stay literal) and str() gives the reference text; other string operations are type errors. Apps which put a {{secret ...}} literal directly in a plugin argument must wrap it in ace.eval. Container env and build args are unchanged.0cd316b0035e33a1769b720be00477b41926c568: Add an allowlist of commands permitted through exec.run plugin (@akclace)
exec.in plugin is governed by a server allowlist of host executables, security.allowed_exec_commands, in place of the plugin-wide permissions.disallow entry in the default config. The list is empty by default (no host command runs); entries are bare names looked up on the server PATH, absolute paths, absolute globs (/bin/*, /opt/tools/**) and ! exclusions, with "*" allowing every executable. Commands are matched on the file that would run, after PATH and symlink resolution, so a renamed symlink or a relative path cannot stand in for another program, and the command executes by that resolved path. An exact entry also requires the requested command to have the entry's name, so on a system where many commands are one multi-call binary (busybox on Alpine, the base of the official image; uutils coreutils on recent Ubuntu) listing ls does not admit sh or env (GHSA-2qf8-7646-rxgx). An exclusion matches by file or by name. A per-app exec.in approval alone no longer grants a command the server does not list. The OpenRun binary itself is always refused. The list is dynamic config; a dynamic update applies to already-loaded apps on their next call, and a malformed entry is rejected. Servers that cleared the disallow list to enable exec must now list the commands their apps run.exec.run is bounded by a new server allowlist of variable names, security.allowed_exec_env (GHSA-2qf8-7646-rxgx). Variables such as LD_PRELOAD, BASH_FUNC_* and GIT_SSH_COMMAND make an allowed program run other code, so an unfiltered environment let an app approved for one harmless command run anything. The list is empty by default: a call passing an unlisted variable is refused, a call passing no env runs with an empty environment as before. Entries are names, patterns (MYAPP_*), "*" for any, and ! exclusions. Dynamic config, validated like the command list. The security documentation now says that each entry in these lists grants code execution to the approved apps and which programs and variables to avoid.apply --pretty-print input) are accepted over the unix domain socket only. The REST and MCP management APIs and the console's openrun_admin plugin calls refuse them with an error. Apps and sync entries whose disk path was recorded by a caller on the server still reload, promote and run from anywhere. Paths under security.remote_disk_read_paths (static config, default ["$OPENRUN_HOME/app_src"]: the app builder's local publish area and the dev mode git checkout area) stay accepted from any caller, so builder-published apps can be created from and re-applied through the console. security.unsafe_enable_remote_disk_read = true (static config) restores the previous behavior. An empty app source is rejected instead of resolving to the server's working directory, and the folder part of a git url cannot contain .. components (it is joined onto the checkout directory).group: member of an RBAC group definition can name a group from the user's sign-in (OIDC/SAML groups, builtin user groups) instead of another config group (#112): "reporting-users": ["group:finance-analysts", "group:sales-ops"] matches a user whose login groups include either, checked on each request, and is inherited through nested groups. The name has the same meaning as in a grant's users list: the config group of that name if one is defined, and the sign-in group of that name. Previously a group: member naming no config group was rejected when the config loaded.destructive=True, the destructive management tools) are no longer run at once for a client which cannot confirm them (an older protocol, no form elicitation, a script calling the endpoint directly): the call is refused with a tool error. [api.mcp] destructive_confirm sets the mode: require (the new default), ask (the previous behavior: capable clients are asked, the others run the call at once) or skip (never ask). The mode is overridable per app with the action.destructive_confirm app config setting, and an API key created with openrun apikey create --confirm skip runs destructive tools without the prompt where the mode is ask, for headless automation. The audit event of a destructive call records how it was confirmed (confirm=accepted, declined, refused, unsupported, skipped, skipped_by_key). skip_destructive_confirm = true is kept as the same as destructive_confirm = "skip". Metadata database version 32 adds the key options column.openrun_status tool of /_openrun/app_mcp reports the destructive_confirm mode and whether the connection can confirm (can_confirm); the endpoint instructions state the rule.Hints column of openrun action list and the Hints: line of openrun action show spell the hints out: readonly, destructive, idempotent, open_world (were ro, idem, open).Nothing published for this version
34e5afca26a8bb7a0874c959a972a1a1434e9278: Fix #109: Update app state after apply with config only change (@akclace)
apply and scheduled syncs now save a declaration-only change (a param, container option, spec, auth or other app() setting) to an app whose git repo has no new commit (#109). With --reload=matched (the default) or --reload=updated, the up-to-date check skipped the code reload and the merged declaration was dropped with it, so the app was reported as both updated and skipped and every later sync run found the same difference.container.retain_previous_images app config setting (default 1) controls how many older versions keep their image for a quick version switch/version revert; the images of the current version of each app copy and of versions newer than the current one are always kept, -1 keeps every image. Switching to a version whose image was removed rebuilds it from the stored source. Each app version now records the image it was deployed with (image_name in the version metadata); images of versions deployed before this release are not tracked and are removed on the first deploy unless a container still uses them.db28936b44619e6312f4b675c0bb631ceaadd871: #105: Changed defaults for container secrets access (@akclace)
storage.googleapis.com with an HMAC key) failed with SignatureDoesNotMatch, because the AWS SDK signed the Accept-Encoding header that GCS rewrites in transit (#107). Litestream is updated to v0.5.17, which leaves the header out of the signature for googleapis.com endpoints, and the replica listing client used by openrun replication status and by app deploys (restores of replicated SQLite bindings) applies the same rule and the same S3-compatible checksum settings as Litestream. Added the sign_accept_encoding litestream config key (default true) for other S3-compatible services with the same problem; it is passed through to the app replication sidecar and restore URLs. truncate_page_n = 0 keeps disabling the blocking TRUNCATE checkpoint: Litestream 0.5.16+ treats 0 as its default threshold, so OpenRun now passes the disabling value (-1) to the embedded library and the sidecar config.container.config call without secrets, so an app declaring secrets=[...] on that permission deploys without approval but cannot resolve them until approved. app create, app reload and apply now print a warning (on stderr) when an app declares secret access that is neither approved nor allowed by the server config; param update and app update container_args warn when the new value references a secret the app cannot resolve, or when the update declares the access (the secrets param); and the container start error says which permission to declare and that openrun app approve <path> grants it. app approve (and --approve) reports the permissions it records as approved, including server-covered ones, instead of "No approval required". The audit result gains changed, approved, ungranted_secrets and main_app_path; the staged update responses gain warnings. The built-in container specs default their secrets param to empty, so a new app passing no secrets requests none; set --param secrets='[["name"]]' to declare the access. Existing apps are unaffected: the approval rules are unchanged.logs/access.log) entries now include request_id, user_id and app_id. The request id matches the audit events for the request, and the user and app ids are empty for unauthenticated and non-app requests (#106).c0126c0b2cdf26ce27e8ec87784e8d565c88605d: APIs for updating MCP config through console app (@akclace)
--server-uri <uri> (or the OPENRUN_SERVER_URI env variable): the server uri to connect to, a unix socket path or https://host[:port]. When set it takes precedence over server_uri in the config file, so one client config can be used against multiple servers (openrun --server-uri https://staging.example.com:25223 app list).Nothing published for this version
Nothing published for this version
Nothing published for this version
This release adds support for running Actions through CLI and MCP (in addition to the web UI interface). See https://openrun.dev/docs/actions/#mcp-too
This release adds support for running Actions through CLI and MCP (in addition to the web UI interface). See https://openrun.dev/docs/actions/#mcp-tools Support is added for running Actions asynchronously. Async actions run without being tied to the client session, run history is maintained for async actions https://openrun.dev/docs/actions/#async-actions
This release adds support for running Actions through CLI and MCP (in addition to the web UI interface). See https://openrun.dev/docs/actions/#mcp-tools
Support is added for running Actions asynchronously. Async actions run without being tied to the client session, run history is maintained for async actions https://openrun.dev/docs/actions/#async-actions
This release adds support for running Actions through CLI and MCP (in addition to the web UI interface). See https://openrun.dev/docs/actions/#mcp-tools Support is added for running Actions asynchronously. Async actions run without being tied to the client session, run history is maintained for async actions https://openrun.dev/docs/actions/#async-actions
gosaml2 to v0.12.0 and goxmldsig to v1.6.1 to reject unsigned logout responses, bound XML parsing complexity, and reject malformed encrypted assertions without panicking. Delayed logout responses no longer clear a newer login session.actions.star and action_params.star convention files: an app built from a spec (or any app) declares actions in actions.star (actions = [ace.action(...)], optionally permissions = [ace.permission(...)]) without copying the spec's app.star, and action_params.star declares the params the actions present. When action_params.star exists, only its params are shown on the action UI, REST API, CLI and MCP tool schema and passed in args; they are app params otherwise (--param, openrun param update, the param module, the container environment). A required action param no longer needs a value at create time.ace.action(..., is_async=True, timeout="2h") runs the handler in the background as the submitting user and records the run (its args, status, the first and last 10MB of a streamed command's output or up to 100MB of result values) in the metadata database, the last 100 runs per app instance. The action page gets a run card, a run page with live output and a runs list with cancel and run again; the REST API answers 202 with the run id and serves /api/runs; the CLI adds --wait and --follow to action run (both report the run id on stderr as soon as the run starts) and the action runs, action output and action cancel commands; the MCP tools of the app return the run id (or wait with wait_seconds) and gain get_run, list_runs and cancel_run; the management API and MCP surface gain list_action_runs, get_action_run, action_run_output and cancel_action_run. The limits and the timeout are [app_config] action.* settings, overridable per app. A run keeps executing on the app version it started with through a reload; a run whose node stops is marked lost.openrun action commands (list, show, run, validate, suggest, openapi) to list and run app actions from the CLI, locally or through a remote CLI. Args are passed as name=value (or --json, with name=@file for file uploads), results are written as a table, text or JSON (--format json|jsonl|csv), streamed commands write their output as produced and the CLI exits with the command's exit code (2 for param validation errors), and --output saves the files of download and image results (fetched as the calling user).ace.action: read_only, destructive, idempotent and open_world (each True/False, none by default). They become the tool annotations of the action's MCP tool, are shown by openrun action list (a Hints column) and openrun action show, and returned as hints by list_actions and get_action. An action declared destructive=True shows a Destructive badge on its page, and its MCP tool (and the management run_action tool for it) asks capable clients (protocol 2026-07-28 with elicitation) to confirm before running: the first call validates the arguments and returns the confirmation prompt, the retry with an accepted answer runs the action; [api.mcp] skip_destructive_confirm turns it off. Actions without hints are unchanged.--mcp=actions ("source": "actions" in the mcp document): the app's actions are served as MCP tools at <app>/mcp, beside the form UI. One tool per action with the params as the input schema, dry_run to validate, a <tool>_suggest tool for suggest handlers, results as structured content plus a markdown table for the model, param errors as correctable tool errors, streamed commands reported with their output and exit status, the files of image and download results returned inline. The tools listed are the ones the user's permits allow.list_actions, get_action, run_action, suggest_action and action_file operations to the management REST API and MCP surface. A credential limited by scopes needs app:access to use them.openrun app create --mcp (also --mcp=/upstream-path, --mcp='{...}', app update mcp, and mcp= in apply files) marks a deployed app as an MCP server whose endpoint OpenRun protects with OAuth 2.1. OpenRun serves the protected resource metadata, issues tokens bound to the app after a login and consent using the app's auth, enforces RBAC app:access and optional app-declared scopes with per-tool requirements, strips the token and forwards the identity headers (plus X-Openrun-Scopes / X-Openrun-Client-Id). API keys can be bound to an app with openrun apikey create --resource app:<path>. MCP apps get a JSON-RPC health probe (TCP probes on Kubernetes) and stage/preview apps accept MCP POSTs.api.cimd_allowed_domains, api.cimd_denied_domains and api.cimd_allow_private_hosts; dynamic client registration remains as the fallback. Pending authorization codes are stored in the metadata database so multi-node deployments work.openrun login flow is now styled like the server's login page (stylesheets and fonts loaded from the server just signed in to) and names the server.client.skip_cert_check. A remote call rejected with 401 reports why instead of a bare Unauthorized: no credential found for the server (with the openrun login --server <url> and OPENRUN_API_KEY ways to provide one), or the credential sent was rejected (expired or revoked login or api key). Other error responses report the server's message as before.Release v0.20.0 - Async Actions and auto MCP
Compare
Nothing published for this version
Nothing published for this version
Changelog Setup for 0.20 release
Setup for 0.20 release
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
6095063 : Add app config doc ( @akclace )
https.acme_ca_url sets the CA's ACME directory URL (enables certmagic even without service_email, for private CAs like step-ca), https.acme_ca_cert points to a root CA PEM to trust for the CA endpoint, and https.acme_eab_key_id/https.acme_eab_mac_key configure External Account Binding for CAs that require it (e.g. ZeroSSL).https.enable_http_challenge: answers ACME HTTP-01 challenges on the HTTP port (before the HTTPS redirect and auth), in addition to the always-on TLS-ALPN challenge. Works with Let's Encrypt and custom ACME CAs; the HTTP listener must be reachable by the CA, on port 80 for public CAs.Nothing published for this version
3a60269 : Fix lint failures and update reverse proxy since proxy.Director is deprecated ( @akclace )
localhost), on docker/podman peer containers on a per app network.app delete now removes the app's runtime assets: its containers and sidecars, generated images, named volumes and per app network on docker/podman, and its workloads, service and volume claims on Kubernetes. Foreign sidecar images and remote registry images are not removed.--prune to sync schedule: each sync run deletes the apps and bindings the sync itself created that are no longer present in the apply file. Resources created imperatively and later adopted by the sync are never pruned. Pruning runs in the same transaction as the apply, so a blocked delete fails and rolls back the run.openrun delete <filePath> [<appPathGlob>] command, the counterpart of apply for removal: the apps and bindings declared in the file that match the glob are deleted (declared resources that do not exist are skipped and reported). All deletes run in one transaction; a blocked delete rolls the whole command back.provider:read and provider:manage checks to the RBAC permission catalog. provider:manage now implies provider:read, and the built-in operator/monitor roles include the corresponding provider permission.067d999 : Pin SDK modules to v0.19.1 for release ( @akclace )
9606f9d : Add health check api for service bindings ( @akclace )
static_root_cache_control app config property: sets the Cache-Control header value for files served from an app's static_root directory (favicons and other stable-named root files). Default is empty, no header. The built-in list_apps app sets public, max-age=3600.Nothing published for this version
2b47842 : Add usage checks for service and binding deletes ( @akclace )
db49bd8 : Added export and diff apis ( @akclace )
e76ce1c : Add support for setting app config in app definition ( @akclace )
openrun_admin.secret_reveal: returns the clear text value of a secret reference (typically an app param holding {{secret_from ...}}), so an HTML app can pass an API key into a served page explicitly while the value lives only in the secret store, never in the app source or git history.static_from_disk app config property instead of being hardcoded to the static_disk spec name.ace.app settings dict now supports an app_config section which sets app config properties from app.star, e.g. settings={"app_config": {"fs": {"retain_versions": 3}}}.redis/valkey service binding is now compiled into the server as a built-in binding type; it no longer needs openrun provider install redis. Each base binding gets a dedicated ACL user restricted to a unique key prefix (and matching pub/sub channel prefix); derived bindings share the base prefix with grant-controlled patterns. Requires Redis 7+ or Valkey, standalone mode.openrun server stop --wait: waits for the server process to fully exit instead of returning as soon as shutdown starts (the final litestream sync runs as the process exits, so scripts that move or restore data directories after a stop need this). Over the unix domain socket the server's pid (now returned by the stop API) is polled; over http(s) the listener port is polled as a best effort signal. Also added openrun server status (prints ok when the server connection works) and openrun server version (reports the server's build version and commit).openrun CLI now discovers a machine scoped Windows service install: when OPENRUN_HOME is not set and no config is found relative to the executable (a winget binary is a links shim, so executable-relative discovery finds nothing), it checks %ProgramData%\openrun\openrun.toml and connects to the server's unix domain socket under that home, like /var/lib/openrun on Linux. Previously the CLI fell back to $HOME\openrun and failed to find the service's socket unless OPENRUN_HOME was set machine-wide.Nothing published for this version
ddc5a3f39fe6db2e92fa3fcc70189578ab2f4f6a: Fix race in dev mode router setup (@akclace)
Nothing published for this version
Nothing published for this version
a6dbdae915c8b1c42ada078a991419d6d3729d66: Add console app in docs (@akclace)
sqlite service binding type: an app bound to a sqlite service gets a persistent volume (Docker/Podman named volume or Kubernetes PVC, ReadWriteOnce with single replica and Recreate strategy) holding its SQLite database files, surfaced through the SQLITE_URL/SQLITE_DB_PATH/SQLITE_DIR env variables. The mount directory defaults to /data and is configurable per binding with the path binding config key. An app can have one sqlite binding and a binding can be attached to one app (single-writer database); derived bindings and grants are not supported.[litestream.<name>] server config entries. metadata.litestream_config replicates the server's own metadata and audit databases (embedded Litestream, restore-on-startup rebuilds a lost node from the replica); a sqlite service's litestream_config config replicates its apps' databases via a per-app replication container (Docker/Podman) or restore init containers plus a native sidecar in the app pod (Kubernetes 1.29+). Every *.db file in the binding directory is replicated, missing databases are restored from the replica before the app starts, and prod/staged environments replicate to separate locations (a linked staging service can use its own litestream config).--bind source reference, e.g. --bind "sqlite;path=/mydata"; the comma separated params become the auto binding's config, for any service type. Slice CLI flag values are no longer split on commas (pass multiple values by repeating the flag).openrun server restart (or SIGHUP, or POST /_openrun/restart) re-execs the server binary and hands the HTTP/HTTPS/unix-socket listeners to the new process.fef6b52d9dd1d629d133e3ae0f4e2e7619421984: Fix test case (@akclace)
Nothing published for this version
01efb72f06b74e930dc868fb80d6766eba92184c: Fix #100: Add sqlite WAL cleanup and move git fetch out of the transaction (@akclace)
5408fa01aa97e38dbb672f4972105b2daa0f446a: Fix goreleaser dir (@akclace)
Nothing published for this version
Nothing published for this version
f49a3fa7d81414361418867c48c25b6a875311c3: Fix binding image fetch and add test (@akclace)
c65edc933c503894e1b20bf815fda4ce7ae8c76d: Add OCI based deployment support for binding providers (@akclace)
openrun provider install/uninstall/list commands (/_openrun/provider APIs, gated by the new provider:read / provider:manage RBAC permissions); the install is recorded in the metadata database with pinned sha256 checksums, so it survives restarts and propagates to all server replicas — each replica materializes the verified binaries into the bindings.cache_dir local cache at startup, before serving traffic, making installs work on Kubernetes multi-replica deployments.FROM scratch image (ghcr.io/openrundev/openrun-binding-<name>), and the Helm chart's bindings.images values render one init container per provider which copies the binary (via the provider binary's new export subcommand) into a shared volume. The server registers pre-placed provider executables from the new bindings.preinstalled_dir config at startup, with no downloads and no database registration — integrity comes from the image digests, and the sha256 computed at discovery is verified on every provider launch. The new bindings.disable_install config (chart value bindings.disableInstall) rejects the imperative openrun provider install/uninstall API/CLI, for deployments where providers are managed only declaratively.builtin app auth type: username/password authentication (HTTP Basic) against [builtin_auth.<username>] config entries, each with a bcrypt password hash and a groups list used for RBAC group: matching (user id is builtin:<username> in grants). Users can be defined statically in openrun.toml or managed dynamically with the new openrun user add/update/delete/list commands (/_openrun/user APIs), which take effect immediately without a server restart and shadow static entries of the same name. Useful for small deployments and for testing RBAC policies with multiple users and groups without setting up OAuth/SAML.--as <provider>:<username> (e.g. openrun --as builtin:user1 app list): the management API call runs as the given user with RBAC enforcement (permission checks, list filtering, the owner rule, audit attribution) instead of as the trusted administrator. Supported over the unix domain socket only and requires RBAC to be enabled; for builtin: users the entry must exist and its groups feed group: grant matching, other provider ids (e.g. github:user) are taken literally with no groups so grants for SSO identities can be tested without creating them. Useful for testing RBAC policies from the CLI without going through an app.stop_server management API now enforces the server:stop RBAC permission (reachable only through --as; the trusted admin CLI is unaffected).targets accept service:<glob> entries matched against service ids (<type>/<name>, e.g. service:postgres/*) and binding:<glob> entries matched against binding paths (e.g. binding:/apps/team1/**); all matches every app, service and binding. New permissions: service:bind (provision binding accounts on a service, required to create base/auto bindings from it), binding:use (attach a binding to an app or derive a new binding from it), binding:reveal (read back binding account credentials with binding show-account; like secret:reveal it always needs an explicit grant — it is never implied by binding:manage and binding owners do not hold it by default, opt owners in via owner_permissions.binding), and the service:manage / binding:manage composites. Attaching bindings at app create/update/apply time now enforces binding:use / service:bind for newly added bindings, sync background runs enforce them against the frozen creator snapshot, and service/binding list operations (including export) return only the entries the user can read. The creator of a service or binding holds the owner permissions on it (default service:manage / binding:manage, configurable via owner_permissions).service:* and binding:* permissions are no longer global. A grant that should confer them must include service:/binding: target entries (or use the all target); grants whose targets only name app paths no longer confer any service or binding permissions. Sync entries created before this change froze grants without typed targets — recreate RBAC-snapshotted syncs whose apply files manage bindings.--bind-perm flag, openrun app update bind-perm, the bind_perm apply file argument, the permissions.binding_source_perms server config and the runtime container-start source check are gone, and approval no longer covers binding sources. Binding access authority is now checked when the binding is attached (RBAC binding:use/service:bind); with RBAC disabled, management operations are admin-only as usual.app_versions row was attributed to admin regardless of the caller, so version listings misattributed changes made by RBAC/SSO/builtin users. Trusted CLI/UDS calls (no user identity) keep the admin attribution.regex: user patterns (in grant.users and group members) now must match the entire user ID instead of any substring. Patterns already anchored with ^...$ behave the same as before.Nothing published for this version
32eef0acced58216c3a23fed8cc205c06e883d20: Add agenting builder using ACP integration (@akclace)
db secret provider encrypts values with AES-256-GCM and saves them in the metadata database. The master key is auto generated into $OPENRUN_HOME/config/secret.key or can be a {{secret_from ...}} reference resolved through another provider (for Kubernetes, mount it from a native Secret). Secrets are managed with the openrun secret create/list/show/delete/rekey commands, the /_openrun/secret management APIs and the openrun_admin plugin (create_secret, get_secret, list_secrets, delete_secret, rekey_secrets); create generates a unique name from a prefix and prints the {{secret_from "db" "<name>"}} reference to use. New secret:create, secret:read, secret:delete and secret:reveal RBAC permissions gate the APIs.{{secret ...}} reference.git_auth setting private_key for providing the SSH private key contents inline (supports {{secret ...}} references), as an alternative to key_file_path.container.separate_stage_prod_images for specs that need distinct staging and production container images.full template (and template names passed to ace.response) can now name a {{define}} block from the base templates instead of a template file, so fragment-only endpoints need no dedicated template file.static_disk app spec for serving static files directly from a local source directory without storing the static file contents in the metadata database.container:read permission covers listing containers, getting container details, logs and Kubernetes stats/status; new container:manage permission covers starting and stopping managed containers (and implies container:read). These operations previously had no RBAC check.audit:read RBAC permission, which grants read access to the audit log across all apps. It gates the list_audit_events and list_operations plugin APIs, which previously had no RBAC check.delete_apps plugin API now rejects an empty path glob instead of matching every app: a caller omitting the path argument could previously delete all apps (the HTTP route already validated this, plugin calls did not).security.headers_level app config defaults to 2, which adds X-Content-Type-Options: nosniff, X-Frame-Options: SAMEORIGIN and Referrer-Policy: strict-origin-when-cross-origin when the app did not set its own value. Apps embedded in cross-origin iframes need security.headers_level = 0 (settable per app with openrun app update conf) or an app-provided X-Frame-Options/CSP header, which takes precedence. Levels 5 and 10 opt into stricter sets (HSTS, CSP).stage_enable_write_access / preview_enable_write_access) now treats every method other than GET, HEAD and OPTIONS as a write, so PATCH and custom verbs fail closed; denied requests now return 403 instead of 500.stage.example.com:/app, instead of suffixing _cl_stage to the production path. Use system.stage_at, system.default_stage_domain, openrun app create --stage-at, or declarative stage_at to choose path-based staging or a specific staging domain for new apps.settings={"container": {"separate_stage_prod_images": True}}.container.deploy_health_attempts budget, and the best-effort EndpointSlice convergence check now skips immediately when the Kubernetes API or RBAC policy does not allow listing EndpointSlices.clc-app_prd_<id>-e96c79f753cfafff instead of a 143-character name. Containers running under the old names are stopped by the stale-container sweeper after upgrade and the app is recreated under the new name on its next request; images built under old tags are not reused.Nothing published for this version
18119fbbe5e019a498affe6110fc3d6c23dda29b: Fix channel cleanup related (@akclace)
dc2099566928b18d3c0274777504a243f69d16d2: Add RBAC checks for API calls (@akclace)
910b57f1459f16231b1a9a4b3b3d9e5517742a8a: Add docs for static_disk spec (@akclace)
1fb1c450c673258c71e42cb3f2b5242de494a9d5: Add metadata for storing stage app path (@akclace)
/_openrun_app/verify_file/{file_name} API to verify that an app-relative source file exists and return its size.ae701cde862caffba8bb17d0fec654b52ab5cd22: Add images to blog post (@akclace)
Nothing published for this version
One column per month.