mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 15:10:00 +08:00
## Description
`headroom learn` aborts with a traceback when `~/.claude/projects/`
contains a project directory the user cannot traverse. Field report
(Headroom desktop 0.9.18, macOS):
```text
File ".../headroom/learn/plugins/claude.py", line 91, in discover_projects
memory_file = memory_dir / "MEMORY.md" if memory_dir.exists() else None
PermissionError: [Errno 13] Permission denied: '~/.claude/projects/-/memory'
```
The `-` entry is the project dir for `/`, left behind by a session
Claude Code ran as root. The entry itself stats fine (its parent is the
user's own `projects/`), so `entry.is_dir()` passes, but nothing under
it is traversable and the first stat below it raises. #2446 guarded the
decoded project path and `CLAUDE.md` probes with `path_exists` for
exactly this reason; the `memory` probe two lines later was still a bare
`Path.exists()`.
This PR routes the two memory probes through the same `path_exists`
helper, so an unreadable project dir contributes no memory file and
discovery continues, instead of taking the whole scan down.
Closes #
## 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/learn/plugins/claude.py`: `discover_projects` probes
`<entry>/memory` and `<entry>/memory/MEMORY.md` with `_path_exists`
instead of `Path.exists()`, matching the project-path and `CLAUDE.md`
probes above it.
- `tests/test_learn/test_plugin_permission_errors.py`:
`test_claude_discover_projects_survives_unreadable_memory_dir` builds a
`projects/-/` entry whose `memory` subtree raises `PermissionError` on
stat and asserts discovery still returns the project with
`memory_file=None`.
## Testing
- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [ ] Type checking passes (`mypy headroom`)
- [x] New tests added for new functionality
- [ ] Manual testing performed
### Test Output
```text
$ uv run --frozen --extra dev pytest tests/test_learn/test_plugin_permission_errors.py -q
collected 6 items
tests/test_learn/test_plugin_permission_errors.py ...... [100%]
6 passed in 0.75s
# With the fix reverted (git show HEAD~1:headroom/learn/plugins/claude.py), the new test fails:
E PermissionError: [Errno 13] Permission denied: '.../projects/-/memory'
1 failed, 5 passed in 0.26s
$ uvx ruff check headroom/learn/plugins/claude.py tests/test_learn/test_plugin_permission_errors.py
All checks passed!
$ uvx ruff format --check headroom/learn/plugins/claude.py tests/test_learn/test_plugin_permission_errors.py
2 files already formatted
```
## Real Behavior Proof
- Environment: macOS 15, Python 3.12, worktree of `main` at 94206e26
(0.38.0)
- Exact command / steps: ran the new regression test against the fix and
against the pre-fix `claude.py`; the field traceback above is the
verbatim stderr from a Headroom desktop 0.9.18 install (Sentry RUST-HJ),
where `~/.claude/projects/-/` is a root-owned project directory.
- Observed result: pre-fix the test reproduces the field traceback
(`PermissionError ... /projects/-/memory` from `discover_projects`);
post-fix discovery returns the project with `memory_file=None` and the
remaining 5 permission tests still pass.
- Not tested: a live `headroom learn` run against a real root-owned
project dir on this machine (none present); mypy over the full package.
## Runtime Rollout Safety
- Rollout-managed feature(s): none
- Minimum rollout channel: n/a
- Stable/default behavior changed: no; an unreadable memory dir is now
treated as absent instead of crashing `learn`
- Kill switch / disable path: none needed; the change only widens an
existing `OSError`-to-absent guard to two more probes
- Unsafe override required: no
- Qualification impact: none
- Rollback path: revert this PR
## 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
- [ ] 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
## Additional Notes
Documentation and mypy items are N/A: no user-facing behavior beyond
"learn no longer crashes", and the touched lines carry no new
annotations. Same class of fix as #2446 (claude project-path probes) and
#2522 (gemini/grok plugins); this is the last bare `Path.exists()` on a
path under a foreign-owned project entry in the claude plugin.
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
Co-authored-by: JD Davis <mxjerrett@gmail.com>
151 lines
5.2 KiB
Python
151 lines
5.2 KiB
Python
"""learn plugins must not crash when a session-derived path can't be stat'd.
|
|
|
|
Session files record project paths written on other machines / by other users.
|
|
``Path.exists()`` calls ``os.stat``, which raises ``PermissionError`` (not
|
|
``False``) when a parent directory isn't stat-able, and unhandled that aborts
|
|
the whole ``learn`` command (issue #2443). The claude plugin already guards
|
|
this; the gemini and grok plugins share the same shape and must too.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from headroom.learn.plugins._paths import path_exists
|
|
|
|
|
|
class _BoomPath(type(Path())): # type: ignore[misc]
|
|
"""A Path whose ``exists()`` raises PermissionError, like a restricted stat."""
|
|
|
|
def exists(self) -> bool: # noqa: D401
|
|
raise PermissionError(13, "Permission denied", str(self))
|
|
|
|
|
|
def test_path_exists_swallows_permission_error() -> None:
|
|
assert path_exists(_BoomPath("/home/other/project")) is False
|
|
|
|
|
|
def test_path_exists_true_for_real_path(tmp_path: Path) -> None:
|
|
assert path_exists(tmp_path) is True
|
|
|
|
|
|
def test_gemini_detect_project_path_survives_permission_error(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
from headroom.learn.plugins.gemini import GeminiPlugin
|
|
|
|
session = tmp_path / "session-1.json"
|
|
session.write_text(json.dumps({"projectPath": "/restricted/project"}), encoding="utf-8")
|
|
|
|
# os.stat on the recorded path raises PermissionError for a restricted parent.
|
|
def _boom(self: Path) -> bool:
|
|
raise PermissionError(13, "Permission denied", str(self))
|
|
|
|
monkeypatch.setattr(Path, "exists", _boom)
|
|
|
|
plugin = GeminiPlugin(gemini_dir=tmp_path)
|
|
# Must treat the unreadable path as absent, not raise.
|
|
assert plugin._detect_project_path(session) is None
|
|
|
|
|
|
def test_grok_discover_projects_survives_permission_error(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
from headroom.learn.plugins.grok import GrokPlugin
|
|
|
|
workspace = tmp_path / "sessions" / "%2Fhome%2Fu%2Fproj"
|
|
(workspace / "s1").mkdir(parents=True)
|
|
(workspace / "s1" / "updates.jsonl").write_text("{}\n", encoding="utf-8")
|
|
|
|
real_exists = Path.exists
|
|
|
|
def _boom_for_context_files(self: Path) -> bool:
|
|
# Only the GROK.md / AGENTS.md probes under the decoded project path blow
|
|
# up; the real session dirs still resolve so discovery reaches them.
|
|
if self.name in {"GROK.md", "AGENTS.md"}:
|
|
raise PermissionError(13, "Permission denied", str(self))
|
|
return real_exists(self)
|
|
|
|
monkeypatch.setattr(Path, "exists", _boom_for_context_files)
|
|
|
|
plugin = GrokPlugin(grok_dir=tmp_path)
|
|
projects = plugin.discover_projects()
|
|
# Discovery completes; the unreadable context file is simply treated as absent.
|
|
assert len(projects) == 1
|
|
assert projects[0].context_file is None
|
|
|
|
|
|
def test_opencode_discover_projects_survives_permission_error(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
import sqlite3
|
|
|
|
from headroom.learn.plugins.opencode import OpenCodePlugin
|
|
|
|
db_path = tmp_path / "opencode.db"
|
|
conn = sqlite3.connect(db_path)
|
|
try:
|
|
conn.executescript(
|
|
"""
|
|
CREATE TABLE project (id TEXT PRIMARY KEY, name TEXT, worktree TEXT);
|
|
CREATE TABLE session (id TEXT PRIMARY KEY, project_id TEXT, time_created INTEGER);
|
|
"""
|
|
)
|
|
conn.execute(
|
|
"INSERT INTO project (id, name, worktree) VALUES (?, ?, ?)",
|
|
("p1", "Proj", "/restricted/worktree"),
|
|
)
|
|
conn.execute(
|
|
"INSERT INTO session (id, project_id, time_created) VALUES (?, ?, ?)",
|
|
("s1", "p1", 1_700_000_000_000),
|
|
)
|
|
conn.commit()
|
|
finally:
|
|
conn.close()
|
|
|
|
# The recorded worktree is behind a restricted parent: the AGENTS.md probe
|
|
# stats it. Only that probe blows up so the DB open still works.
|
|
real_exists = Path.exists
|
|
|
|
def _boom(self: Path) -> bool:
|
|
if self.name == "AGENTS.md":
|
|
raise PermissionError(13, "Permission denied", str(self))
|
|
return real_exists(self)
|
|
|
|
monkeypatch.setattr(Path, "exists", _boom)
|
|
|
|
plugin = OpenCodePlugin(db_path=db_path)
|
|
projects = plugin.discover_projects()
|
|
assert len(projects) == 1
|
|
assert projects[0].context_file is None
|
|
|
|
|
|
def test_claude_discover_projects_survives_unreadable_memory_dir(
|
|
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
from headroom.learn.plugins.claude import ClaudeCodePlugin
|
|
|
|
# A project dir left behind by a root-run session: the entry itself stats
|
|
# (its parent is ours) but nothing under it is traversable.
|
|
projects_dir = tmp_path / "projects"
|
|
entry = projects_dir / "-"
|
|
entry.mkdir(parents=True)
|
|
(entry / "session.jsonl").write_text("{}\n", encoding="utf-8")
|
|
|
|
real_exists = Path.exists
|
|
|
|
def _boom_under_entry(self: Path) -> bool:
|
|
if self.name == "memory" or self.parent.name == "memory":
|
|
raise PermissionError(13, "Permission denied", str(self))
|
|
return real_exists(self)
|
|
|
|
monkeypatch.setattr(Path, "exists", _boom_under_entry)
|
|
|
|
plugin = ClaudeCodePlugin(claude_dir=tmp_path)
|
|
projects = plugin.discover_projects()
|
|
assert [p.data_path for p in projects] == [entry]
|
|
assert projects[0].memory_file is None
|