fix(wrap): match Serena's unset dashboard key instead of appending a duplicate (#4315)

## Description

`headroom wrap` calls `_ensure_serena_dashboard_disabled()`, which turns
off Serena's dashboard auto-open by editing
`web_dashboard_open_on_launch` in `~/.serena/serena_config.yml` in
place. The regex required a non-empty value (`:\s*\S+\s*$`), but
Serena's own template writes the key with **no value**:

```yaml
web_dashboard_open_on_launch:
```

That is valid YAML meaning "unset". The regex missed it, so Headroom
appended a second copy of the key at EOF. Serena loads this file with
ruamel.yaml in duplicate-key-strict mode, so the next startup dies while
constructing the config:

```text
ValueError: Error loading Serena configuration from ~/.serena/serena_config.yml: while constructing a mapping
found duplicate key "web_dashboard_open_on_launch" with value "False" (original value: "None")
  in "~/.serena/serena_config.yml", line 247, column 1

ruamel.yaml.constructor.DuplicateKeyError
```

MCP clients surface that as `Connection closed: MCP server process
exited with code 1`, and it is persistent: every launch fails until the
file is repaired by hand. This was hit in the field with Serena 2.1.0
installed by `headroom wrap opencode`.

The setting is now rewritten line-wise instead of by regex substitution,
which fixes three things:

1. An unset value is matched, so no duplicate is appended.
2. The first `#` on the line is the comment, including when it is flush
against the colon (`web_dashboard_open_on_launch:# note: reason`). It
becomes `...: false # note: reason` (boolean `False`, comment intact,
colons kept) instead of the string `"false note: reason"` or a second
copy of the key.
3. Redundant copies of the key at the root mapping's indent are dropped,
so a config an older Headroom already broke comes back valid instead of
staying broken.
4. The root indent is the shortest indent of a non-comment line,
ignoring `---`, `...`, and `%` directives. A root mapping indented as a
whole, including one under a document marker, is rewritten in place at
that indent; a deeper key (a nested mapping that reuses the name) is
left alone. A missing key is inserted before a trailing `...` so it
stays in the one document Serena loads. Trailing tokens that are not a
comment, such as `!!bool true`, are dropped so the value stays boolean
`False`.

No tracking issue; reported from the live failure described below.

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [ ] Code refactoring (no functional changes)

## Changes Made

- `headroom/cli/wrap.py`: `_ensure_serena_dashboard_disabled` rewrites
the setting line-wise at the root mapping's indent
(`_serena_root_indent`), which is column 0 for a normal file and the
shared indent when the whole mapping is indented. Document markers and
`%` directives are not mapping lines, so they do not pull that indent
back to column 0. A missing key is inserted before a trailing `...`.
`_serena_inline_comment` keeps the first `#` (a space is inserted when
it was glued to the colon or the value) and drops every other token. The
first root occurrence is kept and redundant root copies are dropped. A
deeper key is left alone. Docstring documents the ruamel failure this
prevents.
- `tests/test_wrap_code_memory.py`: regression tests for the unset key,
a comment with a colon, a `#` flush against the colon, a populated value
with a comment, an already-duplicated config, a uniformly indented root
mapping, an indented root under `---` and under `%YAML`, a missing key
before `...`, a nested key under both a column-0 root and an indented
root, and a YAML type tag. Each asserts the parsed value is boolean
`False`.

## Testing

- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [ ] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [x] Manual testing performed

Type checking was not run for this change; `ruff check` and `ruff format
--check` pass on both touched files.

### Test Output

