Files
openworker/tests/test_protected_paths.py
Devika Verma 931a025b8d fix(reviewer): settings changes outside the folders ask the user in Auto-Approve
Round-2 F-5, second half: with the session model as reviewer,
Auto-Approve allowed `git config --global user.name tester` without a
card. The protected-file floor lets plain git keys through and ignores
--global, and nothing in code covered other user-level settings, so the
verdict was the model's alone.

Now, in Auto-Approve, a shell command that changes the user's settings
outside the working folders goes to a person, not the reviewer:
`git config --global|--system` writes, npm / pnpm / yarn / pip config
writes (not npm/pnpm `--location project` or pip `--site`), setx, .NET
SetEnvironmentVariable for User or Machine, registry writes, and writes
to shell profiles or user-level config files (~/.bashrc, $PROFILE,
~/.gitconfig) that lie outside every folder. Inline shells (`bash -c`,
`powershell -Command`, `cmd /c`) are read too. Reading settings,
repo-local git config and sourcing a profile are unchanged, as are
Interactive, Custom, full access, the user's own command allowlist and
an approved plan step for the exact command.

Eval corpora: gate-081 now records human_only (its secure answer);
review-047 and review-222 are tagged settings-floor and left out of the
score; legacy danger-029/030 join the shadow-eval exact list.
2026-11-05 15:14:50 +05:30

516 lines
20 KiB
Python

