mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-18 14:08:21 +00:00
16 commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
080e5f500c
|
🏘️ fix: Resolve Tenant Profiles in Their Own Partition and Keep Role Operations in the Caller's (#17417)
Some checks failed
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Vote Gate / Gate (push) Waiting to run
Codegraph E2E Votes / vote (shard 1/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 10/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 2/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 3/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 4/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 5/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 6/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 7/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 8/10) (push) Waiting to run
Codegraph E2E Votes / vote (shard 9/10) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Client build recovery regression (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/chat (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Has been cancelled
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Has been cancelled
- GET /resolved resolves a group or user profile in the partition its document belongs to, as
writes judge it: for an admin without a tenant reading a tenant's profile, that tenant's
librechat.yaml and __base__. GET /catalog resolves such a scope there too, instead of
answering 404, and GET /effective finds a user by id the way profiles are addressed and
resolves them in their own tenant: their role, groups and documents there.
- findPartitionUser becomes findPrincipalUser, which also returns the user's tenant.
- Admin role operations address the role of the caller's tenant partition: the role lookup
(getPartitionRole), listing, creation's name check, the members a rename migrates or a deletion
reassigns, the members listed and counted, and the ACL entries (deletePrincipalAclEntries) and
grants a deletion removes. A member added or removed by id must be a user of that partition.
- getRoleByName, which every request's permission checks read, reads the role of the caller's
partition too: outside a tenant and under the system context the platform-level one, never an
older tenant role of the same name. updateRoleByName without an id and updateAccessPermissions
for a role read without its _id write that role, so the legacy permission route changes the
platform role. The grants route checks a role exists with getPartitionRole.
- runInPartition moves a read into another partition only from outside a tenant, and rejects
leaving an active one.
- deleteGrantsForPrincipal and findGrantsForPrincipal without a tenantId reach only
platform-level grants, as moveGrantsToPrincipal does.
- updateRoleByName takes { id } to change one role document; renames, their rollback,
description updates and updateAccessPermissions write the document they read.
- The exported keyed rename helpers (applyConfigChange rename, renameConfigEntryTombstones)
refuse a new name no keyed path can address, as the admin routes do.
|
||
|
|
9f617fc4ad
|
🧬 feat: Re-Derive Azure Groups, Vertex AI, Custom Parameters and Spec Defaults for Config Profiles (#17399)
* 🧬 feat: Re-Derive Azure Groups, Vertex AI, Custom Parameters and Spec Defaults for Config Profiles AppService derives part of the served config from librechat.yaml at startup, and config profiles merged into that output without deriving it again. Azure `groups` now merge by `group` like `endpoints.custom` by `name`: a profile's partial group merges over the group of that name, groups it does not name stay, indexed writes are refused, change batches take entry ops on them, and groups that do not resolve over librechat.yaml and Base (or whose written `${VAR}` is not set) answer `invalid_azure_groups`. Each merged group keeps the key below it unless the profile supplies one, so the rebinding guard drops a key a partial item moves and a key a lower layer dropped stays dropped; Azure re-entry compares groups merged the same way. With `CONFIG_REDERIVE_ENDPOINTS=true` (opt-in for this release), a profile's Azure `groups` resolve into what the Azure clients read (unconditional before, now behind the switch so stored group overrides do not go live on upgrade), a profile's `endpoints.anthropic.vertex` derives `vertexConfig` and the Anthropic models it serves where librechat.yaml configures Vertex AI, and the Azure Assistants endpoint follows a profile's `assistants`. Startup logs the documents that hold such overrides, the groups that would not resolve over librechat.yaml and Base, and the Vertex AI overrides that never apply. Always on: Vertex AI's key file and region are base-only, a profile may turn Vertex AI on only where librechat.yaml configures it, its settings may reference only librechat.yaml's own Vertex AI variables (reads return them resolved), a profile's `vertexConfig` is never applied and writes skip it (`derived_path`, `rules.derivedPaths`), a model's own `deploymentName` resolves its `${VAR}` like the default one, the region, project ID and the deployment name each model's requests send (the model name where the client sends it as written) must stay in their URL host label or path segment, a `${VAR}` there is a whole `${NAME}` reference only, the Anthropic client refuses any other deployment name before building a request, and an invalid setup answers `invalid_vertex_config`. The rebinding guard no longer binds the derived Vertex AI region, which is librechat.yaml's. Custom endpoint `customParams` are expanded by `expandCustomEndpoint` into the served copy, so `appConfig.config` stays librechat.yaml as written, and each endpoint a profile writes is expanded again from its merged form (a changed `defaultParamsEndpoint`, OpenRouter defaults for a profile's own endpoint); invalid definitions answer `invalid_param_definitions`. After tenant scoping, `getAppConfig` derives `modelSelect`, `parameters` and `presets` again for the specs a principal is served where nothing sets them, the agents `memory` capability follows the merged memory config, and a model spec naming an unconfigured endpoint answers `unknown_spec_endpoint`. Meta flags: `azureGroupMergeKey`, `customParamsExpansion`, `specInterfaceRederive` and `endpointRederive`. * 🪜 fix: Judge Re-Derived Config on What Every Profile Layer Leaves Two re-derivations decided whether a profile had set a field from whether any layer ever set it, so a lower profile's value tombstoned by a higher one still counted as set. - Vertex AI (CONFIG_REDERIVE_ENDPOINTS=true): the marker that keeps a profile's `endpoints.anthropic.models` over Vertex AI's is cleared by a later tombstone of those models (or of `endpoints.anthropic` or `endpoints`), and such a tombstone derives Vertex AI again, so the Anthropic endpoint serves Vertex AI's models instead of none. A tombstone of librechat.yaml's own models does the same. - Spec-dependent controls: `modelSelect`, `parameters` and `presets` are derived again where their served value differs from the base config's, not only where the librechat.yaml-shaped value does, so a control one profile sets and a higher one tombstones, or a tombstone of one librechat.yaml leaves unset, follows the specs served instead of being dropped. The memory capability, Azure Assistants, Azure groups and custom parameters already derive from the merged result; tests now cover each set in one layer and tombstoned in a higher one, and the reverse. * 🧮 fix: Derive Each Config Part From What the Layers Leave A tombstone of an object above a derived part's inputs, alone or followed by a layer that recreates part of that object, left the part without what startup derives it to: - An Azure endpoint recreated after a tombstone of `endpoints.azureOpenAI` or `endpoints` had no groupMap, modelGroupMap or model lists, so its model lists fell back to the environment's default Azure models, which requests could not map to a group. It now serves no group, with or without CONFIG_REDERIVE_ENDPOINTS (completeAzureResolution). - A tombstone of the whole `interface` left modelSelect, parameters and presets out, which the client reads as off. They are derived from the specs served into a new interface. - A tombstone of `endpoints.agents` or `endpoints` left no agents endpoint, while a tombstone of its capabilities served the defaults. The agents endpoint startup derives is served there. - A tombstone of a Vertex AI setting that leaves the setup unable to load kept the vertexConfig derived below it. Vertex AI is off there, with a warning. A table in service.spec.ts runs every derived part against every way a layer changes its inputs (set, unset, a tombstone of the path and of each object above it, a layer recreating after such a tombstone, Base on either side, tenant scoping, the switch off) through getAppConfig, and compares each cell with what startup derives from the librechat.yaml the layers leave. * 🧭 fix: Serve Only Model Specs Whose Endpoint the Layers Leave A tombstone of `endpoints.custom` or `endpoints` in a higher profile (or the Base profile) left the model specs of the custom endpoints it removes served, librechat.yaml's or a lower profile's: the spec list pointed at endpoints /api/endpoints no longer offers, with the model selector, parameters and presets still off for them. The write check only ran when the write held `modelSpecs.list`, and the merge served stored specs as they were. After the last layer, the merge now serves only the specs whose endpoint is a built-in endpoint or a custom endpoint the YAML-shaped config the layers leave defines, the rule startup skips librechat.yaml's specs by (deriveServedSpecs). A removed endpoint hides its specs until a layer defines it again; where no spec is left, none is served (as with a tenant-hidden endpoint) and the spec-dependent controls come back on. Tombstones of a built-in endpoint's settings keep its specs, as startup does, and `addedEndpoints` stays as merged. A stored spec for an endpoint that is not configured is left out on its own instead of being served; writes of one still answer 400 unknown_spec_endpoint. The derived-part table in service.spec.ts gains the model specs served (with addedEndpoints and the controls they decide) against tombstones of `endpoints.custom`, `endpoints`, and each of `endpoints.openAI`, `azureOpenAI` and `anthropic`: by a profile, by Base under a profile, a lower profile under a higher one, recreated above or by the same layer, with no spec left, and with the switch off. * 🧩 fix: Reconcile Re-Derived Config With Dev's Keyed Tombstones, Write Report and Read APIs - Keyed tombstones of Azure groups (endpoints.azureOpenAI.groups["g"], now merged by key) resolve the groups left again where the merge resolves them, and stay inert without CONFIG_REDERIVE_ENDPOINTS. - Keyed tombstones count as touching endpoints.custom, so served specs and custom parameters are derived again after one. - The served-spec derivation keeps modelSpecs while added endpoints remain, as the hidden endpoint scoping does; hidden endpoint names leave addedEndpoints. - Derived paths join the held paths every write skips, built on first use. - Tests follow the merged behaviour: Azure groups merge by group, the agents endpoint is derived again below a tombstone. |
||
|
|
babf6f908b
|
🧾 feat: Admin Config Write Report, Structured Issues and Deployment-Only Paths (#17395)
* 🧾 feat: Admin Config Write Report, Structured Issues and Deployment-Only Paths Admin config writes dropped what the API never stores (base-only sections, interface permissions, dedicated sections) with a 200 and no word of it, stored values nothing reads (boot-time and operator-only settings, overrides of MCP servers librechat.yaml runs as local processes, tombstones inside arrays), answered most 4xx without a stable code, returned validation issues without the bound or option that failed, and refused every admin write once the terms-acceptance modal was on for an admin who had not accepted it, including the write that turns it off. PUT, PATCH /fields, POST /fields/tombstone and DELETE /fields now answer with `applied` and `skipped` (with a reason per location); a whole `interface` PATCH keeps its UI fields; base-only paths are skipped on every route. A new DEPLOYMENT_ONLY_CONFIG_PATHS list (rate limits, CloudFront, permission leases, OpenAPI, skill deletion, the tool filters, the agents and MCP boot settings, `cache`) is skipped on write, kept at librechat.yaml's value by the merge and published in GET /meta. Writes and tombstones inside a librechat.yaml stdio MCP server answer 400 PROCESS_MCP_SERVER_OVERRIDE, and a whole-section value leaves those servers out. GET of a document lists what the merge leaves out of it (`ignored`, `ignoredBasis`). Validation issues carry allowlisted `params`; each refused allowedAddresses entry is one issue with a `reason`; agent recursion limits must be whole numbers of at least 1, and the runtime ignores any other value. The config handlers' 4xx carry a `code`, the capability middleware adds AUTH_REQUIRED/FORBIDDEN, and the admin config router opts out of the terms gate. PATCH checks a section manager on every section it names, skipped entries included, as /changes does. New meta flags: writeReport, issueParams, adminTermsExempt. * 🧪 test: Expect Issue Params in the Whole-Document Override Validation Scenario Validation issues now carry `params` (here the expected and received types), so the scenario that asserts the exact issue list for a rejected PUT expects them too. * 🧪 test: Cover Merged Read Codes, Tenant-Scoped Read Reports and Deployment-Only Resolution |
||
|
|
f05f50460a
|
🔭 feat: Admin Config Read APIs (Resolved and Effective Config, Scope Catalog, Env Status) (#17383)
* 🔭 feat: Admin Config Read APIs (Resolved and Effective Config, Scope Catalog, Env Status) Admin clients could read one config document at a time, or the deployment's merged config, but nothing showed what a profile or a user resolves to: a client had to re-implement the merge (Base-first precedence, merge keys, tombstones, the interface permission filter, base-only fields, runtime stops, secret rebinding, the env allowlist) to preview it, and had no way to see why part of a profile is ignored. Endpoint, model and tool pickers came from the end-user routes, called as the signed-in admin, so they showed the admin's own scope and keys and needed a browser User-Agent. The admin config API now has four read routes. GET /resolved/:principalType/:principalId and GET /effective?userId= return librechat.yaml, the documents that merge over it in merge order, each with the parts the merge does not apply and why, and the result, in librechat.yaml shape. They come from resolveConfigLayers, which tracks the same fold the served merge runs and is pinned to it by parity tests, and from the stored documents rather than the override cache. GET /catalog lists the endpoints (with the reason one is not served), models (served, configured and defaults), MCP servers and tools a scope serves, resolved for the scope rather than the caller and never with a user's stored key; GET /env-status reports whether each env name the config uses is set, never its value. Every read is filtered to the sections the caller can read, redacted as reads redact, and scoped to the caller's tenant. The admin Langfuse routes now say why a deployment offers no connection settings. Meta reports resolvedApi, catalogApi, envStatus and limits.catalogModelsTtlMs. * 🪞 fix: Report Duplicate Custom Endpoints from the Served Definition When librechat.yaml defines a custom endpoint name twice, or both `Ollama` and `ollama`, the catalog kept the first definition for a name's env names, reason and models, while `loadCustomEndpointsConfig` serves the last servable one. An entry could pair the served config of one definition with the env names of another. `resolveServedCustomEndpoints` now holds the runtime rule (the last definition with a name, key, base URL and models wins under its served name), and `loadCustomEndpointsConfig`, `loadConfigModels` and the catalog all use it. A name with no servable definition is reported from its last one. * ⏱️ feat: Make the Admin Catalog Model-List Lifetime Configurable `GET /api/admin/config/catalog` reused a scope's model lists for a fixed two minutes. The new librechat.yaml field `endpoints.catalogModelsTtlMs` sets that lifetime (milliseconds, `0` to one hour, two minutes by default); `0` resolves the lists on every read. It is a base-only path, so a profile cannot change it and `GET /meta` reports one value, now read from the deployment's config on each request as `limits.catalogModelsTtlMs`. |
||
|
|
4d061fdd46
|
🔄 fix: Judge Tenant Profiles on Their Own Base, Clear Config Caches on Principal Deletion, and Add a Config Reload Route (#17397)
Profile writes are judged in the tenant partition the profile merges in. For a role, or a
caller inside a tenant, that is the caller's partition. For a group or user profile written by
an admin without a tenant, it is the stored document's tenant: PUT, PATCH and POST …/changes
validate on librechat.yaml as that tenant resolves it with that tenant's __base__ over it, use
the same Base for the recheck after commit and for key binding, tombstones and field deletes
judge re-entry on that tenant's librechat.yaml, and every route reports `ignored` over that
tenant's Base. Each attempt reads the document in that partition only, and a document that
moved partition while the write ran answers 409 CONFIG_VERSION_CONFLICT. The config store's
partition rules are unchanged; another tenant's Base is read in that tenant's context.
Deleting a group, role or user clears the config caches when it removes or restores the
principal's profile (`invalidatingConfigStore`), awaited before the response and broadcast with
Redis as config writes do; a call that rejects clears too, since it may have committed.
POST …/changes lets `unset` remove any part of a top-level section configSchema does not
define; the section's own `unknown_section` issue is no longer blamed on the removal, and every
other op there still answers 400 UNKNOWN_SECTION.
POST /api/admin/config/reload, for an admin without a tenant holding broad manage:configs (a
tenant admin gets 403, since the reload reaches every tenant), runs the config cache clear without
a write, loads librechat.yaml again on the answering instance, and once it loaded publishes the
clear over Redis so every other instance loads the file on its next read. It uses
ConfigCacheInvalidation.reload, which reports the clear, the load and the publish instead of only
logging a failure (writes keep `invalidate`, which leaves the load to the next read). It answers
200 `{ success: true, broadcast }`, `broadcast` false without Redis; 422 CONFIG_RELOAD_INVALID
with each schema issue's location when the loader refuses the file, keeping the last good config
and publishing nothing; 500 CONFIG_RELOAD_FAILED when a clear fails or the config cannot be built
from the file; and 503 CONFIG_RELOAD_BROADCAST_FAILED when this instance reloaded but the publish
failed, since an instance that misses the broadcast keeps its cached librechat.yaml, which never
expires. Every reload that runs is audited as `config.reloaded`, a failed one with outcome
`failure` and its code. The meta reports `features.reloadRoute`. Writes still reload the file.
The e2e content-filter helper uses the route instead of a sentinel profile.
docs/mcp-overrides.md describes the current timing: the awaited clear, the Redis broadcast, what
still waits for a TTL, that a process the clear misses keeps its old librechat.yaml, and hiding
as an access boundary at checkout.
|
||
|
|
db225c0919
|
🔐 feat: Admin Config Secrets v2 (MCP and Azure Credentials, Re-entry, Env Allowlist, Rebinding) (#17353)
* 🔐 feat: Admin Config Secrets v2 (MCP and Azure Credentials, Re-entry, Env Allowlist, Rebinding) The admin config API stored MCP server credentials and Azure group keys in plaintext, returned them to config readers, let an admin who cannot read a stored credential send it to a host of their choosing, and let override values reference any environment variable. MCP credentials and Azure keys, in `groups` and in the `groupMap` the Azure clients read, are now encrypted with masked previews, hidden from every read and decrypted once after the merge. A write that keeps a stored MCP credential or web search key while changing where it is sent must enter it again, judged by the value the written document holds. `${VAR}` references in overrides are limited to an allowlist, named where a change batch leaves them, and the merge drops a credential a layer moves to a new destination without entering it, listing it in write responses only for sections the caller can read. A custom endpoint's key is bound to its base URL, its provider and the destination options in addParams and dropParams (such as the anthropicApiUrl the native Anthropic client sends to), matched across layers under the name the merge folds (ollama is Ollama). A restated `${VAR}` counts as entered, so allowlisted names are not bound to a destination. Azure's `${INSTANCE_NAME}` and `${DEPLOYMENT_NAME}` stay templates in a group's `baseURL`, and a scheduled job's MCP consent no longer depends on the masked previews that change when an admin rotates the key in place. * ♻️ refactor: Move the MCP Key Re-entry Guard Out of the Binding Helpers to Break an Import Cycle With #17351's OpenID provisioning on dev, the app config service reached itself through the rebinding guard: app/service -> app/overrides -> app/rebinding -> mcp/registry/binding -> mcp/errors (and mcp/types) -> mcp/oauth/obo -> utils/identity -> auth/openid -> auth/provision -> app/resolve -> app/service. The binding helpers are pure diffs; only requireApiKeyReentryForRebinding needs the MCP error class, so it moves to mcp/registry/reentry.ts, and the helpers take MCPOptions from librechat-data-provider as mcp/headers.ts does. No behaviour changes. * 🧪 test: Drop a Base-Held Endpoint Key That a Lower-Priority Profile Moves Base merges first since #17352, so a profile below Base's priority still lands over it. The rebinding guard drops the key Base stores for a custom endpoint whose baseURL the profile changes, and the PATCH response lists it in `ignored`. * 🔐 fix: Serve Admin Azure Group Keys and Keep Deployment Keys at Their Own Destinations Azure groups a profile writes now take effect: the merge resolves a layer's `endpoints.azureOpenAI.groups` as AppService resolves librechat.yaml's (`resolveAzureGroups`, shared with `azureConfigSetup`) into the `groupMap`, `modelGroupMap`, model list and assistant models the Azure clients read. A layer's groups replace the groups below whole, as its array does; groups that do not resolve stay unread with a warning. The rebinding guard judges the resolved groups like any `groupMap` entry, and an Azure group's destination now also covers a deployment name its base URL takes its host from and the destination options of its `addParams`/`dropParams`. A write that keeps a stored Azure group key (in `groups` or `groupMap`) while changing where the group sends it answers 400 `CONFIG_SECRET_REENTRY_REQUIRED` on PUT, PATCH, field deletes, tombstones and change batches, judged as the document resolves over librechat.yaml and on each `groups` item as written. OCR fills an empty key from `OCR_API_KEY` only for its default destination (no base URL, or `${OCR_BASEURL}`), so a key the guard dropped for an override's `${VAR}` base URL is not replaced by the deployment's. The env reference policy includes the `${OCR_API_KEY}` loading fills in for an `ocr` section without a key, so a client can write back what GET `/base` returned. The custom endpoint guard no longer needs the layer's overrides to name an entry: an entry changed some other way is judged as inherited (positional tombstones inside the list are not applied by the merge, so none reached one). A web search URL a layer points at a `${VAR}` other than librechat.yaml's without entering its key is set back: web search sends the deployment's key, or its client's environment default, to any `${VAR}` URL. * 🔐 fix: Keep Azure Assistants Served, Opaque Keys as Entered and Batch Env Checks on the End State Azure assistants: a profile's `groups` replace the groups below whole, so groups with no model that supports assistants under librechat.yaml's `assistants: true` left `assistants` on with an empty `assistantModels`, and the Azure Assistants initializer picked `assistantModels[0]` (undefined). `azureConfigSetup` refuses that combination at startup; the merge now turns `assistants` off when none of the models it leaves supports them, with a warning, judged on the merged result so a later layer whose groups serve assistants keeps them on. The check is `lacksAzureAssistantModels`, shared with `azureConfigSetup`. Opaque credentials: every runtime reader of the OCR, speech, web search and Langfuse keys uses the decrypted value as is (`resolveConfigSecret`, `resolveStoredConfigSecret`, `decryptConfigSecret`), so a `${...}` inside a key the write encrypts is part of the key. Those fields are marked `opaque`: the write-time check skips a value the write encrypts there, and the runtime pass keeps their ciphertext instead of blanking it. A whole `${VAR}` reference there, which the field passes through and its reader resolves, is still checked, and so is stored plaintext. Custom endpoint (`initializeCustom`), Azure group (`mapModelToAzureConfig`) and MCP (`processMCPEnv`) credentials are expanded by their clients once decrypted and stay checked; the Assistants keys have no reader yet and stay checked too. Change batches: env references are judged on the document the batch leaves, as its other issues are. An issue counts only when the end state still holds a disallowed reference (ciphertext by its plaintext) where the batch sent one, at a location the batch changed, so a value a later op removes or replaces (`set ocr.baseURL`, then `unset ocr`) is no longer refused, and a stored reference the batch puts back where it was is left to merge time. * 🔐 fix: Proxy-Bound OAuth Secrets, Consistent Azure Group State, Batch Issues by Entry Key and Loaded Web Search References - The MCP proxy is part of the OAuth client secret's binding (user tier, admin re-entry and the merge's rebinding guard share `getChangedOAuthSecretBindingFields`): the access token the secret obtains travels through it. - A tombstone of `endpoints.azureOpenAI.groups` resolves the groups to none in the merge (empty `groupMap`, `modelGroupMap` and model lists, so the model list does not fall back to the environment's defaults), and removes what they resolve to in `applyConfigTombstones`. - The merged Azure model lists name only models a merged group serves (`narrowAzureServedModels`), so an override's `assistantModels` no group serves no longer keeps Azure assistants on. - `/changes` env issues are held by entry identity (`toConfigIdentityPath`), followed through renames and resolved on the batch's end state, so a removal or rename no longer shifts them. - References loading librechat.yaml introduces (OCR's `${OCR_API_KEY}`, the web search defaults) are allowed at the location they are loaded at, so GET /base's sections are accepted written back, and nowhere else. * 🔐 fix: Re-entry for Endpoint, OCR and Speech Keys, Own Keys Bound Over Base and User Key Destinations Kept - The document that stores a custom endpoint, OCR or speech key can no longer move its destination without the key: PUT, PATCH, field deletes, tombstones and change batches answer CONFIG_SECRET_REENTRY_REQUIRED at the changed field (getBoundKeyReentryIssues), judged by value as the document alone sends it. - A profile's own key for an endpoint, MCP server, OCR or speech service, or Azure groupMap group that Base defines is bound to that destination when it is entered: the rebinding guard reports a fingerprint of where it goes, the write stores it beside the key (<secret>Binding), and the guard keeps the key there until a lower layer moves it. Reads and the merged config leave the fingerprint out; kept keys carry it; client values are replaced. - An inherited custom endpoint or MCP server that sends a credential each user holds (user_provided, customUserVars, apiKey.source user, OpenID or Graph token placeholders) keeps its destination: a layer's move is set back and listed in ignored. |
||
|
|
76e3c6b134
|
🪜 fix: Base-First Config Precedence, Profile Lifecycle and Role Renames That Keep Their Profile (#17352)
* 🪜 fix: Base-First Config Precedence, Profile Lifecycle and Role Renames That Keep Their Profile Config documents merge in one total order (`compareConfigPrecedence`): Base (`role` / `__base__`) first whatever its priority, then ascending priority, then role < group < user, then document `_id`. The merge, `getApplicableConfigs` and `listAllConfigs` all use it, so a tie no longer goes to the newest document whatever its type, and Base no longer outranks a profile through its priority. A profile that writes fields of a librechat.yaml MCP server therefore undoes a Base hide of that server for its principals. A write that creates a document without a priority gives it its principal type's default (role 10, group 20, user 100, Base 0), and a write that omits the priority keeps the stored one, so a broad PUT no longer resets a profile to 10. Langfuse writes no longer pass a priority. Profile writes (PUT, PATCH `/fields`, POST `/changes`) validate on librechat.yaml with the active Base document resolved over it (`resolveRawConfig`, the fold the merge itself runs), so a role write that is valid where it lands is accepted and one the merge would strip is refused. Base still validates on librechat.yaml alone, an inactive Base is ignored, and `/changes` still judges what librechat.yaml itself defines on the raw YAML. `PATCH /api/admin/config/:principalType/:principalId/priority { priority, expectedRevision? }` sets only the priority, for broad `manage:configs`, keeping overrides, tombstones and `isActive`; it is audited as `operation: 'priority'`. A write that would create a principal's first document (PUT, PATCH `/fields`, POST `/fields/tombstone`, POST `/changes` including a dry run or a priority-only batch) answers 404 `PRINCIPAL_NOT_FOUND` unless the role (exact name), group or user (lowercase ObjectId) exists in the caller's tenant partition, or at platform level outside a tenant (`principalExists`). Each route checks inside its compare-and-swap write, against the document the write replaces; the tombstone route now plans its write like the others, so `AdminConfigDeps` no longer takes `tombstoneConfigField`. A PUT with `expectedRevision: 'absent'` creates the profile even when it carries no overrides. Renaming a role moves its config profile, system grants and ACL entries to the new name in the caller's tenant partition. The profile moves through the store contract (`movePrincipal`: a create-only copy, then removal at the copied revision). A profile already at the new name answers 409 `ROLE_CONFIG_CONFLICT`, and any failed step rolls back the users, the role document and every move (500 `ROLE_RENAME_FAILED`). Profiles, grants and ACL entries that renames made before this change left at an old name are neither moved nor removed, and a role created under that name still picks them up. The Base principal id is a reserved role name (400 `ROLE_NAME_RESERVED`), and a legacy role by that name never moves or deletes Base. The admin config meta reports `deterministicPrecedence`, `priorityRoute`, `principalCheck` and `roleRenameMovesProfile`. * 🧪 test: Give the E2E Reload Sentinel a Role of Its Own Admin config writes now answer 404 PRINCIPAL_NOT_FOUND for a principal that does not exist, so the content-filter helpers' reload sentinel (a made-up user id) could no longer write and every spec that reloads librechat.yaml failed. The sentinel is now a role the helper creates once (409 when it already exists) and deletes after its profile in cleanup; no user is a member, so its empty profile changes no one's config. * 🛟 fix: Keep a Moved Profile Whose Removal Cannot Be Confirmed, Validate on the Caller's Base and Restore Rolled-Back Descriptions - `movePrincipal` no longer treats a failed read-back of the source, after its removal failed, as the source still being there. It keeps the copy, which may be the only one left, and rethrows the removal's failure instead of deleting the copy. - Profile writes read the Base validation floor from the caller's tenant partition, so a caller without a tenant validates on the platform-level Base and never on a tenant's. - A role rename that rolls back gives a role stored without a description the schema default back, instead of a `$set` of `undefined` that kept the new description. * 🧭 fix: Scope Profile Priority Changes to the Caller's Tenant Partition `setConfigPriority`, behind PATCH `/api/admin/config/:principalType/:principalId/priority`, read and wrote through the unpartitioned config store. A platform-level admin without a tenant runs in the default non-strict context, where the tenant-isolation plugin adds no predicate, so the route could reorder a tenant's profile for the same principal, and answer with it, when no platform-level profile existed. It now runs on the partitioned operations that the role rename and the partitioned `findConfigByPrincipal` use. The read is limited to the caller's partition: that tenant's document, or without a tenant only a platform-level one (no tenant, `null` or `''`). The write is pinned to the `_id` of the document that read returned. A tenantless caller therefore gets 404 `CONFIG_NOT_FOUND` for a profile only a tenant holds. An `expectedRevision` naming such a profile gets a revision conflict and changes nothing. Tests: `config.spec.ts` (data-schemas) adds "setConfigPriority in the caller tenant partition". It covers the platform profile changing alone, a profile that only a tenant holds being neither changed nor returned, and only the active tenant's profile changing inside a tenant. The tenant helpers are now shared with the rename suite. `config.precedence.integration.spec.ts` adds the same check through the handler. With the old wiring, a tenantless PATCH of a profile only tenant-a holds answers 200 and moves tenant-a's profile to 40. With the fix it answers 404 and tenant-a keeps 10. * 🧷 fix: Roll Back Only What a Rename Changed and Validate Profile Writes on the Base They Land Over - Grant moves report what they changed (re-keyed grants, and superseded grants whose removal was confirmed); the undo re-keys only grants still at the new name and re-creates a superseded grant only while the new name still holds the grant that superseded it, so a grant revoked during a rename is never resurrected. - The Mongoose binding settles a create whose acknowledgement was lost by the `_id` it chose (found at version 1: committed, returned), as the store contract now requires; a profile move whose copy committed finishes instead of leaving an orphan copy. The memory engine and the conformance suite cover it, plus a copy that cannot be withdrawn being logged. - A rename rollback moves back only the profile it moved (by identity, edits included), puts back only members still on the new name, and reverts the description only while it is still the one the rename set. - PUT, PATCH /fields and POST /changes read Base beside the profile on every attempt and read it again once the write commits; a write that Base changed under is judged on that Base and withdrawn (only at the revision it wrote) when it fails there. - The priority route rereads a lost race's current revision in the caller's tenant partition. |
||
|
|
4e0d9145e0
|
⚛️ feat: Atomic Admin Config Changes Endpoint (set, unset, tombstone, entry upsert/remove/rename) (#17328)
* 🗄️ refactor: Portable Admin Config Store with Revisions, Key Encoding and Coherent Writes Admin config writes went straight to MongoDB with dotted-path `$set`, `$unset`, `$pull` and `$addToSet`, and nothing checked `configVersion`. That caused six problems. * ⚛️ feat: Atomic Admin Config Changes Endpoint (set, unset, tombstone, entry upsert/remove/rename) Admin clients can change a principal's config overrides only one kind of change at a time: - PATCH `/fields` for sets, at most 100 entries; - POST `/fields/tombstone` for one tombstone; - DELETE `/fields` for one reset. * 🔁 fix: Reload librechat.yaml on Admin Config Writes Base-only sections such as `filters` and `messageFilter` live only in librechat.yaml, and an admin config write was how a running server picked up an edit to them. The coherent-cache change limited admin-write invalidation to the override and MCP caches, so the YAML base was never re-read after startup: the content-filter e2e suite, which activates filters by editing the YAML and writing a reload sentinel, saw `filters: undefined` from GET /base and every activation timed out. Admin config writes clear the YAML base config again, alongside the override and MCP caches, and the clear is broadcast with the others, so every instance reloads its YAML. The reload keeps the last good config on failure and republishes the tools derived from it, so the global tool cache is left for it to overwrite rather than emptied first. * 🧭 fix: Cap Dotted Field Path Depth and Hold Revision Preconditions on No-Op Writes A dotted fieldPath was split without the 32-segment cap that segments already had, so a deep path reached the recursive path writer and failed with a 500. Both spellings now share MAX_CONFIG_PATH_DEPTH and answer 400 CONFIG_PATH_INVALID / too_deep on PATCH, tombstone and DELETE /fields. Writes reduced to nothing (protected interface permissions, base-only or dedicated sections) answered 200 without checking expectedRevision. They now compare it with the stored document and answer 409 CONFIG_VERSION_CONFLICT with currentRevision on a mismatch, as the write itself would. * 📡 fix: Retry the Config Invalidation Subscription When Redis Comes Back A SUBSCRIBE that failed at startup (Redis unreachable, the client's retries spent) was only logged, and ioredis resubscribes only to channels it has joined, so the instance missed every other instance's config invalidation until it restarted. The subscription is now sent again each time the subscriber becomes ready until one succeeds; after that the client's own resubscribe takes over, and closing stops the retries. * 🧷 fix: Tighten Config Change Batches Around Array Entries, Cancelled Changes and MCP Tombstones - A tombstone with an index segment below a field configSchema does not define (an unknown key, or what an intersection or any holds) is refused as inside_array: the merge removes inherited values from objects only, so it was stored and reported applied while the element stayed visible. - unset joins set and rename in the merged-by-key position check: unset endpoints.custom.0.headers answers 400 indexed_merge_key_write, since the position can name another endpoint by the time the batch applies. upsertEntry and removeEntry address entries by key. - A batch whose changes cancel out (set interface.customWelcome, then unset interface) writes nothing: no empty document, revision bump, audit entry or invalidation. Its changes are reported as unchanged. - A whole-section mcpServers tombstone reports each librechat.yaml stdio server it leaves in place as ignored (process_mcp_server). - removeEntry no longer attributes the whole collection to itself, and existing issues of merged-by-key entries are matched by key rather than index, so removing an entry beside a legacy-invalid one (or shifting it) is no longer refused for that entry's issue. * 🪪 fix: Keep a Requested Priority on New Principals and Report Ignored MCP Renames POST …/changes discarded a broad manager's priority for a principal without a document when no change altered it: the batch answered written: false instead of creating the priority-only document PUT creates. An explicit priority on an absent principal now counts as a change. A rename under an MCP server librechat.yaml runs as a process persisted an override the runtime merge drops, but was not reported in ignored. It now is, like set and tombstone. An unset there stays unreported: it asks for the YAML value, which is what runs. * 🔁 fix: Drop YAML Reloads and Merges Overtaken by a Config Write Admin config writes clear the YAML base config on every instance, so a write is how a running server picks up an edit to librechat.yaml. Two races could undo that: - A base reload that read the old YAML before a write's clear cached it after the clear, and the base has no TTL, so the old base was served until the next write. - A request that read the old base before the clear, and was still resolving principals, cached its merge under the new override generation for the override TTL. The config service now keeps a base-config generation that `clearAppConfigCache` bumps. A reload publishes the base, the tools and the last good config only if its generation is still current, a read after a clear never joins a reload started before it, and the newer reload starts once the stale one settles so the loader's process-wide side effects end with the newest YAML. Merges capture the generation, base included, before they read the base config. Tests: - service.spec: a clear during a reload (stale success, stale failure, a read waiting on the newer reload) and a merge built on the pre-clear base. - invalidation.redis.spec: a write on one instance makes another reload librechat.yaml. - admin-config-reload.spec (api): every admin config write route, through the real router, handlers, database and config service, reloads librechat.yaml; a request with nothing to write does not. - invalidateConfigCaches.spec no longer asserts an order the parallel clears do not have. * 🧪 test: Reload librechat.yaml After a Committed Change Batch and Not After an Unwritten One * 🧮 fix: Validate Change Batches on Their End State and Report Base-Only Fields a Tombstone Keeps A batch's validation scope was built from every intermediate write, located in the state each change produced. A change a later one undid (set `balance.startBalance`, then restore `balance`) still widened the scope, so an issue the stored document already had there rejected an unrelated change, and an entry a later change moved (upsert one entry, then remove one before it) pointed its written index at a neighbour with a legacy issue. The written paths are now located in the batch's end state and kept only where that state differs from the stored document, with entries of merged-by-key arrays compared by key. A tombstone above a base-only field (`endpoints.agents`, `endpoints.agents.pullRequests`) is stored and hides the rest of the subtree, while the runtime merge puts back the provider, host, OAuth app and shared cache slots librechat.yaml sets. The response now lists those fields in `ignored` with reason `base_only_path`, as it already does for the stdio MCP servers a whole-section tombstone leaves in place. * 🧬 fix: Encode Config Keys in Objects Built in Another Realm The key encoder treated an object as plain only when its prototype was this realm's Object.prototype, and returned any other object unchanged, keys and all. Under Jest, structuredClone (which the secret pipeline uses) returns objects from the host realm, so the items of an array the pipeline had cloned, such as Azure groups or custom endpoints, reached the engine with their dotted keys raw. Node in production has one realm, but the encoding must not depend on prototype identity: a skipped object stores its dotted keys raw without an error. A plain object is now one whose prototype is null or a root Object.prototype from any realm. The encoding spec covers an object built in a vm context. * 🧪 test: Check Dotted Record Keys Reach the Store's Whole-Document Write dev's admin config route test asserted the keys on patchConfigFields, which the handlers no longer call; it now asserts them on the draft writeConfigDocument receives. * 🚩 feat: Publish the expectedRevision, prunesEmptyParents and awaitedInvalidation Config Flags GET /api/admin/config/meta now reports the three write-coherence behaviours this branch implements, so an admin client can drop the workarounds each one replaces: - expectedRevision: responses carry `revision`; PUT, PATCH /fields, POST /fields/tombstone and PATCH /active take `expectedRevision` in the body and both DELETE routes in the query. A mismatch answers 409 CONFIG_VERSION_CONFLICT with currentRevision, a malformed value 400 INVALID_EXPECTED_REVISION; unpinned writes re-read and re-apply up to 3 times. - prunesEmptyParents: a field delete or tombstone removes the objects it empties, stopping at arrays; shells-only documents count as empty for assign-only lifecycle calls. - awaitedInvalidation: writes answer after the config caches are cleared (broadcast with Redis), GET /base bypasses the merged-config cache, and a merge read before a clear is never cached. meta.spec probes each one against the behaviour: a stale and a malformed precondition on a PATCH, the store operations' unset and tombstone on nested objects and an array element, and a held invalidation, the GET /base read options and a merge raced by a clear. * 🔀 fix: Keep Config Keys Raw Where the Engine Stores Them, So Older Servers Read Them During Upgrades Servers before the key encoding (v0.8.9-rc1 among them) read every override key literally. The Mongoose binding encoded every write, so during a rolling upgrade the first write from an upgraded server turned a stored `gpt-4.1` or Bedrock inference profile into `gpt-4%2E1` for every server not yet upgraded, and an older server's restore of a deleted group or role config dropped the `keyEncoding` marker its schema lacks, after which upgraded servers read the encoded keys literally. The binding now sends keys raw first and encodes them only when the engine refuses a raw field name (DocumentDB, Cosmos, FerretDB or MongoDB 4.4 for `$` names): the refused write changed nothing, so it runs again encoded under the same revision precondition, and that process encodes later writes holding such keys directly. MongoDB 4.4+ stores dotted names (5.0+ also `$` names inside a value), so there an older server reads exactly what it wrote. A document whose raw keys spell escape sequences while none holds a raw `.`, `$` or NUL is still written encoded, since a raw read would decode it. A raw write clears the marker. Reads decode a marked document (raw keys an older server added beside encoded ones, or wrote under a marker it left, carry no escape sequence and read as stored) and an unmarked one unless some key holds a raw `.`, `$` or NUL, which no encoded document does; that reads an encoded document whose marker an older server dropped. Encoding stays in the binding for every engine that needs it (decision #15); the residual cases are in documentdb-compat.md. * ⏱️ fix: Remove Config Cache Writes a Clear Overtook in Flight With an asynchronous APP_CONFIG store (Redis or a custom Keyv store), a clear can bump the generation and finish its delete after a reload or merge checked the generation but before its `set` landed. The older value then repopulated `_BASE_` until the next write, or a merged config for the full override TTL. The base reload, the last-good restoration and the merge cache now check the generation again once their write lands and delete what they wrote if a clear overtook it. A deleted entry only costs the next read a reload or a merge; a newer base load cannot be removed this way, since it starts only after the stale one settles. * 🔐 fix: Require the Stored Web Search Key Again When a Change Batch Moves Its URL #17323 refuses a PUT, PATCH, tombstone or field delete that changes or removes a web search URL beside a stored API key unless the key is entered again, so a stored key cannot be sent to a destination it was not entered for. POST /changes skipped that check: a batch could set, reset or tombstone `webSearch.searxngInstanceUrl` (or replace `webSearch` without the key, which keeps the stored key) and point the stored key at another host. A batch is now judged on the document it would store, like PATCH: a URL that ends up beside a stored key it did not travel with answers 400 CONFIG_SECRET_REENTRY_REQUIRED and writes nothing, dry runs included. Only keys the request sent count as entered again; a secret a set kept from the stored document does not. * 🚩 feat: Publish the changesBatch Flag and the maxChangeOps Limit in Config Meta GET /api/admin/config/meta now reports `features.changesBatch: true` and `limits.maxChangeOps` (1000, from MAX_CONFIG_CHANGE_OPS), so the admin panel can gate its one-request save on the endpoint and size its batches from the server. The meta.spec probe checks the behaviour itself: an oversized batch answers TOO_MANY_OPS, a batch with one invalid op writes nothing, and a valid set plus tombstone lands as one write. |
||
|
|
0b4dc238b3
|
🗄️ refactor: Portable Admin Config Store with Revisions, Key Encoding and Coherent Writes (#17326)
* 🗄️ refactor: Portable Admin Config Store with Revisions, Key Encoding and Coherent Writes Admin config writes went straight to MongoDB with dotted-path `$set`, `$unset`, `$pull` and `$addToSet`, and nothing checked `configVersion`. That caused six problems. * 🔁 fix: Reload librechat.yaml on Admin Config Writes Base-only sections such as `filters` and `messageFilter` live only in librechat.yaml, and an admin config write was how a running server picked up an edit to them. The coherent-cache change limited admin-write invalidation to the override and MCP caches, so the YAML base was never re-read after startup: the content-filter e2e suite, which activates filters by editing the YAML and writing a reload sentinel, saw `filters: undefined` from GET /base and every activation timed out. Admin config writes clear the YAML base config again, alongside the override and MCP caches, and the clear is broadcast with the others, so every instance reloads its YAML. The reload keeps the last good config on failure and republishes the tools derived from it, so the global tool cache is left for it to overwrite rather than emptied first. * 🧭 fix: Cap Dotted Field Path Depth and Hold Revision Preconditions on No-Op Writes A dotted fieldPath was split without the 32-segment cap that segments already had, so a deep path reached the recursive path writer and failed with a 500. Both spellings now share MAX_CONFIG_PATH_DEPTH and answer 400 CONFIG_PATH_INVALID / too_deep on PATCH, tombstone and DELETE /fields. Writes reduced to nothing (protected interface permissions, base-only or dedicated sections) answered 200 without checking expectedRevision. They now compare it with the stored document and answer 409 CONFIG_VERSION_CONFLICT with currentRevision on a mismatch, as the write itself would. * 📡 fix: Retry the Config Invalidation Subscription When Redis Comes Back A SUBSCRIBE that failed at startup (Redis unreachable, the client's retries spent) was only logged, and ioredis resubscribes only to channels it has joined, so the instance missed every other instance's config invalidation until it restarted. The subscription is now sent again each time the subscriber becomes ready until one succeeds; after that the client's own resubscribe takes over, and closing stops the retries. * 🔁 fix: Drop YAML Reloads and Merges Overtaken by a Config Write Admin config writes clear the YAML base config on every instance, so a write is how a running server picks up an edit to librechat.yaml. Two races could undo that: - A base reload that read the old YAML before a write's clear cached it after the clear, and the base has no TTL, so the old base was served until the next write. - A request that read the old base before the clear, and was still resolving principals, cached its merge under the new override generation for the override TTL. The config service now keeps a base-config generation that `clearAppConfigCache` bumps. A reload publishes the base, the tools and the last good config only if its generation is still current, a read after a clear never joins a reload started before it, and the newer reload starts once the stale one settles so the loader's process-wide side effects end with the newest YAML. Merges capture the generation, base included, before they read the base config. Tests: - service.spec: a clear during a reload (stale success, stale failure, a read waiting on the newer reload) and a merge built on the pre-clear base. - invalidation.redis.spec: a write on one instance makes another reload librechat.yaml. - admin-config-reload.spec (api): every admin config write route, through the real router, handlers, database and config service, reloads librechat.yaml; a request with nothing to write does not. - invalidateConfigCaches.spec no longer asserts an order the parallel clears do not have. * 🧬 fix: Encode Config Keys in Objects Built in Another Realm The key encoder treated an object as plain only when its prototype was this realm's Object.prototype, and returned any other object unchanged, keys and all. Under Jest, structuredClone (which the secret pipeline uses) returns objects from the host realm, so the items of an array the pipeline had cloned, such as Azure groups or custom endpoints, reached the engine with their dotted keys raw. Node in production has one realm, but the encoding must not depend on prototype identity: a skipped object stores its dotted keys raw without an error. A plain object is now one whose prototype is null or a root Object.prototype from any realm. The encoding spec covers an object built in a vm context. * 🧪 test: Check Dotted Record Keys Reach the Store's Whole-Document Write dev's admin config route test asserted the keys on patchConfigFields, which the handlers no longer call; it now asserts them on the draft writeConfigDocument receives. * 🚩 feat: Publish the expectedRevision, prunesEmptyParents and awaitedInvalidation Config Flags GET /api/admin/config/meta now reports the three write-coherence behaviours this branch implements, so an admin client can drop the workarounds each one replaces: - expectedRevision: responses carry `revision`; PUT, PATCH /fields, POST /fields/tombstone and PATCH /active take `expectedRevision` in the body and both DELETE routes in the query. A mismatch answers 409 CONFIG_VERSION_CONFLICT with currentRevision, a malformed value 400 INVALID_EXPECTED_REVISION; unpinned writes re-read and re-apply up to 3 times. - prunesEmptyParents: a field delete or tombstone removes the objects it empties, stopping at arrays; shells-only documents count as empty for assign-only lifecycle calls. - awaitedInvalidation: writes answer after the config caches are cleared (broadcast with Redis), GET /base bypasses the merged-config cache, and a merge read before a clear is never cached. meta.spec probes each one against the behaviour: a stale and a malformed precondition on a PATCH, the store operations' unset and tombstone on nested objects and an array element, and a held invalidation, the GET /base read options and a merge raced by a clear. * 🔀 fix: Keep Config Keys Raw Where the Engine Stores Them, So Older Servers Read Them During Upgrades Servers before the key encoding (v0.8.9-rc1 among them) read every override key literally. The Mongoose binding encoded every write, so during a rolling upgrade the first write from an upgraded server turned a stored `gpt-4.1` or Bedrock inference profile into `gpt-4%2E1` for every server not yet upgraded, and an older server's restore of a deleted group or role config dropped the `keyEncoding` marker its schema lacks, after which upgraded servers read the encoded keys literally. The binding now sends keys raw first and encodes them only when the engine refuses a raw field name (DocumentDB, Cosmos, FerretDB or MongoDB 4.4 for `$` names): the refused write changed nothing, so it runs again encoded under the same revision precondition, and that process encodes later writes holding such keys directly. MongoDB 4.4+ stores dotted names (5.0+ also `$` names inside a value), so there an older server reads exactly what it wrote. A document whose raw keys spell escape sequences while none holds a raw `.`, `$` or NUL is still written encoded, since a raw read would decode it. A raw write clears the marker. Reads decode a marked document (raw keys an older server added beside encoded ones, or wrote under a marker it left, carry no escape sequence and read as stored) and an unmarked one unless some key holds a raw `.`, `$` or NUL, which no encoded document does; that reads an encoded document whose marker an older server dropped. Encoding stays in the binding for every engine that needs it (decision #15); the residual cases are in documentdb-compat.md. * ⏱️ fix: Remove Config Cache Writes a Clear Overtook in Flight With an asynchronous APP_CONFIG store (Redis or a custom Keyv store), a clear can bump the generation and finish its delete after a reload or merge checked the generation but before its `set` landed. The older value then repopulated `_BASE_` until the next write, or a merged config for the full override TTL. The base reload, the last-good restoration and the merge cache now check the generation again once their write lands and delete what they wrote if a clear overtook it. A deleted entry only costs the next read a reload or a merge; a newer base load cannot be removed this way, since it starts only after the stale one settles. |
||
|
|
2591a15c10
|
🔑 feat: Keep Dotted Record Keys in Admin Config Writes and Publish the Config Contract (#17322)
* 🔑 feat: Keep Dotted Record Keys in Admin Config Writes and Publish the Config Contract Keep dotted record keys in admin config write bodies behind a path-scoped sanitizer, reject $-prefixed and prototype keys after auth, report dotted_key issues with segments, and publish GET /api/admin/config/meta (features, rules, limits, versions) so clients can gate on backend capabilities. * 🧪 test: Expect Issue Segments in the Config Override e2e Scenario Override validation issues now carry `segments`; assert the full issue shape. |
||
|
|
ccae5b988d
|
📜 feat: Audit Admin Role, Group, Config and IdP Role Mutations (#17052)
* feat: Extend the Audit Action Vocabulary to Admin, Sync and Credential Mutations * feat: Audit Admin Role, Group and Config Mutations Role deletion now removes the role's grants, ACL entries and config overrides before the role itself and returns ROLE_CLEANUP_FAILED instead of success when any of them fails, so a recreated role cannot inherit leftover privileges. * feat: Audit IdP and Startup Role Changes * fix: Keep the Startup Role Sync Running When Its Audit Verification Read Fails * test: Cover Admin Role Audit Trail End to End * fix: Audit a Remote Agent Role Sync Only After It Persists * fix: Restore Role Dependents When Role Deletion Fails Midway * fix: Restore Role Dependents Only When the Role Still Exists * style: Sort Role Admin Imports * fix: Keep the ACL Snapshot When Role Cleanup Fails Ambiguously * test: Read Role Audit Entries From the Audit Log Route * fix: Audit Only Real Membership Changes and Restore Deleted Role Config in Full * fix: Restore Deleted Role Grants in Full and Sanitize Audit Write Logging * fix: Audit and Report a Role Deletion Confirmed After a Lost Response * fix: Never Restore Dependents Onto a Recreated Role * fix: Snapshot Role Dependents Before Deleting and Detect Membership Changes Atomically * fix: Restore From the Data a Cascade Step Actually Removed * fix: Restore Only Config Overrides When a Role Delete Fails * fix: Log Only Safe Metadata When the Startup Audit Read Fails * fix: Audit Grants Removed by a Failed Role Delete * fix: Audit Removed Grants on Unverifiable Role Delete Exits * fix: Honor Fail-Closed Auditing in the Admin Config, Group and Role Routes * fix: Bind Role Deletion to the Captured Id and Audit Only Atomic Role and Config Changes * fix: Skip the Config Restore When the Targeted Role Is Gone * fix: Audit Initial Group Members and Skip No-Op Role Description Updates * fix: Record Role Deletion as Pending Before Cleanup and Append Its Outcome * fix: Audit Reassigned Role Members and Return the Persisted Config After a Tracked Toggle * fix: Keep a Committed Role Deletion Successful When Cascade Audit Writes Fail * fix: Decide Group Update Audits From the Atomic Write and Sanitize Permission Update Logs * fix: Audit Grants From a Snapshot, Fail on Member Lookup Errors and Chunk Member Audit Entries * fix: Audit Group Deletion Members and Previous Role Removal, Abort on Grant Snapshot Failure * fix: Invalidate Config Caches After Partial Secret Writes * fix: Retry Failed Cascade Restores, Report Changed Group Fields and Audit Every Reassigned Member * fix: Log Safe Metadata When Cache Invalidation Fails After a Partial Write * fix: Keep Error Messages Out of the Audit Write Failure Log * style: Sort Audit Log Spec Imports * fix: Sanitize Admin Handler Error Logs and Dispatch System Audit Writes Without Waiting |
||
|
|
044c134ecf
|
🤏 fix: Filter Admin Config Reads by Section-Scoped Read Capability (#14472)
listConfigs, getBaseConfig, and getConfig only checked the broad read:configs capability, so a caller holding nothing but read:configs:<section> grants got a blanket 403 on all three instead of a response filtered to the sections they hold. Any deployment using section-scoped config grants hits this. Adds hasAnyConfigReadAccess as a cheap pre-flight check covering broad and section-scoped read and manage grants (manage implies read), so a zero-access caller still 403s before a DB fetch while a section-scoped caller gets the response filtered to exactly what they hold. The same manage-implies-read rule is fixed at its root in getParentCapabilities so a manage-only caller sees the section they manage instead of having it stripped after passing the pre-flight. Resolves every section for a request in one batched getHeldCapabilities query via getReadableConfigSections instead of one round trip per section. Includes AppConfig field-renaming normalization (interfaceConfig, turnstileConfig, mcpConfig) so the filter checks the canonical section name rather than the renamed response field, and stops availableTools from bypassing the filter by gating it on its filteredTools/includedTools source sections. |
||
|
|
fa20003952
|
🛂 refactor: Accept Targeted assign:configs for Config Scope-Lifecycle Endpoints (#13773)
* 🔓 fix: Accept Targeted assign:configs for Config Scope-Lifecycle Endpoints Three admin-config endpoints currently require broad manage:configs: PUT /:principalType/:principalId for empty-overrides scope creation, DELETE /:principalType/:principalId for scope removal, and PATCH /:principalType/:principalId/active for the active toggle. The capability model already defines assign:configs:user|group|role for delegated administrators and validates that shape in isValidCapability, but no handler accepts it, so a delegate granted assign:configs:role via /api/admin/grants cannot manage scope lifecycle for the principal type they were explicitly delegated. This aligns the server-side auth with the documented capability surface. Every destructive lateral path stays behind broad manage:configs: operations against the base config principal (__base__), non-empty PUT payloads that $set the full overrides field, and DELETE or toggle on a document whose existing overrides are non-empty (which would erase or neutralize sections the caller could not author). The new hasCapability dep on AdminConfigDeps is optional with a false default, so external consumers continue to get pre-PR behavior until they wire the resolver. * 🛡️ fix: Block Assign-Only Scope-Lifecycle When Existing Doc Has Tombstones The existing-overrides guard introduced in the prior commit only checked overrides, but configs also carry tombstones (suppressed inherited field paths) which are iterated during cascade resolution. An assign-only caller could delete, toggle, or empty-upsert a doc whose overrides is empty but whose tombstones is non-empty, which would erase or neutralize suppressions on fields they could not author. Extends the guard at all three call sites to treat a non-empty tombstones array as destructive state. * 🚨 fix: Log TOCTOU Race When Assign-Only Lifecycle Op Hits Non-Empty Doc The empty-state guard for assign-only callers performs a read-then-write across two DB roundtrips, so a concurrent broad-manage write can land between the guard and the destructive op. Adds post-write detection on the delete and toggle handlers: when the destructive op returns a doc whose state was non-empty at write time, emit logger.warn with the caller id, principal, and observed-state counts so ops can detect the race and restore from audit logs. A fully atomic fix would require extending deleteConfig, toggleConfigActive, and upsertConfig in packages/data-schemas/src/methods/config.ts to support compare-and-swap filters, which is a wider design change than this PR's auth scope. Empty-payload upsert is not covered because $set replaces overrides, so the post-write doc no longer reflects pre-write state. * 🔒 fix: Atomic Empty-State Filter for Assign-Only Scope-Lifecycle Writes Replaces the read-then-check guard with an atomic Mongo filter on the destructive write itself. Adds an options.expectEmpty parameter to deleteConfig, toggleConfigActive, and upsertConfig in the shared data-schemas layer. When set, the filter requires both overrides and tombstones to be empty before the write matches. The TOCTOU race window is eliminated: a concurrent write cannot land between the empty-state check and the destructive op because they are now a single atomic operation. For upsertConfig, the E11000 retry path returns null instead of falling back to a filterless update when expectEmpty is set, preserving the atomic property. Handlers fall back to findConfigByPrincipal only to disambiguate the null return between 404 (doc absent) and 403 (doc exists with non-empty state). The post-write logger.warn race detection added in the prior commit is removed as unreachable. |
||
|
|
aeb5adff34
|
🪦 fix: Add Durable MCP Config Tombstones (#13534)
* fix: add durable MCP config tombstones * fix: preserve scoped config tombstones * fix: clean up config tombstone lint * fix: handle empty model spec skill allowlist * fix: preserve inactive config tombstones |
||
|
|
9f6d8c6e93
|
🧵 feat: ALS Context Middleware, Tenant Threading, and Config Cache Invalidation (#12407)
* feat: add tenant context middleware for ALS-based isolation Introduces tenantContextMiddleware that propagates req.user.tenantId into AsyncLocalStorage, activating the Mongoose applyTenantIsolation plugin for all downstream DB queries within a request. - Strict mode (TENANT_ISOLATION_STRICT=true) returns 403 if no tenantId - Non-strict mode passes through for backward compatibility - No-op for unauthenticated requests - Includes 6 unit tests covering all paths * feat: register tenant middleware and wrap startup/auth in runAsSystem() - Register tenantContextMiddleware in Express app after capability middleware - Wrap server startup initialization in runAsSystem() for strict mode compat - Wrap auth strategy getAppConfig() calls in runAsSystem() since they run before user context is established (LDAP, SAML, OpenID, social login, AuthService) * feat: thread tenantId through all getAppConfig callers Pass tenantId from req.user to getAppConfig() across all callers that have request context, ensuring correct per-tenant cache key resolution. Also fixes getBaseConfig admin endpoint to scope to requesting admin's tenant instead of returning the unscoped base config. Files updated: - Controllers: UserController, PluginController - Middleware: checkDomainAllowed, balance - Routes: config - Services: loadConfigModels, loadDefaultModels, getEndpointsConfig, MCP - Audio services: TTSService, STTService, getVoices, getCustomConfigSpeech - Admin: getBaseConfig endpoint * feat: add config cache invalidation on admin mutations - Add clearOverrideCache(tenantId?) to flush per-principal override caches by enumerating Keyv store keys matching _OVERRIDE_: prefix - Add invalidateConfigCaches() helper that clears base config, override caches, tool caches, and endpoint config cache in one call - Wire invalidation into all 5 admin config mutation handlers (upsert, patch, delete field, delete overrides, toggle active) - Add strict mode warning when __default__ tenant fallback is used - Add 3 new tests for clearOverrideCache (all/scoped/base-preserving) * chore: update getUserPrincipals comment to reflect ALS-based tenant filtering The TODO(#12091) about missing tenantId filtering is resolved by the tenant context middleware + applyTenantIsolation Mongoose plugin. Group queries are now automatically scoped by tenantId via ALS. * fix: replace runAsSystem with baseOnly for pre-tenant code paths App configs are tenant-owned — runAsSystem() would bypass tenant isolation and return cross-tenant DB overrides. Instead, add baseOnly option to getAppConfig() that returns YAML-derived config only, with zero DB queries. All startup code, auth strategies, and MCP initialization now use getAppConfig({ baseOnly: true }) to get the YAML config without touching the Config collection. * fix: address PR review findings — middleware ordering, types, cache safety - Chain tenantContextMiddleware inside requireJwtAuth after passport auth instead of global app.use() where req.user is always undefined (Finding 1) - Remove global tenantContextMiddleware registration from index.js - Update BalanceMiddlewareOptions to include tenantId, remove redundant cast (Finding 4) - Add warning log when clearOverrideCache cannot enumerate keys on Redis (Finding 3) - Use startsWith instead of includes for cache key filtering (Finding 12) - Use generator loop instead of Array.from for key enumeration (Finding 3) - Selective barrel export — exclude _resetTenantMiddlewareStrictCache (Finding 5) - Move isMainThread check to module level, remove per-request check (Finding 9) - Move mid-file require to top of app.js (Finding 8) - Parallelize invalidateConfigCaches with Promise.all (Finding 10) - Remove clearOverrideCache from public app.js exports (internal only) - Strengthen getUserPrincipals comment re: ALS dependency (Finding 2) * fix: restore runAsSystem for startup DB ops, consolidate require, clarify baseOnly - Restore runAsSystem() around performStartupChecks, updateInterfacePermissions, initializeMCPs, and initializeOAuthReconnectManager — these make Mongoose queries that need system context in strict tenant mode (NEW-3) - Consolidate duplicate require('@librechat/api') in requireJwtAuth.js (NEW-1) - Document that baseOnly ignores role/userId/tenantId in JSDoc (NEW-2) * test: add requireJwtAuth tenant chaining + invalidateConfigCaches tests - requireJwtAuth: 5 tests verifying ALS tenant context is set after passport auth, isolated between concurrent requests, and not set when user has no tenantId (Finding 6) - invalidateConfigCaches: 4 tests verifying all four caches are cleared, tenantId is threaded through, partial failure is handled gracefully, and operations run in parallel via Promise.all (Finding 11) * fix: address Copilot review — passport errors, namespaced cache keys, /base scoping - Forward passport errors in requireJwtAuth before entering tenant middleware — prevents silent auth failures from reaching handlers (P1) - Account for Keyv namespace prefix in clearOverrideCache — stored keys are namespaced as "APP_CONFIG:_OVERRIDE_:..." not "_OVERRIDE_:...", so override caches were never actually matched/cleared (P2) - Remove role from getBaseConfig — /base should return tenant-scoped base config, not role-merged config that drifts per admin role (P2) - Return tenantStorage.run() for cleaner async semantics - Update mock cache in service.spec.ts to simulate Keyv namespacing * fix: address second review — cache safety, code quality, test reliability - Decouple cache invalidation from mutation response: fire-and-forget with logging so DB mutation success is not masked by cache failures - Extract clearEndpointConfigCache helper from inline IIFE - Move isMainThread check to lazy once-per-process guard (no import side effect) - Memoize process.env read in overrideCacheKey to avoid per-request env lookups and log flooding in strict mode - Remove flaky timer-based parallelism assertion, use structural check - Merge orphaned double JSDoc block on getUserPrincipals - Fix stale [getAppConfig] log prefix → [ensureBaseConfig] - Fix import order in tenant.spec.ts (package types before local values) - Replace "Finding 1" reference with self-contained description - Use real tenantStorage primitives in requireJwtAuth spec mock * fix: move JSDoc to correct function after clearEndpointConfigCache extraction * refactor: remove Redis SCAN from clearOverrideCache, rely on TTL expiry Redis SCAN causes 60s+ stalls under concurrent load (see #12410). APP_CONFIG defaults to FORCED_IN_MEMORY_CACHE_NAMESPACES, so the in-memory store.keys() path handles the standard case. When APP_CONFIG is Redis-backed, overrides expire naturally via overrideCacheTtl (60s default) — an acceptable window for admin config mutations. * fix: remove return from tenantStorage.run to satisfy void middleware signature * fix: address second review — cache safety, code quality, test reliability - Switch invalidateConfigCaches from Promise.all to Promise.allSettled so partial failures are logged individually instead of producing one undifferentiated error (Finding 3) - Gate overrideCacheKey strict-mode warning behind a once-per-process flag to prevent log flooding under load (Finding 4) - Add test for passport error forwarding in requireJwtAuth — the if (err) { return next(err) } branch now has coverage (Finding 5) - Add test for real partial failure in invalidateConfigCaches where clearAppConfigCache rejects (not just the swallowed endpoint error) * chore: reorder imports in index.js and app.js for consistency - Moved logger and runAsSystem imports to maintain a consistent import order across files. - Improved code readability by ensuring related imports are grouped together. |
||
|
|
4b6d68b3b5
|
🎛️ feat: DB-Backed Per-Principal Config System (#12354)
* ✨ feat: Add Config schema, model, and methods for role-based DB config overrides Add the database foundation for principal-based configuration overrides (user, group, role) in data-schemas. Includes schema with tenantId and tenant isolation, CRUD methods, and barrel exports. * 🔧 fix: Add shebang and enforce LF line endings for git hooks The pre-commit hook was missing #!/bin/sh, and core.autocrlf=true was converting it to CRLF, both causing "Exec format error" on Windows. Add .gitattributes to force LF for .husky/* and *.sh files. * ✨ feat: Add admin config API routes with section-level capability checks Add /api/admin/config endpoints for managing per-principal config overrides (user, group, role). Handlers in @librechat/api use DI pattern with section-level hasConfigCapability checks for granular access control. Supports full overrides replacement, per-field PATCH via dot-paths, field deletion, toggle active, and listing. * 🐛 fix: Move deleteConfigField fieldPath from URL param to request body The path-to-regexp wildcard syntax (:fieldPath(*)) is not supported by the version used in Express. Send fieldPath in the DELETE request body instead, which also avoids URL-encoding issues with dotted paths. * ✨ feat: Wire config resolution into getAppConfig with override caching Add mergeConfigOverrides utility in data-schemas for deep-merging DB config overrides into base AppConfig by priority order. Update getAppConfig to query DB for applicable configs when role/userId is provided, with short-TTL caching and a hasAnyConfigs feature flag for zero-cost when no DB configs exist. Also: add unique compound index on Config schema, pass userId from config middleware, and signal config changes from admin API handlers. * 🔄 refactor: Extract getAppConfig logic into packages/api as TS service Move override resolution, caching strategy, and signalConfigChange from api/server/services/Config/app.js into packages/api/src/app/appConfigService.ts using the DI factory pattern (createAppConfigService). The JS file becomes a thin wiring layer injecting loadBaseConfig, cache, and DB dependencies. * 🧹 chore: Rename configResolution.ts to resolution.ts * ✨ feat: Move admin types & capabilities to librechat-data-provider Move SystemCapabilities, CapabilityImplications, and utility functions (hasImpliedCapability, expandImplications) from data-schemas to data-provider so they are available to external consumers like the admin panel without a data-schemas dependency. Add API-friendly admin types: TAdminConfig, TAdminSystemGrant, TAdminAuditLogEntry, TAdminGroup, TAdminMember, TAdminUserSearchResult, TCapabilityCategory, and CAPABILITY_CATEGORIES. data-schemas re-exports these from data-provider and extends with config-schema-derived types (ConfigSection, SystemCapability union). Bump version to 0.8.500. * feat: Add JSON-serializable admin config API response types to data-schemas Add AdminConfig, AdminConfigListResponse, AdminConfigResponse, and AdminConfigDeleteResponse types so both LibreChat API handlers and the admin panel can share the same response contract. Bump version to 0.0.41. * refactor: Move admin capabilities & types from data-provider to data-schemas SystemCapabilities, CapabilityImplications, utility functions, CAPABILITY_CATEGORIES, and admin API response types should not be in data-provider as it gets compiled into the frontend bundle, exposing the capability surface. Moved everything to data-schemas (server-only). All consumers already import from @librechat/data-schemas, so no import changes needed elsewhere. Consolidated duplicate AdminConfig type (was in both config.ts and admin.ts). * chore: Bump @librechat/data-schemas to 0.0.42 * refactor: Reorganize admin capabilities into admin/ and types/admin.ts Split systemCapabilities.ts following data-schemas conventions: - Types (BaseSystemCapability, SystemCapability, AdminConfig, etc.) → src/types/admin.ts - Runtime code (SystemCapabilities, CapabilityImplications, utilities) → src/admin/capabilities.ts Revert data-provider version to 0.8.401 (no longer modified). * chore: Fix import ordering, rename appConfigService to service - Rename app/appConfigService.ts → app/service.ts (directory provides context) - Fix import order in admin/config.ts, types/admin.ts, types/config.ts - Add naming convention to AGENTS.md * feat: Add DB base config support (role/__base__) - Add BASE_CONFIG_PRINCIPAL_ID constant for reserved base config doc - getApplicableConfigs always includes __base__ in queries - getAppConfig queries DB even without role/userId when DB configs exist - Bump @librechat/data-schemas to 0.0.43 * fix: Address PR review issues for admin config - Add listAllConfigs method; listConfigs endpoint returns all active configs instead of only __base__ - Normalize principalId to string in all config methods to prevent ObjectId vs string mismatch on user/group lookups - Block __proto__ and all dunder-prefixed segments in field path validation to prevent prototype pollution - Fix configVersion off-by-one: default to 0, guard pre('save') with !isNew, use $inc on findOneAndUpdate - Remove unused getApplicableConfigs from admin handler deps * fix: Enable tree-shaking for data-schemas, bump packages - Switch data-schemas Rollup output to preserveModules so each source file becomes its own chunk; consumers (admin panel) can now import just the modules they need without pulling in winston/mongoose/etc. - Add sideEffects: false to data-schemas package.json - Bump data-schemas to 0.0.44, data-provider to 0.8.402 * feat: add capabilities subpath export to data-schemas Adds `@librechat/data-schemas/capabilities` subpath export so browser consumers can import BASE_CONFIG_PRINCIPAL_ID and capability constants without pulling in Node.js-only modules (winston, async_hooks, etc.). Bump version to 0.0.45. * fix: include dist/ in data-provider npm package Add explicit files field so npm includes dist/types/ in the published package. Without this, the root .gitignore exclusion of dist/ causes npm to omit type declarations, breaking TypeScript consumers. * chore: bump librechat-data-provider to 0.8.403 * feat: add GET /api/admin/config/base for raw AppConfig Returns the full AppConfig (YAML + DB base merged) so the admin panel can display actual config field values and structure. The startup config endpoint (/api/config) returns TStartupConfig which is a different shape meant for the frontend app. * chore: imports order * fix: address code review findings for admin config Critical: - Fix clearAppConfigCache: was deleting from wrong cache store (CONFIG_STORE instead of APP_CONFIG), now clears BASE and HAS_DB_CONFIGS keys - Eliminate race condition: patchConfigField and deleteConfigField now use atomic MongoDB $set/$unset with dot-path notation instead of read-modify-write cycles, removing the lost-update bug entirely - Add patchConfigFields and unsetConfigField atomic DB methods Major: - Reorder cache check before principal resolution in getAppConfig so getUserPrincipals DB query only fires on cache miss - Replace '' as ConfigSection with typed BROAD_CONFIG_ACCESS constant - Parallelize capability checks with Promise.all instead of sequential awaits in for loops - Use loose equality (== null) for cache miss check to handle both null and undefined returns from cache implementations - Set HAS_DB_CONFIGS_KEY to true on successful config fetch Minor: - Remove dead pre('save') hook from config schema (all writes use findOneAndUpdate which bypasses document hooks) - Consolidate duplicate type imports in resolution.ts - Remove dead deepGet/deepSet/deepUnset functions (replaced by atomic ops) - Add .sort({ priority: 1 }) to getApplicableConfigs query - Rename _impliedBy to impliedByMap * fix: self-referencing BROAD_CONFIG_ACCESS constant * fix: replace type-cast sentinel with proper null parameter Update hasConfigCapability to accept ConfigSection | null where null means broad access check (MANAGE_CONFIGS or READ_CONFIGS only). Removes the '' as ConfigSection type lie from admin config handlers. * fix: remaining review findings + add tests - listAllConfigs accepts optional { isActive } filter so admin listing can show inactive configs (#9) - Standardize session application to .session(session ?? null) across all config DB methods (#15) - Export isValidFieldPath and getTopLevelSection for testability - Add 38 tests across 3 spec files: - config.spec.ts (api): path validation, prototype pollution rejection - resolution.spec.ts: deep merge, priority ordering, array replacement - config.spec.ts (data-schemas): full CRUD, ObjectId normalization, atomic $set/$unset, configVersion increment, toggle, __base__ query * fix: address second code review findings - Fix cross-user cache contamination: overrideCacheKey now handles userId-without-role case with its own cache key (#1) - Add broad capability check before DB lookup in getConfig to prevent config existence enumeration (#2/#3) - Move deleteConfigField fieldPath from request body to query parameter for proxy/load balancer compatibility (#5) - Derive BaseSystemCapability from SystemCapabilities const instead of manual string union (#6) - Return 201 on upsert creation, 200 on update (#11) - Remove inline narration comments per AGENTS.md (#12) - Type overrides as Partial<TCustomConfig> in DB methods and handler deps (#13) - Replace double as-unknown-as casts in resolution.ts with generic deepMerge<T> (#14) - Make override cache TTL injectable via AppConfigServiceDeps (#16) - Add exhaustive never check in principalModel switch (#17) * fix: remaining review findings — tests, rename, semantics - Rename signalConfigChange → markConfigsDirty with JSDoc documenting the stale-window tradeoff and overrideCacheTtl knob - Fix DEFAULT_OVERRIDE_CACHE_TTL naming convention - Add createAppConfigService tests (14 cases): cache behavior, feature flag, cross-user key isolation, fallback on error, markConfigsDirty - Add admin handler integration tests (13 cases): auth ordering, 201/200 on create/update, fieldPath from query param, markConfigsDirty calls, capability checks * fix: global flag corruption + empty overrides auth bypass - Remove HAS_DB_CONFIGS_KEY=false optimization: a scoped query returning no configs does not mean no configs exist globally. Setting the flag false from a per-principal query short-circuited all subsequent users. - Add broad manage capability check before section checks in upsertConfigOverrides: empty overrides {} no longer bypasses auth. * test: add regression and invariant tests for config system Regression tests: - Bug 1: User A's empty result does not short-circuit User B's overrides - Bug 2: Empty overrides {} returns 403 without MANAGE_CONFIGS Invariant tests (applied across ALL handlers): - All 5 mutation handlers call markConfigsDirty on success - All 5 mutation handlers return 401 without auth - All 5 mutation handlers return 403 without capability - All 3 read handlers return 403 without capability * fix: third review pass — all findings addressed Service (service.ts): - Restore HAS_DB_CONFIGS=false for base-only queries (no role/userId) so deployments with zero DB configs skip DB queries (#1) - Resolve cache once at factory init instead of per-invocation (#8) - Use BASE_CONFIG_PRINCIPAL_ID constant in overrideCacheKey (#10) - Add JSDoc to clearAppConfigCache documenting stale-window (#4) - Fix log message to not say "from YAML" (#14) Admin handlers (config.ts): - Use configVersion===1 for 201 vs 200, eliminating TOCTOU race (#2) - Add Array.isArray guard on overrides body (#5) - Import CapabilityUser from capabilities.ts, remove duplicate (#6) - Replace as-unknown-as cast with targeted type assertion (#7) - Add MAX_PATCH_ENTRIES=100 cap on entries array (#15) - Reorder deleteConfigField to validate principalType first (#12) - Export CapabilityUser from middleware/capabilities.ts DB methods (config.ts): - Remove isActive:true from patchConfigFields to prevent silent reactivation of disabled configs (#3) Schema (config.ts): - Change principalId from Schema.Types.Mixed to String (#11) Tests: - Add patchConfigField unsafe fieldPath rejection test (#9) - Add base-only HAS_DB_CONFIGS=false test (#1) - Update 201/200 tests to use configVersion instead of findConfig (#2) * fix: add read handler 401 invariant tests + document flag behavior - Add invariant: all 3 read handlers return 401 without auth - Document on markConfigsDirty that HAS_DB_CONFIGS stays true after all configs are deleted until clearAppConfigCache or restart * fix: remove HAS_DB_CONFIGS false optimization entirely getApplicableConfigs([]) only queries for __base__, not all configs. A deployment with role/group configs but no __base__ doc gets the flag poisoned to false by a base-only query, silently ignoring all scoped overrides. The optimization is not safe without a comprehensive Config.exists() check, which adds its own DB cost. Removed entirely. The flag is now write-once-true (set when configs are found or by markConfigsDirty) and only cleared by clearAppConfigCache/restart. * chore: reorder import statements in app.js for clarity * refactor: remove HAS_DB_CONFIGS_KEY machinery entirely The three-state flag (false/null/true) was the source of multiple bugs across review rounds. Every attempt to safely set it to false was defeated by getApplicableConfigs querying only a subset of principals. Removed: HAS_DB_CONFIGS_KEY constant, all reads/writes of the flag, markConfigsDirty (now a no-op concept), notifyChange wrapper, and all tests that seeded false manually. The per-user/role TTL cache (overrideCacheTtl, default 60s) is the sole caching mechanism. On cache miss, getApplicableConfigs queries the DB. This is one indexed query per user per TTL window — acceptable for the config override use case. * docs: rewrite admin panel remaining work with current state * perf: cache empty override results to avoid repeated DB queries When getApplicableConfigs returns no configs for a principal, cache baseConfig under their override key with TTL. Without this, every user with no per-principal overrides hits MongoDB on every request after the 60s cache window expires. * fix: add tenantId to cache keys + reject PUBLIC principal type - Include tenantId in override cache keys to prevent cross-tenant config contamination. Single-tenant deployments (tenantId undefined) use '_' as placeholder — no behavior change for them. - Reject PrincipalType.PUBLIC in admin config validation — PUBLIC has no PrincipalModel and is never resolved by getApplicableConfigs, so config docs for it would be dead data. - Config middleware passes req.user.tenantId to getAppConfig. * fix: fourth review pass findings DB methods (config.ts): - findConfigByPrincipal accepts { includeInactive } option so admin GET can retrieve inactive configs (#5) - upsertConfig catches E11000 duplicate key on concurrent upserts and retries without upsert flag (#2) - unsetConfigField no longer filters isActive:true, consistent with patchConfigFields (#11) - Typed filter objects replace Record<string, unknown> (#12) Admin handlers (config.ts): - patchConfigField: serial broad capability check before Promise.all to pre-warm ALS principal cache, preventing N parallel DB calls (#3) - isValidFieldPath rejects leading/trailing dots and consecutive dots (#7) - Duplicate fieldPaths in patch entries return 400 (#8) - DEFAULT_PRIORITY named constant replaces hardcoded 10 (#14) - Admin getConfig and patchConfigField pass includeInactive to findConfigByPrincipal (#5) - Route import uses barrel instead of direct file path (#13) Resolution (resolution.ts): - deepMerge has MAX_MERGE_DEPTH=10 guard to prevent stack overflow from crafted deeply nested configs (#4) * fix: final review cleanup - Remove ADMIN_PANEL_REMAINING.md (local dev notes with Windows paths) - Add empty-result caching regression test - Add tenantId to AdminConfigDeps.getAppConfig type - Restore exhaustive never check in principalModel switch - Standardize toggleConfigActive session handling to options pattern * fix: validate priority in patchConfigField handler Add the same non-negative number validation for priority that upsertConfigOverrides already has. Without this, invalid priority values could be stored via PATCH and corrupt merge ordering. * chore: remove planning doc from PR * fix: correct stale cache key strings in service tests * fix: clean up service tests and harden tenant sentinel - Remove no-op cache delete lines from regression tests - Change no-tenant sentinel from '_' to '__default__' to avoid collision with a real tenant ID when multi-tenancy is enabled - Remove unused CONFIG_STORE from AppConfigServiceDeps * chore: bump @librechat/data-schemas to 0.0.46 * fix: block prototype-poisoning keys in deepMerge Skip __proto__, constructor, and prototype keys during config merge to prevent prototype pollution via PUT /api/admin/config overrides. |