```text
# headroom/cli/wrap.py reverted to the previous commit, new tests only
$ uv run pytest tests/test_wrap_code_memory.py -k "comment_on_unset_value or repairs_duplicate_keys" -q
FF                                                                       [100%]
E   AssertionError: assert 'web_dashboard_open_on_launch: false # note: leave unset for now' in
    '...web_dashboard_open_on_launch: false note: leave unset for now...'
E   AssertionError: duplicate key breaks Serena
E   assert 2 == 1
2 failed, 15 deselected in 0.30s

$ uv run pytest tests/test_wrap_code_memory.py -q
16 passed, 1 skipped in 0.24s

$ uv run ruff check headroom/cli/wrap.py tests/test_wrap_code_memory.py
All checks passed!

$ uv run ruff format --check headroom/cli/wrap.py tests/test_wrap_code_memory.py
2 files already formatted

# follow-up in 9949c4bc, including the flush-# and nested-key tests
$ .venv/bin/python -m pytest tests/test_wrap_code_memory.py -q
19 passed, 1 skipped in 0.35s

$ .venv/bin/ruff check headroom/cli/wrap.py tests/test_wrap_code_memory.py
All checks passed!

$ .venv/bin/ruff format --check headroom/cli/wrap.py tests/test_wrap_code_memory.py
2 files already formatted

# follow-up in e62338ab, indented root mapping
$ .venv/bin/python -m pytest tests/test_wrap_code_memory.py -q
21 passed, 1 skipped in 0.28s

$ .venv/bin/ruff check headroom/cli/wrap.py tests/test_wrap_code_memory.py
All checks passed!

$ .venv/bin/ruff format --check headroom/cli/wrap.py tests/test_wrap_code_memory.py
2 files already formatted

# follow-up in 8fb014f2, document markers. The three new tests fail on e62338ab.
$ .venv/bin/python -m pytest tests/test_wrap_code_memory.py -q
24 passed, 1 skipped in 0.40s

$ .venv/bin/ruff check headroom/cli/wrap.py tests/test_wrap_code_memory.py
All checks passed!

$ .venv/bin/ruff format --check headroom/cli/wrap.py tests/test_wrap_code_memory.py
2 files already formatted
```

## Real Behavior Proof

- Environment: macOS 26.6.2 arm64, Python 3.13.12, Serena 2.1.0 (`uvx
--from serena-agent`), headroom `main` at `fbf7bc32` plus this branch;
released Headroom 0.35.0 used for the "before" case; each case in its
own temp `$HOME`, so the real user config was never touched.
- Exact command / steps: run the old and patched
`_ensure_serena_dashboard_disabled` on temp homes, then load the results
with Serena's own loader and start the real MCP server (details below).
- Observed result: old code appends a duplicate and Serena refuses to
load; patched code keeps one key, preserves comments, and the MCP
handshake completes (output below).
- Not tested: Windows and Linux, and a fresh live Serena process for the
document-marker case. Nested keys, a uniformly indented root, a `---`
marker, a `%YAML` directive, and a trailing `...` are covered by the
unit tests and by running the helper on temp configs. Quoted values that
contain a `#` are not specially handled; the value is still rewritten to
a plain boolean.

Details:

