ha-mcp-dev 9.0.0.dev3182__tar.gz → 9.0.0.dev3183__tar.gz

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.0.0.dev3182
+Version: 9.0.0.dev3183
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.0.0.dev3182"
+version = "9.0.0.dev3183"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.15"

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.0.0.dev3182"
+version = "9.0.0.dev3183"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/src/ha_mcp/config_meta.py

@@ -31,6 +31,7 @@ AdvancedSection = Literal[
     "sidecar",
     "beta_codemode",
     "beta_yamlkeys",
+    "redact_keys",
     "developer",
 ]
 

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/src/ha_mcp/config_settings.py

@@ -559,6 +559,21 @@ class Settings(BaseSettings):
         Field(False, alias="REDACT_SECRETS")
     )
 
+    # App option names to redact like ``format: password`` fields, for apps
+    # whose schema ships a secret as a plain string (#2843). Format: see
+    # ``redaction._listed_entries``. Consulted only while ``redact_secrets``
+    # is on; the UI nests it under that toggle. Restart-required because the
+    # app reads its options only at start, though other installs apply it live.
+    redact_app_option_keys: Annotated[
+        str,
+        Setting(
+            surface="advanced",
+            section="redact_keys",
+            app=_ALL_FLAVORS,
+            restart_required=True,
+        ),
+    ] = Field("", alias="REDACT_APP_OPTION_KEYS")
+
     # Mandatory best-practice skills — server-side master switch for the
     # write-tool skill_content delivery feature (issue #1182). When True
     # (default), the six write tools (automations / scripts / scenes /

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/src/ha_mcp/redaction.py

@@ -8,12 +8,14 @@ surfaces stop returning operator secrets verbatim:
    proxy-mode 403 hints): every ``options`` value whose Supervisor-serialized
    ``schema`` entry carries ``format: "password"`` is replaced with a
    set/empty sentinel. The schema is authoritative — keys without a schema
-   entry are never touched, and no name-based guessing happens.
+   entry are never touched, and option names are never guessed at. The only
+   name-based match is the operator's own ``redact_app_option_keys`` list;
+   listed options and PEM private-key values are treated as password fields.
 2. **Integration options** (``ha_get_integration``): fields the
    options-flow schema marks with a password text selector are replaced the
    same way, on both the harvested options and the ``include_schema=True``
    schema echo (whose ``suggested_value`` carries the live value).
-3. **Every other tool response**: password values seen while serving 1 and 2
+3. **Every other tool response**: secret values seen while serving 1 and 2
    are remembered in a process-local known-secrets set, and
    :class:`RedactSecretsMiddleware` (registered just outside the
    entity-visibility outbound scan, which stays innermost) scrubs any
@@ -162,63 +164,239 @@ def _iter_schema_entries(schema: Any) -> Iterable[dict[str, Any]]:
             yield entry
 
 
