mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 12:05:34 +08:00
## 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>
566 lines
21 KiB
Python
566 lines
21 KiB
Python
"""Code-memory MCP is selectable via --code-memory (default none; Serena is opt-in).
|
|
|
|
Covers the resolver precedence (selector > deprecated flags > default), the
|
|
graceful retirement of the removed ``tokensave`` option, the orchestrator
|
|
dispatch for each selection, and that --code-memory is exposed on the
|
|
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
|
|
import pytest
|
|
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)
|
|
return env
|
|
|
|
|
|
def test_default_is_none() -> None:
|
|
with patch.dict(os.environ, _clean_env(), clear=True):
|
|
assert wrap._resolve_code_memory({}) == wrap._CODE_MEMORY_NONE
|
|
|
|
|
|
def test_selector_env_wins() -> None:
|
|
for val in (wrap._CODE_MEMORY_SERENA, wrap._CODE_MEMORY_NONE):
|
|
with patch.dict(os.environ, {"HEADROOM_CODE_MEMORY": val}):
|
|
# selector beats any legacy flag
|
|
assert wrap._resolve_code_memory({"serena": True, "no_serena": True}) == val
|
|
|
|
|
|
def test_deprecated_flags_map_into_selector() -> None:
|
|
with patch.dict(os.environ, _clean_env(), clear=True):
|
|
assert wrap._resolve_code_memory({"serena": True}) == wrap._CODE_MEMORY_SERENA
|
|
# tokensave is retired: --no-tokensave is a no-op → default none
|
|
assert wrap._resolve_code_memory({"no_tokensave": True}) == wrap._CODE_MEMORY_NONE
|
|
# --no-serena means "no code memory" now that tokensave is gone
|
|
assert wrap._resolve_code_memory({"no_serena": True}) == wrap._CODE_MEMORY_NONE
|
|
# opt-out wins over opt-in when both legacy flags are given
|
|
assert (
|
|
wrap._resolve_code_memory({"serena": True, "no_serena": True}) == wrap._CODE_MEMORY_NONE
|
|
)
|
|
|
|
|
|
def test_retired_tokensave_selector_maps_to_serena() -> None:
|
|
# An explicit HEADROOM_CODE_MEMORY=tokensave (or --code-memory tokensave from
|
|
# an old script) degrades gracefully to Serena instead of erroring.
|
|
with patch.dict(os.environ, {"HEADROOM_CODE_MEMORY": "tokensave"}):
|
|
assert wrap._resolve_code_memory({}) == wrap._CODE_MEMORY_SERENA
|
|
|
|
|
|
def test_serena_dashboard_disabled_flips_existing_config(tmp_path, monkeypatch) -> None:
|
|
monkeypatch.setenv("HOME", str(tmp_path))
|
|
monkeypatch.setenv("USERPROFILE", str(tmp_path))
|
|
cfg = tmp_path / ".serena" / "serena_config.yml"
|
|
cfg.parent.mkdir(parents=True)
|
|
cfg.write_text(
|
|
"web_dashboard: true\nweb_dashboard_open_on_launch: true\ngui_log_window: false\n"
|
|
)
|
|
wrap._ensure_serena_dashboard_disabled()
|
|
text = cfg.read_text()
|
|
assert "web_dashboard_open_on_launch: false" in text
|
|
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).
|
|
|
|
This is the exact invariant, and it is the reason the outage happened.
|
|
Verified against Serena 1.6.2.dev0 ``serena/config/serena_config.py``: Serena
|
|
autogenerates a complete config only when the path does not exist; once any
|
|
file is there it validates instead, and a missing ``projects`` key is fatal
|
|
(``SerenaConfigError``). Headroom used to write a one-key bootstrap file,
|
|
which killed Serena's MCP handshake on every fresh install.
|
|
|
|
Asserting "we write nothing" is stronger than asserting which keys we write:
|
|
it stays correct even if Serena adds a new required key, whereas a test that
|
|
pins our own key list would go on passing while users broke again.
|
|
"""
|
|
monkeypatch.setenv("HOME", str(tmp_path))
|
|
monkeypatch.setenv("USERPROFILE", str(tmp_path))
|
|
|
|
wrap._ensure_serena_dashboard_disabled()
|
|
|
|
cfg = tmp_path / ".serena" / "serena_config.yml"
|
|
assert not cfg.exists(), "Headroom created a config Serena would have generated itself"
|
|
|
|
|
|
def test_serena_dashboard_disabled_repairs_config_missing_projects(tmp_path, monkeypatch) -> None:
|
|
"""Backfill ``projects`` into a config an older Headroom already wrote (#2674).
|
|
|
|
Users who ran an affected version have the single-key file on disk, so simply
|
|
not creating new bad files would leave them broken forever.
|
|
"""
|
|
import yaml
|
|
|
|
monkeypatch.setenv("HOME", str(tmp_path))
|
|
monkeypatch.setenv("USERPROFILE", str(tmp_path))
|
|
cfg = tmp_path / ".serena" / "serena_config.yml"
|
|
cfg.parent.mkdir(parents=True)
|
|
cfg.write_text("web_dashboard_open_on_launch: false\n")
|
|
|
|
wrap._ensure_serena_dashboard_disabled()
|
|
|
|
parsed = yaml.safe_load(cfg.read_text())
|
|
assert parsed["projects"] == []
|
|
assert parsed["web_dashboard_open_on_launch"] is False
|
|
|
|
|
|
def test_serena_dashboard_disabled_preserves_registered_projects(tmp_path, monkeypatch) -> None:
|
|
"""Never clobber Serena's real project registry — it is user data."""
|
|
import yaml
|
|
|
|
monkeypatch.setenv("HOME", str(tmp_path))
|
|
monkeypatch.setenv("USERPROFILE", str(tmp_path))
|
|
cfg = tmp_path / ".serena" / "serena_config.yml"
|
|
cfg.parent.mkdir(parents=True)
|
|
cfg.write_text(
|
|
"# my serena config\nprojects:\n - /home/me/work/api\n - /home/me/work/web\n"
|
|
"web_dashboard_open_on_launch: true\n"
|
|
)
|
|
|
|
wrap._ensure_serena_dashboard_disabled()
|
|
|
|
text = cfg.read_text()
|
|
parsed = yaml.safe_load(text)
|
|
assert parsed["projects"] == ["/home/me/work/api", "/home/me/work/web"]
|
|
assert parsed["web_dashboard_open_on_launch"] is False
|
|
assert "# my serena config" in text # comments preserved
|
|
assert text.count("projects:") == 1 # no duplicate key
|
|
|
|
|
|
def test_serena_dashboard_disabled_is_idempotent(tmp_path, monkeypatch) -> None:
|
|
monkeypatch.setenv("HOME", str(tmp_path))
|
|
monkeypatch.setenv("USERPROFILE", 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\n")
|
|
wrap._ensure_serena_dashboard_disabled()
|
|
first = cfg.read_text()
|
|
wrap._ensure_serena_dashboard_disabled()
|
|
assert cfg.read_text() == first
|
|
|
|
|
|
def test_serena_config_required_keys_match_serena_source() -> None:
|
|
"""Pin the assumption this fix rests on, against Serena's real source (#2674).
|
|
|
|
Skipped unless a Serena checkout is present. When it is, this proves the claim
|
|
the fix depends on — that ``projects`` is the *only* hard-required key and that
|
|
Serena bootstraps only a missing file — rather than trusting a bug report.
|
|
Set ``SERENA_SRC`` to a Serena source tree to enable it.
|
|
"""
|
|
import os
|
|
import re
|
|
from pathlib import Path
|
|
|
|
src = os.environ.get("SERENA_SRC", "")
|
|
if not src or not (Path(src) / "config" / "serena_config.py").is_file():
|
|
pytest.skip("set SERENA_SRC to a Serena source tree to run this check")
|
|
|
|
text = (Path(src) / "config" / "serena_config.py").read_text(encoding="utf-8")
|
|
# Serena bootstraps only when the file is absent — so we must not create one.
|
|
assert re.search(r"if not os\.path\.exists\(config_file_path\)", text)
|
|
# `projects` is the sole fatal omission; everything else has a default.
|
|
fatal = re.findall(r"raise SerenaConfigError\((.*?)\)", text, re.DOTALL)
|
|
projects_fatal = [f for f in fatal if "projects" in f]
|
|
assert projects_fatal, "Serena no longer rejects a missing `projects` key"
|
|
assert "get_value_or_default" in text, "Serena's default-filling path changed"
|
|
|
|
|
|
def test_invalid_env_raises() -> None:
|
|
with patch.dict(os.environ, {"HEADROOM_CODE_MEMORY": "bogus"}):
|
|
try:
|
|
wrap._resolve_code_memory({})
|
|
except click.ClickException:
|
|
pass
|
|
else: # pragma: no cover
|
|
raise AssertionError("invalid HEADROOM_CODE_MEMORY should raise ClickException")
|
|
|
|
|
|
def _dispatch_calls(selection: str, extra: dict | None = None) -> list[str]:
|
|
"""Run the orchestrator with a given selection, recording which setup/disable
|
|
helpers fire (all mocked)."""
|
|
calls: list[str] = []
|
|
env = _clean_env()
|
|
env["HEADROOM_CODE_MEMORY"] = selection
|
|
with (
|
|
patch.dict(os.environ, env, clear=True),
|
|
patch.object(wrap, "_setup_serena_mcp", lambda *a, **k: calls.append("serena")),
|
|
patch.object(
|
|
wrap, "_disable_tokensave_mcp", lambda *a, **k: calls.append("disable_tokensave")
|
|
),
|
|
patch.object(wrap, "_disable_serena_mcp", lambda *a, **k: calls.append("disable_serena")),
|
|
):
|
|
wrap._setup_coding_compressor(object(), serena_context="claude-code", **(extra or {}))
|
|
return calls
|
|
|
|
|
|
def test_orchestrator_dispatch() -> None:
|
|
# A legacy tokensave entry is always retired first, then the selection applies.
|
|
assert _dispatch_calls(wrap._CODE_MEMORY_SERENA) == ["disable_tokensave", "serena"]
|
|
assert set(_dispatch_calls(wrap._CODE_MEMORY_NONE)) == {"disable_tokensave", "disable_serena"}
|
|
|
|
|
|
def test_code_memory_option_present_only_on_code_memory_agents() -> None:
|
|
runner = CliRunner()
|
|
for tool in ("claude", "codex", "grok", "opencode"):
|
|
out = runner.invoke(wrap.wrap, [tool, "--help"]).output
|
|
assert "--code-memory" in out, f"--code-memory missing from `wrap {tool} --help`"
|
|
# aider does not register a code-memory MCP → no flag
|
|
out = runner.invoke(wrap.wrap, ["aider", "--help"]).output
|
|
assert "--code-memory" not in out
|