- Steps: (1) write a minimal faithful slice of the config Serena 2.1.0
generates into `$HOME/.serena/serena_config.yml` for throwaway homes;
(2) run `_ensure_serena_dashboard_disabled` (0.35.0 for "before", this
branch for "after"); (3) load each file with `python3 -c "from
serena.config.serena_config import SerenaConfig;
SerenaConfig.from_config_file()"`; (4) start the real server with
`printf '' | uvx --from serena-agent serena start-mcp-server
--project-from-cwd --context agent --open-web-dashboard False`.
- Before: file ends with an appended `web_dashboard_open_on_launch:
false` (2 occurrences) and Serena's loader raises `ValueError: Error
loading Serena configuration ... while constructing a mapping` — the
reported crash.
- After, unset key with comment: input `web_dashboard_open_on_launch: #
note: leave unset for now` becomes `web_dashboard_open_on_launch: false
# note: leave unset for now`; Serena's loader prints `loaded OK;
web_dashboard_open_on_launch = False`; a second call is byte-identical.
- After, already-broken duplicate config: 2 occurrences collapse to 1
with the comment block and `projects` intact; Serena's loader prints
`loaded OK; web_dashboard_open_on_launch = False`; the MCP server prints
`Starting MCP server …`, `MCP server lifetime setup complete` and exits
0.

## Runtime Rollout Safety

- Rollout-managed feature(s): none
- Minimum rollout channel: n/a
- Stable/default behavior changed: no (same end state; only the
duplicate-key bug, comment corruption and blank-line churn are gone)
- Kill switch / disable path: `--no-serena` /
`HEADROOM_CODE_MEMORY=none` still skip Serena setup entirely
- Unsafe override required: no
- Qualification impact: none
- Rollback path: revert this commit; the edit is idempotent either way

## Review Readiness

- [x] I have performed a self-review
- [x] This PR is ready for human review

## Checklist

- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)

## Screenshots (if applicable)

N/A — config file behaviour only.

## Additional Notes

Documentation checkbox: only the function docstring changed; there is no
user-facing docs page describing this internal line edit. The `mypy` box
is unchecked because it was not run. Duplicate repair keeps the first
occurrence at the root indent and its comment; comments attached to a
dropped copy are not merged. A key deeper than the root indent is a
nested mapping and is left as written. `---`, `...`, and `%` directives
are not part of that indent.


### Maintainer current-main requalification

Exact head `66ad70f02bc4994b6002e2ec2f766e8dd64fa7ae`, upstream main
`c01cf07d943d816cfd9d97e6838ed4e38f1ff9a4`.

Requalified against upstream main
c01cf07d94 after a clean mechanical merge.
Maintainer test-only adjustment isolates Path.home() to tmp_path on
Windows and POSIX; original tests set HOME, which Windows Path.home()
ignores. Before that fixture correction the local run had 15
fixture-path failures; after correction 24 tests pass and one optional
real-Serena test skips because SERENA_SRC is unavailable. Ruff
lint/format and main-relative whitespace checks pass. Contributor
YAML-rewrite logic is unchanged.

The existing document-terminator finding still reproduces through the
actual combined-branch helper in an isolated temporary home: valid
`---\nprojects: []\n... # end of config\n` receives the new setting
after the terminator and becomes ParserError. A bare terminator followed
by a comment-only line also reproduces. Please recognize valid end
markers with trailing whitespace/comments and preserve additions inside
the document even when trailing comments follow it. Cover parsing and
idempotence for both cases. The ordinary unset-key/comment/duplicate-key
and indented-root improvements remain acknowledged; the request concerns
incomplete handling in the PR's document-marker support, not inherited
pipeline failures.

Local mocked-home config probes and current-main native DLL for Python
test startup only; no fresh real Serena, inference or branch-native
build claimed. Maintainers handle hosted checks; no contributor CI
action requested. Nothing merged.