-def redact_addon_options(options: Any, schema: Any) -> Any:
-    """Copy of ``options`` with ``format: password`` values sentinel-replaced.
+def _listed_entries() -> list[tuple[str, str]]:
+    """``(scope, name)`` pairs from ``redact_app_option_keys`` (#2843).
 
-    Walks nested option groups recursively (a group's value may be a dict or,
-    with ``multiple``, a list of dicts). Keys without a schema entry pass
-    through untouched. Non-dict ``options`` are returned as-is.
+    Entries are separated by commas or newlines. ``name`` applies to every
+    app (scope ``""``); ``<slug>:<name>`` to one app.
     """
+    entries: list[tuple[str, str]] = []
+    for entry in re.split(r"[,\n]", get_global_settings().redact_app_option_keys):
+        scope, _sep, name = (part.strip() for part in entry.rpartition(":"))
+        if name:
+            entries.append((scope, name))
+    return entries
+
+
+def _scope_matches(scope: str, slug: str) -> bool:
+    # A store app's slug carries its repository's prefix (``cebe7a76_...``,
+    # ``core_...``), which the app's own docs and repository leave out, so
+    # the unprefixed slug names the app too.
+    return scope == slug or scope == slug.partition("_")[2]
+
+
+def _operator_listed_option_keys(slug: str) -> frozenset[str]:
+    return frozenset(
+        name
+        for scope, name in _listed_entries()
+        if not scope or _scope_matches(scope, slug)
+    )
+
+
+def _schema_names(schema: Any) -> set[str]:
+    names: set[str] = set()
+    for entry in _iter_schema_entries(schema):
+        names.add(entry["name"])
+        names |= _schema_names(entry.get("schema"))
+    return names
+
+
+def _option_names(options: Any) -> set[str]:
+    names: set[str] = set()
+    items = options if isinstance(options, list) else [options]
+    for item in items:
+        if isinstance(item, dict):
+            for name, value in item.items():
+                names.add(name)
+                names |= _option_names(value)
+    return names
+
+
+def _is_secret_option(
+    entry: dict[str, Any], value: Any, listed: frozenset[str]
+) -> bool:
+    return (
+        entry.get("format") == "password"
+        or entry["name"] in listed
+        or contains_pem_private_key(value)
+    )
+
+
+def redact_addon_info(
+    addon: dict[str, Any], slug: str
+) -> tuple[dict[str, Any], list[str]]:
+    """Redacted copy of a Supervisor ``/addons/<slug>/info`` result, and warnings.
+
+    Registers the app's secret values for the known-value scrub. Without a
+    readable schema the password fields cannot be told apart, so every option
+    value is redacted, like the integration surface does.
+    """
+    options = addon.get("options")
+    schema = addon.get("schema")
+    if not isinstance(options, dict) or not options:
+        return addon, []
+    listed = _operator_listed_option_keys(slug)
+    if not isinstance(schema, list) or not schema:
+        # Every value is masked here, but only listed ones are known secrets
+        # worth scrubbing from other responses.
+        register_known_secret_values(_collect_stored(options, listed, False))
+        redacted = {key: sentinel_replacement(value) for key, value in options.items()}
+        return {**addon, "options": redacted}, [
+            f"redact_secrets: no options schema readable for '{slug}' — "
+            "every option value was redacted conservatively (the "
+            "password fields cannot be told apart without the schema)"
+        ]
+    register_known_secret_values(_collect_addon_secret_values(options, schema, listed))
+    unknown = sorted(
+        {
+            name
+            for scope, name in _listed_entries()
+            if scope and _scope_matches(scope, slug)
+        }
+        - _schema_names(schema)
+        - _option_names(options)
+    )
+    warnings = (
+        [
+            f"redact_app_option_keys names {', '.join(unknown)} for '{slug}', "
+            "but this app has no such option, so nothing was redacted for them"
+        ]
+        if unknown
+        else []
+    )
+    redacted = _redact_addon_options(options, schema, listed)
+    return {**addon, "options": redacted}, warnings
+
+
+def redact_addon_options(options: Any, schema: Any, slug: str) -> Any:
+    """Copy of ``options`` with secret values sentinel-replaced.
+
+    A value is secret when its schema entry carries ``format: password``, its
+    name (or the name of a group containing it) is listed for ``slug`` in
+    ``redact_app_option_keys``, or it holds a PEM private key. Listed names
+    are also redacted in values Supervisor kept after an app update dropped
+    the option or changed it between a group and a plain field, keeping the
+    stored shape around them. Walks nested option groups recursively (a
+    group's value may be a dict or, with ``multiple``, a list of dicts).
+    Other keys without a schema entry pass through untouched. Non-dict
+    ``options`` are returned as-is.
+    """
+    return _redact_addon_options(options, schema, _operator_listed_option_keys(slug))
+
+
+def _redact_addon_options(
+    options: Any, schema: Any, listed: frozenset[str], whole: bool = False
+) -> Any:
+    """``whole``: the options sit inside a listed group, so all are secret."""
     if not isinstance(options, dict):
         return options
     out = dict(options)
+    known: set[str] = set()
     for entry in _iter_schema_entries(schema):
         name = entry["name"]
+        known.add(name)
         if name not in out:
             continue
         value = out[name]
         nested = entry.get("schema")
+        secret = whole or name in listed
+        # A manual app update can turn a field into a group or back without
+        # Supervisor converting the stored value, so a mismatched value is
+        # walked like a stored option the schema no longer describes.
         if isinstance(nested, list):
-            if isinstance(value, dict):
-                out[name] = redact_addon_options(value, nested)
-            elif isinstance(value, list):
-                out[name] = [
-                    redact_addon_options(item, nested)
-                    if isinstance(item, dict)
-                    else item
-                    for item in value
-                ]
-            continue
-        if entry.get("format") == "password" or contains_pem_private_key(value):
+            out[name] = _redact_group(value, nested, listed, secret)
+        elif secret or _is_secret_option(entry, value, listed):
             # multiple: true passwords are a list — sentinel_replacement
             # keeps the container shape so the option's type survives.
             out[name] = sentinel_replacement(value)
+        elif isinstance(value, (dict, list)):
+            out[name] = _redact_stored(value, listed, False)
+    for name in out.keys() - known:
+        out[name] = _redact_stored(out[name], listed, whole or name in listed)
     return out
 
 
-def collect_addon_secret_values(options: Any, schema: Any) -> set[str]:
-    """Live ``format: password`` option values, for the known-value scrub."""
+def _redact_group(
+    value: Any, schema: list[Any], listed: frozenset[str], secret: bool
+) -> Any:
+    if isinstance(value, dict):
+        return _redact_addon_options(value, schema, listed, secret)
+    if isinstance(value, list):
+        return [
+            _redact_addon_options(item, schema, listed, secret)
+            if isinstance(item, dict)
+            else _redact_stored(item, listed, secret)
+            for item in value
+        ]
+    return value if value is None else _redact_stored(value, listed, secret)
+
+
+def _redact_stored(value: Any, listed: frozenset[str], secret: bool) -> Any:
+    """Redact a stored option the schema no longer describes.
+
+    Supervisor keeps an option's saved value after an app update drops it
+    from the schema or changes its type, so a listed secret can outlive its
+    schema entry. Only the listed names can be matched here; the shape is
+    kept.
+    """
+    if isinstance(value, dict):
+        return {
+            key: _redact_stored(item, listed, secret or key in listed)
+            for key, item in value.items()
+        }
+    if isinstance(value, list):
+        return [_redact_stored(item, listed, secret) for item in value]
+    return sentinel_replacement(value) if secret else value
+
+
+def collect_addon_secret_values(options: Any, schema: Any, slug: str) -> set[str]:
+    """Live secret option values (see ``redact_addon_options``), for the scrub."""
+    return _collect_addon_secret_values(
+        options, schema, _operator_listed_option_keys(slug)
+    )
+
+
+def _collect_addon_secret_values(
+    options: Any, schema: Any, listed: frozenset[str], whole: bool = False
+) -> set[str]:
     values: set[str] = set()
     if not isinstance(options, dict):
         return values
+    known: set[str] = set()
     for entry in _iter_schema_entries(schema):
-        value = options.get(entry["name"])
+        name = entry["name"]
+        known.add(name)
+        value = options.get(name)
         nested = entry.get("schema")
+        secret = whole or name in listed
         if isinstance(nested, list):
-            if isinstance(value, dict):
-                values |= collect_addon_secret_values(value, nested)
-            elif isinstance(value, list):
-                for item in value:
-                    if isinstance(item, dict):
-                        values |= collect_addon_secret_values(item, nested)
+            items = value if isinstance(value, list) else [value]
+            for item in items:
+                if isinstance(item, dict):
+                    values |= _collect_addon_secret_values(item, nested, listed, secret)
+                else:
+                    values |= _collect_stored(item, listed, secret)
             continue
-        if entry.get("format") == "password" or contains_pem_private_key(value):
-            candidates = value if isinstance(value, list) else [value]
-            for candidate in candidates:
-                values |= known_values_for_option_item(candidate)
+        values |= _collect_stored(
+            value, listed, secret or _is_secret_option(entry, value, listed)
+        )
+    for name in options.keys() - known:
+        values |= _collect_stored(options[name], listed, whole or name in listed)
     return values
 
 
+def _collect_stored(value: Any, listed: frozenset[str], secret: bool) -> set[str]:
+    """Known-value strings of a stored option (see ``_redact_stored``)."""
+    if isinstance(value, dict):
+        values: set[str] = set()
+        for key, item in value.items():
+            values |= _collect_stored(item, listed, secret or key in listed)
+        return values
+    if isinstance(value, list):
+        return set().union(*(_collect_stored(item, listed, secret) for item in value))
+    return known_values_for_option_item(value) if secret else set()
+
+
 def sentinel_option_keys(options: Any, _prefix: str = "") -> list[str]:
     """Dotted paths of submitted option values that equal a redaction sentinel.
 

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/src/ha_mcp/settings_ui/locales/en.json

@@ -138,7 +138,7 @@
     "features.read_only_mode.label": "Read Only Mode",
     "features.read_only_mode.help": "Toggles all write tools off, and removes ability for tools to make any write or destructive calls. Mixed read/write tools — backups, Apps (add-ons), energy preferences, voice pipelines, and code mode when enabled — stay available with their write operations blocked. Same toggle as the web UI Tools tab. Off by default. Requires restart to take effect.",
     "features.redact_secrets.label": "Redact Secrets",
-    "features.redact_secrets.help": "Redacts secrets from tool responses before they reach the AI assistant. App (add-on) options and integration fields marked as passwords are replaced with a set/empty marker (so \"is this credential configured?\" stays answerable), and other tool responses are scrubbed of secret values the server has already seen (values shorter than 6 characters are skipped, since replacing tiny fragments would corrupt unrelated output). Fields not marked as passwords by their schema cannot be detected. Off by default.",
+    "features.redact_secrets.help": "Redacts secrets from tool responses before they reach the AI assistant. App (add-on) options and integration fields marked as passwords are replaced with a set/empty marker (so \"is this credential configured?\" stays answerable), and other tool responses are scrubbed of secret values the server has already seen (values shorter than 6 characters are skipped, since replacing tiny fragments would corrupt unrelated output). Other fields are not detected, except private keys in app options and the app option names listed below. Off by default.",
     "features.enable_mandatory_bps.label": "Attach best-practice skills on writes",
     "features.enable_mandatory_bps.help": "Master switch for the write-tool skill content delivery feature (issue #1182). When enabled (default), the six config write tools (automations, scripts, scenes, helpers, dashboards, raw YAML) attach the canonical Home Assistant best-practice reference files under `skill_content` on every successful write, plus auto-embed any reference sections cited by best-practice warnings. Each tool also exposes a per-call `MandatoryBPS` parameter the agent can set to false on subsequent calls once it has the content. When this master switch is off, NO skill_content goes out regardless of the per-call parameter or BP warnings. Recommended ON as the first choice; disable only for models with very small context windows. Turning this off may degrade write accuracy. Requires restart to take effect.",
     "features.enable_strict_mandatory_bps.label": "Strict best-practices mode",
@@ -516,6 +516,8 @@
     "advanced.code_mode_saved_tools_path.help": "JSON file used to persist custom tools across restarts.",
     "advanced.extra_yaml_write_keys.label": "Extra YAML write keys",
     "advanced.extra_yaml_write_keys.help": "Extra top-level keys ha_config_set_yaml may write in addition to the built-in ones, for YAML-first integrations on this install (e.g. alert2). Enter one key per line or separate keys with commas. Keys that redefine Home Assistant's own trust boundary can never be added and are ignored. Requires custom component 1.2.4 or newer.",
+    "advanced.redact_app_option_keys.label": "Extra app option keys to redact",
+    "advanced.redact_app_option_keys.help": "App (add-on) option names to redact like password fields, for apps whose schema stores a secret as plain text (for example backup_password). Separate names with commas or new lines. A name applies to every app; write app_slug:name to limit it to one app. Naming an option group covers every option in it. Used only while Redact Secrets is on. Empty by default.",
     "advanced.sidecar_pin_port.label": "Settings UI sidecar port",
     "advanced.sidecar_pin_port.help": "0 picks a free port on first start and keeps it for later restarts; a port in the range pins a preferred port (falls back to a free one if taken).",
     "advanced.enable_dev_mode.label": "Developer mode",

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/src/ha_mcp/settings_ui/settings.css

@@ -511,28 +511,35 @@
   .feature-row.beta-sub,
   .feature-row.codemode-sub,
   .feature-row.yaml-packages-sub,
-  .feature-row.mandatory-bps-sub { position: relative; }
+  .feature-row.mandatory-bps-sub,
+  .feature-row.redact-sub { position: relative; }
   .feature-row.beta-sub::before,
   .feature-row.codemode-sub::before,
   .feature-row.yaml-packages-sub::before,
-  .feature-row.mandatory-bps-sub::before {
+  .feature-row.mandatory-bps-sub::before,
+  .feature-row.redact-sub::before {
     content: ""; position: absolute; top: 0; bottom: 0; width: 2px; background: var(--border);
   }
   .feature-row.beta-sub.dimmed,
   .feature-row.codemode-sub.dimmed,
   .feature-row.yaml-packages-sub.dimmed,
-  .feature-row.mandatory-bps-sub.dimmed { opacity: 0.38; }
+  .feature-row.mandatory-bps-sub.dimmed,
+  .feature-row.redact-sub.dimmed { opacity: 0.38; }
   .feature-row.beta-sub.dimmed input,
   .feature-row.codemode-sub.dimmed input,
   .feature-row.yaml-packages-sub.dimmed input,
-  .feature-row.mandatory-bps-sub.dimmed input { cursor: not-allowed; }
+  .feature-row.mandatory-bps-sub.dimmed input,
+  .feature-row.redact-sub.dimmed input { cursor: not-allowed; }
 
   /* Depth 1 — nested directly under a top-level toggle (beta-sub under the
-     master; strict-mode under the non-beta enable_mandatory_bps row). */
+     master; strict-mode under the non-beta enable_mandatory_bps row; extra
+     redacted app option keys under redact_secrets). */
   .feature-row.beta-sub,
-  .feature-row.mandatory-bps-sub { padding-left: 32px; }
+  .feature-row.mandatory-bps-sub,
+  .feature-row.redact-sub { padding-left: 32px; }
   .feature-row.beta-sub::before,
-  .feature-row.mandatory-bps-sub::before { left: 12px; }
+  .feature-row.mandatory-bps-sub::before,
+  .feature-row.redact-sub::before { left: 12px; }
 
   /* Depth 2 — nested under a beta-sub parent (yaml packages under
      enable_yaml_config_editing; code-mode numerics under enable_code_mode). */

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/src/ha_mcp/settings_ui/settings_js/05_feature_flags.js

@@ -25,7 +25,7 @@ const FEATURE_META = {
   },
   redact_secrets: {
     label: "Redact Secrets",
-    help: "Redacts secrets from tool responses before they reach the AI assistant. App (add-on) options and integration fields marked as passwords are replaced with a set/empty marker (so \"is this credential configured?\" stays answerable), and other tool responses are scrubbed of secret values the server has already seen (values shorter than 6 characters are skipped, since replacing tiny fragments would corrupt unrelated output). Fields not marked as passwords by their schema cannot be detected. Off by default.",
+    help: "Redacts secrets from tool responses before they reach the AI assistant. App (add-on) options and integration fields marked as passwords are replaced with a set/empty marker (so \"is this credential configured?\" stays answerable), and other tool responses are scrubbed of secret values the server has already seen (values shorter than 6 characters are skipped, since replacing tiny fragments would corrupt unrelated output). Other fields are not detected, except private keys in app options and the app option names listed below. Off by default.",
   },
   enable_mandatory_bps: {
     label: "Attach best-practice skills on writes",
@@ -107,6 +107,18 @@ const MANDATORY_BPS_SUB_FLAGS = [
   'enable_strict_mandatory_bps',
 ];
 
+// Non-master toggles with rows nested under them; flipping one re-renders
+// the panel so those rows dim or undim at once.
+const PARENTS_WITH_SUB_ROWS = new Set([
+  'enable_yaml_config_editing',
+  'enable_mandatory_bps',
+  'redact_secrets',
+]);
+
+// Advanced text settings edited as a one-per-line list and saved
+// comma-joined.
+const LIST_EDITOR_FIELDS = new Set(['extra_yaml_write_keys', 'redact_app_option_keys']);
+
 // Cached add-on flag. Each settings endpoint (/api/settings/features,
 // /api/settings/advanced, /api/settings/backup-config) returns
 // ``is_addon`` so the env-locked banner copy can adapt — the addon
@@ -284,40 +296,18 @@ function renderFeatureFlags(flags) {
         // master off then back on restores the user's prior sub-flag
         // selections automatically, which is the intended UX for an
         // opt-in beta surface.
-        if (isMaster) {
-          if (_lastFeatureFlags[fieldName]) {
-            _lastFeatureFlags[fieldName] = {
-              ..._lastFeatureFlags[fieldName],
-              value: input.checked,
-            };
-            renderFeatureFlags(_lastFeatureFlags);
-          }
-        }
-        // Re-render on enable_yaml_config_editing flip so the 3
-        // packages sub-rows dim/undim immediately. Same pattern as the
-        // master flip above — value is mutated in the live cache and
-        // the panel re-renders synchronously while the save POST runs
-        // in the background.
-        if (fieldName === 'enable_yaml_config_editing') {
-          if (_lastFeatureFlags[fieldName]) {
-            _lastFeatureFlags[fieldName] = {
-              ..._lastFeatureFlags[fieldName],
-              value: input.checked,
-            };
-            renderFeatureFlags(_lastFeatureFlags);
-          }
-        }
-        // Re-render on enable_mandatory_bps flip so the strict-mode
-        // sub-row dims/undims immediately. Same live-cache pattern as
-        // the master and yaml-config flips above.
-        if (fieldName === 'enable_mandatory_bps') {
-          if (_lastFeatureFlags[fieldName]) {
-            _lastFeatureFlags[fieldName] = {
-              ..._lastFeatureFlags[fieldName],
-              value: input.checked,
-            };
-            renderFeatureFlags(_lastFeatureFlags);
-          }
+        //
+        // The other parents with nested rows re-render the same way, so
+        // their sub-rows dim/undim immediately.
+        if (
+          (isMaster || PARENTS_WITH_SUB_ROWS.has(fieldName)) &&
+          _lastFeatureFlags[fieldName]
+        ) {
+          _lastFeatureFlags[fieldName] = {
+            ..._lastFeatureFlags[fieldName],
+            value: input.checked,
+          };
+          renderFeatureFlags(_lastFeatureFlags);
         }
         saveFeatureFlag(fieldName, input.checked);
       });
@@ -385,6 +375,11 @@ function renderFeatureFlags(flags) {
         lockedByGate: !parentOn,
       });
     }
+    // Extra app option keys to redact (#2843), nested under redact_secrets
+    // and dimmed while it is off.
+    if (fieldName === 'redact_secrets') {
+      renderAdvancedSubRows(targetBody, 'redact_keys', 'redact-sub', !f.value);
+    }
     // After the enable_filesystem_tools row, inject the custom-directories
     // editor (issue #1567). Dimmed when either the master beta is off or
     // filesystem tools itself is off. The list is component-owned and fetched
@@ -473,7 +468,8 @@ function renderSubFlagRows(flags, parentEl, subFieldNames, { cssClass, lockedByG
 
 // Shared renderer for non-bool sub-rows that live in ADVANCED_SETTINGS_FIELDS
 // but render nested under a feature toggle (code-mode numerics under
-// enable_code_mode, extra YAML write keys under enable_yaml_config_editing).
+// enable_code_mode, extra YAML write keys under enable_yaml_config_editing,
+// extra redacted app option keys under redact_secrets).
 // They save through commitAdvancedEdit rather than saveFeatureFlag, which is
 // why renderSubFlagRows (checkbox-only) cannot serve them.
 function renderAdvancedSubRows(parentEl, section, cssClass, lockedByGate) {
@@ -482,7 +478,7 @@ function renderAdvancedSubRows(parentEl, section, cssClass, lockedByGate) {
     const meta = localizeMeta('advanced', f.field, {});
     const row = document.createElement('div');
     row.className = 'feature-row ' + cssClass + (lockedByGate ? ' dimmed' : '');
-    const multiline = f.field === 'extra_yaml_write_keys';
+    const multiline = LIST_EDITOR_FIELDS.has(f.field);
     if (multiline) row.classList.add('list-editor');
 
     const info = document.createElement('div');

{ha_mcp_dev-9.0.0.dev3182 → ha_mcp_dev-9.0.0.dev3183}/src/ha_mcp/tools/tools_addons.py

@@ -42,11 +42,10 @@ from ..errors import (
 )
 from ..redaction import (
     collect_addon_secret_values,
-    redact_addon_options,
+    redact_addon_info,
     redaction_enabled,
     register_known_secret_values,
     sentinel_option_keys,
-    sentinel_replacement,
 )
 from ..utils.python_sandbox import (
     PythonSandboxError,
@@ -997,34 +996,9 @@ async def get_addon_info(client: HomeAssistantClient, slug: str) -> dict[str, An
     result: dict[str, Any] = {"success": True, "addon": addon}
 
     if redaction_enabled():
-        options = addon.get("options")
-        schema = addon.get("schema")
-        if isinstance(options, dict) and options:
-            if isinstance(schema, list) and schema:
-                register_known_secret_values(
-                    collect_addon_secret_values(options, schema)
-                )
-                result["addon"] = {
-                    **addon,
-                    "options": redact_addon_options(options, schema),
-                }
-            else:
-                # No readable schema (absent, malformed, or empty) — the
-                # password fields cannot be told apart, so fail closed like
-                # the integration surface does rather than passing raw
-                # options through.
-                result["addon"] = {
-                    **addon,
-                    "options": {
-                        key: sentinel_replacement(value)
-                        for key, value in options.items()
-                    },
-                }
-                result.setdefault("warnings", []).append(
-                    f"redact_secrets: no options schema readable for '{slug}' — "
-                    "every option value was redacted conservatively (the "
-                    "password fields cannot be told apart without the schema)"
-                )
+        result["addon"], warnings = redact_addon_info(addon, slug)
+        if warnings:
+            result["warnings"] = warnings
 
     # Extracted AFTER redaction so an app (add-on) that schema-marks log_level as
     # a password surfaces the sentinel here, never the live value.
@@ -3065,22 +3039,22 @@ class AddOnTools:
             merged_options = _merge_options(current_options, config_data["options"])
 
             # Both the live current options and the merged result are
-            # password-bearing; remember them for the global known-value
+            # secret-bearing; remember them for the global known-value
             # scrub (this path fetches info directly, bypassing
             # get_addon_info's harvesting). The merged copy carries any
-            # password the caller is submitting right now — without it a
+            # secret the caller is submitting right now — without it a
             # freshly written secret stays unknown to the scrub until some
             # later read harvests it.
-            if redaction_enabled() and isinstance(addon_info.get("schema"), list):
+            schema_ui: list | None = addon_info.get("schema")
+            if redaction_enabled() and isinstance(schema_ui, list):
                 register_known_secret_values(
-                    collect_addon_secret_values(current_options, addon_info["schema"])
-                    | collect_addon_secret_values(merged_options, addon_info["schema"])
+                    collect_addon_secret_values(current_options, schema_ui, slug)
+                    | collect_addon_secret_values(merged_options, schema_ui, slug)
                 )
 
             # Pre-write schema check: identify fields not in the app's schema.
             # Supervisor silently drops unknown fields on write; surfacing them
             # here lets the caller correct mistakes before any state is changed.
-            schema_ui: list | None = addon_info.get("schema")
             if schema_ui is not None:
                 allowed_keys = {item["name"] for item in schema_ui if "name" in item}
                 ignored_fields = [