"""In-project files that run later, and OpenWorker's own settings, are matched regardless
of letter case where the file system ignores case (OPE-231).
Windows and macOS (by default) treat `.GIT/hooks` and `.git/hooks` as the same folder,
but `Path.resolve()` only restores the on-disk case for parts that already exist. A
target that doesn't exist yet keeps whatever case the agent typed, so the string match
has to fold case itself."""
from __future__ import annotations
import sys
from pathlib import Path
import pytest
from coworker import permissions
from coworker.permissions import Mode, PermissionEngine, _is_protected_in_project
_MARKER_TARGETS = [
".git/hooks/pre-commit",
".github/workflows/ci.yml",
".gitlab-ci.yml",
".vscode/tasks.json",
".coworker/config.toml",
# OPE-231: run by a build backend, env tool, git or a hook manager without being named
"setup.py",
".envrc",
".gitattributes",
".pre-commit-config.yaml",
"tox.ini",
".devcontainer/devcontainer.json",
".husky/pre-push",
".circleci/config.yml",
# read into every session's system prompt (coworker/project.py)
"AGENTS.md",
]
def _variants(path: str) -> list[str]:
return [path, path.upper(), "".join(c.upper() if i % 2 else c for i, c in enumerate(path))]
def _gate(tmp_path: Path, mode: Mode = Mode.AUTO_APPROVE) -> PermissionEngine:
return PermissionEngine(workspace_root=tmp_path, mode=mode)
@pytest.fixture
def case_insensitive(monkeypatch):
monkeypatch.setattr(permissions, "_case_insensitive_fs", lambda: True)
@pytest.fixture
def case_sensitive(monkeypatch):
monkeypatch.setattr(permissions, "_case_insensitive_fs", lambda: False)
@pytest.mark.parametrize("target", _MARKER_TARGETS)
def test_every_protected_target_is_human_only(tmp_path, target):
d = _gate(tmp_path).evaluate("write_file", {"path": target, "content": "x"})
assert not d.allowed and d.needs_user and d.human_only
@pytest.mark.parametrize("target", _MARKER_TARGETS)
def test_any_letter_case_is_protected_on_case_insensitive_file_systems(tmp_path, case_insensitive, target):
# The targets don't exist on disk, which is exactly when resolve() can't fix the case.
for variant in _variants(target):
d = _gate(tmp_path).evaluate("write_file", {"path": variant, "content": "x"})
assert d.human_only, variant
def test_existing_protected_folder_with_different_case_is_protected(tmp_path, case_insensitive):
(tmp_path / ".git" / "hooks").mkdir(parents=True)
d = _gate(tmp_path).evaluate("write_file", {"path": ".GIT/Hooks/pre-commit", "content": "x"})
assert d.human_only
def test_case_sensitive_file_systems_keep_exact_matching(tmp_path, case_sensitive):
# On Linux `.GIT/hooks` is a different folder that git never runs, so it is an
# ordinary write: no extra card.
d = _gate(tmp_path).evaluate("write_file", {"path": ".GIT/hooks/pre-commit", "content": "x"})
assert not d.human_only
d = _gate(tmp_path).evaluate("write_file", {"path": ".git/hooks/pre-commit", "content": "x"})
assert d.human_only
@pytest.mark.parametrize(
"path",
["src/package.json.bak", "docs/setup.py.txt", "notes/my-pyproject.toml", "README.md", "src/app.py"],
)
def test_lookalike_names_are_ordinary_writes(tmp_path, case_insensitive, path):
d = _gate(tmp_path).evaluate("write_file", {"path": path, "content": "x"})
assert not d.human_only
@pytest.mark.parametrize(
"path", ["package.json", "packages/web/package.json", "pyproject.toml", "setup.cfg"]
)
def test_package_manifests_stay_with_the_reviewer(tmp_path, case_insensitive, path):
# Users edit these constantly (versions, dependencies), and the reviewer sees the
# content, so a version bump the user asked for runs without a card while a new
# install script can still be caught. Not human-only by design (OPE-231).
d = _gate(tmp_path).evaluate("replace_in_file", {"path": path, "old": "1.4.1", "new": "1.4.2"})
assert not d.allowed and d.needs_user and not d.human_only
def test_nested_setup_py_is_protected(tmp_path):
d = _gate(tmp_path).evaluate("write_file", {"path": "packages/core/setup.py", "content": "x"})
assert d.human_only
def test_patch_touching_a_protected_file_in_another_case_is_protected(tmp_path, case_insensitive):
patch = "*** Begin Patch\n*** Add File: .Husky/pre-commit\n+echo hi\n*** End Patch"
d = _gate(tmp_path).evaluate("apply_patch", {"patch": patch})
assert d.human_only
@pytest.mark.parametrize("mode", [Mode.INTERACTIVE, Mode.AUTO_APPROVE, Mode.BYPASS_APPROVALS])
def test_protection_holds_in_every_asking_mode(tmp_path, case_insensitive, mode):
d = _gate(tmp_path, mode).evaluate("write_file", {"path": ".ENVRC", "content": "x"})
assert not d.allowed and d.human_only
def test_dangerous_mode_still_clears_it_and_says_which_floor(tmp_path, case_insensitive):
d = _gate(tmp_path, Mode.DANGEROUSLY_BYPASS_APPROVALS).evaluate(
"write_file", {"path": ".GITHUB/workflows/ci.yml", "content": "x"}
)
assert d.allowed and "runs automatically later" in d.reason
def test_matcher_folds_case_only_when_asked(case_insensitive):
assert _is_protected_in_project(Path("/w/.GITLAB-CI.YML"))
assert _is_protected_in_project(Path("/w/.CoWorker/policy.toml"))
def test_matcher_is_exact_on_case_sensitive_systems(case_sensitive):
assert not _is_protected_in_project(Path("/w/.GITLAB-CI.YML"))
assert _is_protected_in_project(Path("/w/.gitlab-ci.yml"))
def test_own_settings_write_is_refused_in_any_case(tmp_path, monkeypatch, case_insensitive):
# OpenWorker's own settings live outside the project; when a root does contain them,
# a write must be refused whatever case the path is written in.
state = tmp_path / "state"
state.mkdir()
settings = state / "config.toml" # does not exist yet
monkeypatch.setattr(permissions, "protected_paths", lambda: [settings])
gate = PermissionEngine(workspace_root=tmp_path, mode=Mode.AUTO_APPROVE)
d = gate.evaluate("write_file", {"path": "STATE/CONFIG.TOML", "content": "x"})
assert not d.allowed and not d.needs_user
assert "OpenWorker's own settings" in d.reason
# -- git's own configuration, conftest.py, CI / editor / package-manager files ----------------
_NEW_MARKER_TARGETS = [
# git reads these on its own: settings that can name programs or move the hooks
# folder, attributes that pick filters, and a submodule's own git folder
".git/config",
".git/info/attributes",
".git/modules/vendor/lib/hooks/post-checkout",
".git/modules/vendor/lib/config",
"vendor/lib/.git", # a `.git` file says which folder git takes settings and hooks from
".git/worktrees/feature/config.worktree", # a linked worktree's own settings
# pytest imports these on every test run, at any depth
"conftest.py",
"tests/unit/conftest.py",
"pytest.ini", # its options can load a plugin on every test run
# Python imports these on every start of an interpreter that can see them
"sitecustomize.py",
".venv/Lib/site-packages/usercustomize.py",
# mise loads these on entering the folder
".mise.toml",
"mise.toml",
"mise.local.toml",
# CI services run these on push
"azure-pipelines.yml",
".travis.yml",
"Jenkinsfile",
"bitbucket-pipelines.yml",
".buildkite/pipeline.yml",
".github/actions/setup/action.yml", # actions the workflows call
# the editor runs this when the user starts the program or the debugger
".vscode/launch.json",
".vscode/settings.json", # can name the terminal shell, interpreter and formatters
# package managers read these on every run, and they can name programs to run
".npmrc",
".yarnrc",
".yarnrc.yml",
".pnpmfile.cjs",
# cargo's settings can name the program that runs, links or wraps every build
".cargo/config.toml",
".cargo/config",
]
@pytest.mark.parametrize("target", _NEW_MARKER_TARGETS)
def test_new_protected_targets_are_human_only(tmp_path, target):
d = _gate(tmp_path).evaluate("write_file", {"path": target, "content": "x"})
assert not d.allowed and d.needs_user and d.human_only, target
@pytest.mark.parametrize(
"path",
[
".gitmodules",
".git/index.lock",
".git/COMMIT_EDITMSG",
".git/info/exclude",
".vscode/extensions.json",
".github/ISSUE_TEMPLATE/bug.md",
"docs/pytest.ini.md",
"src/sitecustomize_helpers.py",
"notes/mise.toml.example",
".cargo/credentials.toml",
"src/cargo/config.rs",
"src/conftest.py.bak",
"tests/my_conftest.py",
"docs/Jenkinsfile.md",
"notes/.npmrc.example",
"src/git/config.py",
"src/.github_utils.py",
],
)
def test_neighbours_of_the_new_targets_stay_ordinary(tmp_path, case_insensitive, path):
d = _gate(tmp_path).evaluate("write_file", {"path": path, "content": "x"})
assert not d.human_only, path
# -- shell commands ----------------------------------------------------------------------------
def _shell(tmp_path: Path, command: str, mode: Mode = Mode.AUTO_APPROVE, **kw):
gate = PermissionEngine(workspace_root=tmp_path, mode=mode, **kw)
return gate.evaluate("run_shell", {"command": command})
@pytest.mark.parametrize(
"command, shell",
[
("cp hook.sh .git/hooks/pre-commit", "bash"),
("echo 'make test' >> .github/workflows/ci.yml", "bash"),
("sed -i 's/a/b/' setup.py", "bash"),
("printf 'import os' > tests/conftest.py", "bash"),
("mv tmp.yml ./.gitlab-ci.yml", "bash"),
("ln -sf ../../tools/hook .git/hooks/pre-push", "bash"),
("rm -rf .git/hooks", "bash"),
("cat > .envrc <<'X'\nexport A=1\nX", "bash"),
('tee -a ".git/config" < extra.cfg', "bash"),
("Set-Content -Path .GIT\\hooks\\pre-commit -Value x", "powershell"),
("Add-Content .github\\workflows\\ci.yml 'run: x'", "powershell"),
("Copy-Item hook.ps1 -Destination:.husky\\pre-commit", "powershell"),
("Out-File -FilePath 'AGENTS.md' -InputObject x", "powershell"),
],
)
def test_shell_commands_that_change_a_protected_file_are_human_only(tmp_path, case_insensitive, command, shell):
d = _shell(tmp_path, command, shell_kind=shell)
assert not d.allowed and d.needs_user and d.human_only, command
assert "runs automatically later" in d.reason
@pytest.mark.parametrize(
"command, shell",
[
("cat .github/workflows/ci.yml", "bash"),
("grep -n hook .git/hooks/pre-commit", "bash"),
("cat .git/config", "bash"),
("git diff setup.py", "bash"),
("git log -p -- tests/conftest.py", "bash"),
("ls -la .husky", "bash"),
("head -n 20 tox.ini | grep envlist", "bash"),
("cat .github\\workflows\\ci.yml", "powershell"),
],
)
def test_shell_reads_of_protected_files_keep_their_normal_handling(tmp_path, command, shell):
d = _shell(tmp_path, command, shell_kind=shell)
assert not d.human_only, command
# The read-only session grant still covers them, as before.
d = _shell(tmp_path, command, Mode.INTERACTIVE, shell_kind=shell, session_readonly=True)
assert d.allowed, command
@pytest.mark.parametrize(
"command",
["ls -la .git/hooks 2>/dev/null | head", "cat .git/config 2>&1", "cat setup.py > /dev/null"],
)
def test_a_read_that_throws_output_away_is_still_a_read(tmp_path, command):
assert not _shell(tmp_path, command, shell_kind="bash").human_only, command
@pytest.mark.parametrize(
"command",
["ls -la .git && make", "find . -newer x | grep -v .git > files.txt", "tar czf src.tgz --exclude=.git ."],
)
def test_naming_the_git_folder_in_a_command_is_not_a_change_to_it(tmp_path, command):
# A `.git` FILE is protected for the file tools; in a command `.git` almost always
# names the folder being listed or left out.
(tmp_path / ".git").mkdir()
assert not _shell(tmp_path, command, shell_kind="bash").human_only, command
@pytest.mark.parametrize(
"command",
["cat setup.py && cat tox.ini", "cat .gitattributes; ls .git/hooks",
"cd /src/app && head -40 .gitlab-ci.yml", "cd sub; cat .pre-commit-config.yaml | head -40"],
)
def test_a_sequence_of_reads_is_still_a_read(tmp_path, command):
d = _shell(tmp_path, command, shell_kind="bash")
assert not d.human_only, command
@pytest.mark.parametrize(
"command",
[
"pytest -q",
"python -m build",
"npm install",
"cp docs/setup.py.txt notes/",
"echo setup.pyx > notes.txt",
"rm -rf build dist",
"git config --get user.email",
"git config user.name",
"git config --list --show-origin",
"git config user.email a@b.c",
"git config set --local init.defaultBranch main",
"git config push.autoSetupRemote true",
"git config fetch.prune true",
"git config rebase.autoStash true",
"git config merge.conflictStyle zdiff3",
"cd .git && cat config",
],
)
def test_other_shell_commands_are_unaffected(tmp_path, case_insensitive, command):
d = _shell(tmp_path, command, shell_kind="bash")
assert not d.human_only, command
@pytest.mark.parametrize(
"command",
[
"git config --global user.name 'A B'",
"git config --global core.longpaths true",
"git config --global push.default simple",
],
)
def test_a_plain_global_git_setting_is_not_a_protected_file(tmp_path, case_insensitive, command):
# Not this floor's: no file here runs later. Round-2 F-5 still sends a change to the
# user's global settings to a person in Auto-Approve (tests/test_settings_floor.py),
# and the other modes keep their ordinary card.
d = _shell(tmp_path, command, shell_kind="bash")
assert d.human_only and d.reason == permissions.USER_SETTINGS_REASON, command
assert not _shell(tmp_path, command, Mode.INTERACTIVE, shell_kind="bash").human_only, command
@pytest.mark.parametrize(
"command",
[
"git config core.hooksPath tools/hooks",
"git config --local core.fsmonitor ./watch.sh",
"git -C sub config alias.st '!sh x'",
"git config set core.pager less",
"git config --global core.editor vim",
"git config --unset core.hooksPath",
"git config -e",
"git config --system --add safe.directory /deps/repo",
"git config --global url.file:///deps/.insteadOf https://github.com/",
"git config --global protocol.file.allow always",
"git config user.email a@b.c && git config core.hooksPath x",
"cd $HOME && cp hook .git/hooks/pre-commit",
],
)
def test_git_config_changes_are_human_only(tmp_path, command):
d = _shell(tmp_path, command, shell_kind="bash")
assert d.human_only, command
@pytest.mark.parametrize(
"command",
["python setup.py develop", "python scripts/setup.py", "py -3 setup.py sdist",
"bash .husky/pre-commit", "./setup.py install", "python3 -u setup.py test && pytest -q"],
)
def test_running_a_protected_file_is_not_changing_it(tmp_path, command):
# Running it now is an ordinary command the reviewer sees; nothing is left behind.
d = _shell(tmp_path, command, shell_kind="bash")
assert not d.human_only, command
@pytest.mark.parametrize(
"command",
["python setup.py > setup.py", "python -c \"open('setup.py', 'w').write('x')\"",
"python tools/gen.py --out conftest.py", "python setup.py && cp x setup.py"],
)
def test_another_mention_beside_running_it_still_counts(tmp_path, command):
d = _shell(tmp_path, command, shell_kind="bash")
assert d.human_only, command
def test_shell_paths_are_read_from_the_shells_current_folder(tmp_path):
(tmp_path / ".git" / "hooks").mkdir(parents=True)
d = _shell(tmp_path, "cp ../hook.sh hooks/pre-commit", shell_kind="bash",
shell_cwd=lambda: str(tmp_path / ".git"))
assert d.human_only
def test_shell_wildcards_are_expanded_against_the_folder(tmp_path):
hooks = tmp_path / ".git" / "hooks"
hooks.mkdir(parents=True)
(hooks / "pre-commit").write_text("")
assert _shell(tmp_path, "cp pre-commit .git/ho*", shell_kind="bash").human_only
assert _shell(tmp_path, "cp hook.sh .git/ho*/pre-c*", shell_kind="bash").human_only
@pytest.mark.parametrize("mode", [Mode.INTERACTIVE, Mode.AUTO_APPROVE, Mode.BYPASS_APPROVALS])
def test_shell_protection_ignores_allowlists_and_grants(tmp_path, mode):
command = "cp hook.sh .git/hooks/pre-commit"
gate = PermissionEngine(
workspace_root=tmp_path, mode=mode, allowed_commands=["cp"], shell_kind="bash",
session_allow_commands={command}, session_readonly=True,
)
d = gate.evaluate("run_shell", {"command": command})
assert not d.allowed and d.human_only
def test_dangerous_mode_clears_the_shell_floor_too(tmp_path):
d = _shell(tmp_path, "cp hook.sh .git/hooks/pre-commit", Mode.DANGEROUSLY_BYPASS_APPROVALS,
shell_kind="bash")
assert d.allowed and "runs automatically later" in d.reason
# -- every spelling that reaches the same file (Windows) ---------------------------------------
windows_only = pytest.mark.skipif(sys.platform != "win32", reason="Windows path spellings")
def _short_name(path: Path) -> "str | None":
import ctypes
buf = ctypes.create_unicode_buffer(1024)
n = ctypes.windll.kernel32.GetShortPathNameW(str(path), buf, len(buf))
if not n or buf.value.lower() == str(path).lower():
return None
return Path(buf.value).name
@windows_only
@pytest.mark.parametrize(
"target",
[
"setup.py.",
"setup.py. . ",
"setup.py::$DATA",
"conftest.py:extra",
".envrc...",
"tests/conftest.py ",
".git/hooks/pre-commit.",
],
)
def test_windows_trailing_dots_spaces_and_streams_reach_the_same_file(tmp_path, target):
(tmp_path / "tests").mkdir()
(tmp_path / ".git" / "hooks").mkdir(parents=True)
d = _gate(tmp_path).evaluate("write_file", {"path": target, "content": "x"})
assert not d.allowed and d.human_only, target
@windows_only
def test_windows_folder_stream_spelling_is_the_folder(tmp_path):
(tmp_path / ".git" / "hooks").mkdir(parents=True)
d = _gate(tmp_path).evaluate(
"write_file", {"path": ".git::$INDEX_ALLOCATION/hooks/pre-commit", "content": "x"}
)
assert not d.allowed and d.human_only
@windows_only
def test_windows_short_names_resolve_to_the_real_folder(tmp_path):
github = tmp_path / ".github"
(github / "workflows").mkdir(parents=True)
short = _short_name(github)
if short is None:
pytest.skip("8.3 short names are turned off on this volume")
d = _gate(tmp_path).evaluate("write_file", {"path": f"{short}/workflows/ci.yml", "content": "x"})
assert d.human_only
d = _shell(tmp_path, f"Copy-Item x.yml {short}\\workflows\\ci.yml", shell_kind="powershell")
assert d.human_only
@windows_only
def test_windows_junction_into_a_protected_folder_is_followed(tmp_path):
import subprocess
hooks = tmp_path / ".git" / "hooks"
hooks.mkdir(parents=True)
link = tmp_path / "tools"
made = subprocess.run(["cmd", "/c", "mklink", "/J", str(link), str(hooks)], capture_output=True)
if made.returncode != 0:
pytest.skip("could not create a junction here")
d = _gate(tmp_path).evaluate("write_file", {"path": "tools/pre-commit", "content": "x"})
assert d.human_only
d = _shell(tmp_path, "Set-Content tools\\pre-commit x", shell_kind="powershell")
assert d.human_only
def test_a_write_whose_location_cannot_be_worked_out_fails_closed(monkeypatch):
def boom(*_a, **_k):
raise OSError("cannot resolve")
monkeypatch.setattr(permissions.os.path, "realpath", boom)
assert _is_protected_in_project(Path("/w/src/app.py"))
# Words in a shell command are not all paths, so there it is only a missed match.
assert not _is_protected_in_project(Path("/w/src/app.py"), fail_closed=False)
@windows_only
def test_a_name_windows_would_reduce_to_nothing_fails_closed(tmp_path):
d = _gate(tmp_path).evaluate("write_file", {"path": "src/...", "content": "x"})
assert d.human_only