Exact-head hosted checks are being handled by maintainers. Existing
correctness/qualification holds remain; nothing merged.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: JerrettDavis <mxjerrett@gmail.com>
This commit is contained in:
Rehan Ahmed
2026-11-09 23:09:09 -06:00
committed by GitHub
co-authored by Cursor JerrettDavis
parent dcd03b9b4c
commit 1da8930ab4
2 changed files with 465 additions and 7 deletions
+119 -7
View File
@@ -2360,6 +2360,57 @@ def _setup_headroom_mcp(
click.echo(line)
def _serena_inline_comment(rest: str) -> str:
"""Return the inline comment to keep when rewriting a Serena setting.
``rest`` is everything after the colon. The first ``#`` starts the comment,
including when it sits flush against the colon or the old value: this
setting is always rewritten to ``false``, so a ``#`` that strict YAML would
treat as part of the scalar is kept as a comment instead. Whitespace that
already separates the ``#`` is preserved; a glued ``#`` gets one inserted
space. Every other token, such as a YAML type tag, is discarded with the
old value.
"""
hash_at = rest.find("#")
if hash_at < 0:
return ""
prefix, body = rest[:hash_at], rest[hash_at:]
if prefix.strip(" \t") == "":
return prefix + body if prefix else " " + body
if prefix[-1] in " \t":
return prefix[len(prefix.rstrip(" \t")) :] + body
return " " + body
# A document marker or directive is YAML syntax outside the mapping. It is
# only a marker when it starts at column 0; an indented ``---`` inside a
# block scalar is content.
_YAML_STRUCTURE_LINE = re.compile(r"^(?:---|\.\.\.)(?:[ \t]|$)|^%")
def _serena_root_indent(text: str) -> str:
"""Return the indentation of the root mapping.
YAML allows every root key to share an indent, so column 0 is not the
test. The root indent is the shortest leading whitespace on a non-empty,
non-comment line. Document markers (``---``, ``...``) and ``%`` directives
are skipped: they are YAML syntax outside the mapping, and counting them
would treat an indented root as column 0. A deeper line belongs to a
nested block.
"""
root: str | None = None
for line in text.splitlines():
if _YAML_STRUCTURE_LINE.match(line):
continue
stripped = line.lstrip(" \t")
if not stripped or stripped.startswith("#"):
continue
indent = line[: len(line) - len(stripped)]
if root is None or len(indent) < len(root):
root = indent
return root or ""
def _ensure_serena_dashboard_disabled(*, verbose: bool = False) -> None:
"""Disable Serena's browser dashboard auto-open in ``~/.serena/serena_config.yml``.
@@ -2393,6 +2444,21 @@ def _ensure_serena_dashboard_disabled(*, verbose: bool = False) -> None:
``projects: []`` is still backfilled into an *existing* file, to repair
configs an affected Headroom version already wrote.
Serena's own template writes this key with *no* value
(``web_dashboard_open_on_launch:``), which is valid YAML meaning "unset".
The line edit therefore has to match an empty value too: treating it as
"key absent" appended a second copy of the key, and Serena loads this file
with ruamel in duplicate-key-strict mode, so every later startup died with
``DuplicateKeyError`` before the MCP handshake ("Connection closed").
The edit only touches the key at the root mapping's indent. YAML allows
that mapping to be indented as a whole, so column 0 is not the test: the
root indent is the shortest indent of a non-comment line, ignoring
document markers and directives. A deeper occurrence belongs to a nested
mapping (e.g. an ``extension:`` block that reuses the name) and is left
alone — both when rewriting the value and when dropping duplicates, so
it can never be mistaken for, or merged with, Serena's real setting.
"""
import re
@@ -2413,19 +2479,65 @@ def _ensure_serena_dashboard_disabled(*, verbose: bool = False) -> None:
new = text
appended: list[str] = []
dashboard = re.compile(rf"^(\s*){re.escape(key)}:\s*\S+\s*$", re.MULTILINE)
if dashboard.search(new):
new = dashboard.sub(rf"\g<1>{key}: false", new)
# Serena's template writes this key with no value, and Headroom used to
# append a second copy of it in that case. Rewrite the value in place
# (keeping any inline comment) and drop redundant copies, so configs an
# older Headroom already broke are repaired rather than re-broken.
#
# Match the key only at the root mapping's indent, and keep that indent
# when rewriting or appending. A root mapping indented as a whole is still
# the top-level mapping; appending a column-0 key beside it makes the file
# unparsable. A deeper occurrence is a different mapping.
#
# The pattern only recognizes the key line. ``_serena_inline_comment``
# decides what to keep from the remainder, so a ``#`` flush against the
# colon still matches and is preserved instead of leaving the line in
# place and appending a second copy of the key.
indent = _serena_root_indent(text)
dashboard = re.compile(rf"^{re.escape(indent)}{re.escape(key)}:[ \t]*(.*)$")
lines: list[str] = []
rewritten = False
for line in text.splitlines(keepends=True):
body = line.rstrip("\r\n")
match = dashboard.match(body)
if match is None:
lines.append(line)
continue
if rewritten:
continue
rewritten = True
comment = _serena_inline_comment(match.group(1))
ending = "\n" if line.endswith(("\n", "\r")) else ""
lines.append(f"{indent}{key}: false{comment}{ending}")
if rewritten:
new = "".join(lines)
else:
appended.append(f"{key}: false")
appended.append(f"{indent}{key}: false")
# Repair a config left by an affected Headroom version (see #2674 above).
if not re.search(r"^\s*projects\s*:", new, re.MULTILINE):
appended.append("projects: []")
appended.append(f"{indent}projects: []")
if appended:
body = new.rstrip("\n")
new = (f"{body}\n" if body.strip() else "") + "\n".join(appended) + "\n"
addition = "\n".join(appended) + "\n"
lines = new.splitlines(keepends=True)
end_at: int | None = None
for index in range(len(lines) - 1, -1, -1):
if not lines[index].strip(" \t\r\n"):
continue
if lines[index].rstrip("\r\n") == "...":
end_at = index
break
if end_at is None:
body = new.rstrip("\n")
new = (f"{body}\n" if body.strip() else "") + addition
else:
# A key after ``...`` starts a second document. Keep the addition
# inside the one Serena loads.
prefix = "".join(lines[:end_at])
if prefix and not prefix.endswith("\n"):
prefix += "\n"
new = prefix + addition + "".join(lines[end_at:])
if new == text:
return
+346
View File
@@ -9,6 +9,7 @@ code-memory-capable subcommands (claude/codex/grok/opencode) but not others.
from __future__ import annotations
import os
from pathlib import Path
from unittest.mock import patch
import click
@@ -18,6 +19,12 @@ from click.testing import CliRunner
from headroom.cli import wrap
@pytest.fixture(autouse=True)
def isolated_home(tmp_path, monkeypatch):
"""Keep config edits in the test home on Windows as well as POSIX."""
monkeypatch.setattr(Path, "home", classmethod(lambda cls: tmp_path))
def _clean_env() -> dict[str, str]:
env = dict(os.environ)
env.pop("HEADROOM_CODE_MEMORY", None)
@@ -70,6 +77,345 @@ def test_serena_dashboard_disabled_flips_existing_config(tmp_path, monkeypatch)
assert "web_dashboard: true" in text # other keys preserved
def test_serena_dashboard_disabled_handles_unset_value(tmp_path, monkeypatch) -> None:
"""Serena's template ships ``web_dashboard_open_on_launch:`` with no value.
Requiring a value in the regex treated the key as absent and appended a
second copy of it. Serena loads this file with ruamel in duplicate-key-strict
mode, so the duplicate made every later startup die with ``DuplicateKeyError``
before the MCP handshake ("Connection closed").
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text(
"web_dashboard: true\n"
"web_dashboard_open_on_launch:\n"
"\n"
"gui_log_window: false\n"
"projects:\n- /home/me/work/api\n"
)
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert text.count("web_dashboard_open_on_launch") == 1, "duplicate key breaks Serena"
assert "web_dashboard_open_on_launch: false" in text
assert "\n\ngui_log_window: false\n" in text, "blank line after the key must survive"
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["web_dashboard"] is True
assert parsed["projects"] == ["/home/me/work/api"]
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_keeps_inline_comment(tmp_path, monkeypatch) -> None:
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text("projects: []\nweb_dashboard_open_on_launch: true # keep this\n")
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert "web_dashboard_open_on_launch: false # keep this" in text
assert text.count("web_dashboard_open_on_launch") == 1
def test_serena_dashboard_disabled_keeps_comment_on_unset_value(tmp_path, monkeypatch) -> None:
"""A comment right after the colon must stay a comment, not become the value.
``web_dashboard_open_on_launch: # note`` used to turn into
``...: false note``, which YAML reads as the string ``"false note"`` rather
than the boolean ``False``.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text(
"projects: []\n"
"web_dashboard_open_on_launch: # note: leave unset for now\n"
"gui_log_window: false\n"
)
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert "web_dashboard_open_on_launch: false # note: leave unset for now" in text
assert yaml.safe_load(text)["web_dashboard_open_on_launch"] is False
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_keeps_comment_glued_to_colon(tmp_path, monkeypatch) -> None:
"""A ``#`` with no space after the colon is still the comment.
``web_dashboard_open_on_launch:# note`` does not match a pattern that
requires the value token to be non-comment text, so the line used to be
left in place and a second copy of the key was appended.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text(
"projects: []\n"
"web_dashboard_open_on_launch:# note: leave unset for now\n"
"gui_log_window: false\n"
)
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert text.count("web_dashboard_open_on_launch") == 1
assert "web_dashboard_open_on_launch: false # note: leave unset for now" in text
assert yaml.safe_load(text)["web_dashboard_open_on_launch"] is False
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_repairs_duplicate_keys(tmp_path, monkeypatch) -> None:
"""Configs already broken by an older Headroom must come back valid.
A duplicate top-level key makes Serena's ruamel loader raise, so rewriting
both copies in place would leave the MCP server unable to start.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text(
"web_dashboard: true\n"
"web_dashboard_open_on_launch:\n"
"\n"
"# other settings\n"
"gui_log_window: false\n"
"projects:\n- /home/me/work/api\n"
"web_dashboard_open_on_launch: false\n"
)
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert text.count("web_dashboard_open_on_launch") == 1, "duplicate key breaks Serena"
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["projects"] == ["/home/me/work/api"]
assert parsed["web_dashboard"] is True
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_keeps_indented_root_mapping(tmp_path, monkeypatch) -> None:
"""A root mapping indented as a whole is still the top-level mapping.
Rewriting only a column-0 key misses this setting and appends another
at column 0. YAML then rejects the file: expected a document start, but
found a block mapping start.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text(" projects: []\n web_dashboard_open_on_launch: true\n")
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert " web_dashboard_open_on_launch: false\n" in text
assert "\nweb_dashboard_open_on_launch:" not in text
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["projects"] == []
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_keeps_indented_root_after_document_marker(
tmp_path, monkeypatch
) -> None:
"""A ``---`` document marker is not a mapping line.
Counting it as column 0 makes the root indent empty, so the indented
setting is left in place and a column-0 key is appended. YAML then
rejects the file.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text("---\n projects: []\n web_dashboard_open_on_launch: true\n")
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert text.startswith("---\n")
assert " web_dashboard_open_on_launch: false\n" in text
assert "\nweb_dashboard_open_on_launch:" not in text
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["projects"] == []
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_skips_yaml_directive(tmp_path, monkeypatch) -> None:
"""A ``%YAML`` directive is outside the mapping and must not set the indent."""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text("%YAML 1.2\n---\n projects: []\n web_dashboard_open_on_launch: true\n")
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert text.startswith("%YAML 1.2\n---\n")
assert " web_dashboard_open_on_launch: false\n" in text
assert "\nweb_dashboard_open_on_launch:" not in text
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["projects"] == []
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_appends_inside_document_end_marker(
tmp_path, monkeypatch
) -> None:
"""A missing key is inserted before a trailing ``...``, not after it.
A key written after the document end marker starts a second document.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text("---\n projects: []\n...\n")
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert text.index(" web_dashboard_open_on_launch: false\n") < text.index("...\n")
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["projects"] == []
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_ignores_nested_key(tmp_path, monkeypatch) -> None:
"""A key nested under another mapping is not Serena's setting.
The root key in this file is at column 0. The indented copy belongs to
``extension`` and must not be rewritten or dropped as a duplicate.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text(
"extension:\n"
" web_dashboard_open_on_launch: true\n"
"web_dashboard_open_on_launch: true\n"
"projects: []\n"
)
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert " web_dashboard_open_on_launch: true\n" in text, "nested key must be left untouched"
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["extension"]["web_dashboard_open_on_launch"] is True
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_ignores_nested_key_under_indented_root(
tmp_path, monkeypatch
) -> None:
"""A deeper key stays nested when the root mapping itself is indented."""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text(
" extension:\n"
" web_dashboard_open_on_launch: true\n"
" web_dashboard_open_on_launch: true\n"
" projects: []\n"
)
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert " web_dashboard_open_on_launch: true\n" in text
assert " web_dashboard_open_on_launch: false\n" in text
parsed = yaml.safe_load(text)
assert parsed["web_dashboard_open_on_launch"] is False
assert parsed["extension"]["web_dashboard_open_on_launch"] is True
first = text
wrap._ensure_serena_dashboard_disabled()
assert cfg.read_text() == first
def test_serena_dashboard_disabled_drops_non_comment_trailing_content(
tmp_path, monkeypatch
) -> None:
"""Trailing content that is not a comment must not survive the rewrite.
E.g. an explicit YAML type tag (``!!bool true``) has a value token plus a
second, space-separated token. Preserving that second token as if it were
a comment turns the rewritten line into ``false true``, which YAML parses
as the string ``"false true"`` instead of the boolean ``False``.
"""
import yaml
monkeypatch.setenv("HOME", str(tmp_path))
cfg = tmp_path / ".serena" / "serena_config.yml"
cfg.parent.mkdir(parents=True)
cfg.write_text("projects: []\nweb_dashboard_open_on_launch: !!bool true\n")
wrap._ensure_serena_dashboard_disabled()
text = cfg.read_text()
assert "web_dashboard_open_on_launch: false\n" in text
assert yaml.safe_load(text)["web_dashboard_open_on_launch"] is False
def test_serena_config_is_never_created_by_headroom(tmp_path, monkeypatch) -> None:
"""Headroom must NOT pre-empt Serena's own config bootstrap (#2674).