"""Tests for `_is_read_command` — which shell commands count as file reads. Read detection drives read protection: a command classified as a file read has its output passed verbatim instead of lossy-compressed, because the agent needs exact bytes to build a patch from. Chained commands used to fall through: only the first program was inspected, so `wc -l a.py && sed -n '1,60p' a.py` was classified as a `wc` run and the file content was word-dropped by Kompress. """ import json import pytest from headroom.tokenizers.estimator import EstimatingTokenCounter from headroom.transforms.content_router import ( ContentRouter, ContentRouterConfig, _is_read_command, ) @pytest.mark.parametrize( "command", [ "cat foo.py", "head -80 foo.py", "tail -n 50 foo.py", "sed -n '1,60p' foo.py", "sed -ne '1,60p' foo.py", "sed -En '1,60p' foo.py", "sed --quiet '1,60p' foo.py", "sed --silent '1,60p' foo.py", "sed --quiet --expression='1,60p' foo.py", "timeout 30 sed -ne '1,60p' foo.py", "sed -n --follow-symlinks '1,60p' foo.py", "sed -a -n '1,60p' foo.py", # BSD sed. "sed -n -e '1,60p' foo.py -l", # BSD line buffering (no argument). "sed -l -n '1,60p' foo.py", "sed -ln '1,60p' foo.py", "sed -l 80 -n '1,60p' foo.py", # GNU line length takes an argument. "sed -nl80 '1,60p' foo.py", "cd /repo && cat foo.py", "sudo cat foo.py", "rtk cat foo.py", 'bash -lc "cat foo.py"', # The `-c` argument is not the first token after the shell. 'bash --norc -lc "cat foo.py"', ], ) def test_simple_reads_are_detected(command: str) -> None: assert _is_read_command(command) is True @pytest.mark.parametrize( "command", [ # The reported case: a read batched behind an unrelated first program. "wc -l a.py b.py && sed -n '1,60p' c.py", "grep -n X foo.py | head -40; head -80 bar.py", "ls -la || cat foo.py", "echo start; cat foo.py", # Bare `sed` is a stream edit, but the `cat` segment is still a read. "sed 's/a/b/' foo.py && cat -n bar.py", # A read in the first segment survives a non-read tail. "cat foo.py && pytest -q", # Trailing and doubled separators produce empty segments, which are skipped. "cat foo.py;", "ls -la; ; cat foo.py", # A write in a SIBLING segment does not unprotect the read segment: the # output still carries the exact bytes of foo.py. "cat foo.py && echo done > marker", "echo done > marker && cat foo.py", "sed -n '1,60p' foo.py; touch out >> log", ], ) def test_chained_reads_are_detected(command: str) -> None: assert _is_read_command(command) is True @pytest.mark.parametrize( "command", [ # Derived output — stays compressible. "grep -n x foo.py", "pytest -q", "ls -la", # A pipeline stage consumes the previous stage's output, not a file: # `head` here truncates grep output, it does not read bar.py. "grep -n x foo.py | head -40", # Writes are never reads. "cat > foo.py", # The write lives in the read segment itself — a pipeline is one segment, # so `tee` is still visible after the split. "cat foo.py | tee bar.py", "cat foo.py > copy.py && echo done", "sed -n '1,60p' foo.py >> out.txt", "sed 's/a/b/' foo.py", "sed -n1,60p foo.py", # Invalid: a script cannot be attached to -n. "sed -ni '1,60p' foo.py", "sed -n -i '1,60p' foo.py", "sed -n -I .bak '1,60p' foo.py", # BSD in-place editing. "sed -n -I '' '1,60p' foo.py", "sed -n -l -i '' '1,60p' foo.py", # BSD -l must not hide in-place flags. "sed -n -l -I .bak '1,60p' foo.py", "sed -in '1,60p' foo.py", "sed --quiet --in-place '1,60p' foo.py", "sed --quiet --in-place=.bak '1,60p' foo.py", "sed -e 's/a/ -n /' foo.py", # Script text is not a quiet option. "sed -e ' -n ' foo.py", "sed -- -n foo.py", # Option parsing ends at --. # Lockfiles are regenerated, never byte-patched. "cat uv.lock", # `-n` from a sibling segment must not qualify a bare `sed`. "sed 's/a/b/' foo.py && ls -n", # A segment that is only an env assignment resolves to no program. "FOO=1", # A shell invocation with no `-c` argument runs a script, not a read. "bash --norc", "bash script.sh", ], ) def test_non_reads_are_not_detected(command: str) -> None: assert _is_read_command(command) is False @pytest.mark.parametrize( ("command", "expected"), [ # Shell operators inside a quoted sed script are part of the argument (#4478). ("sed -n '/x >/p' foo.py", True), ("sed -n '/x >> y/p' foo.py", True), ('sed -n "/a > b/p" foo.py', True), ("sed -n '/a|b/p' foo.py", True), ("sed -n '/a;b/p' foo.py", True), ("sed -n '/a && b/p' foo.py", True), ("sed -n '/ tee /p' foo.py", True), ("cat 'a > b.py'", True), # An escaped operator is a literal argument too. (r"cat foo.py \> out", True), # Real operators next to a quoted script still count. ("sed -n '/x >/p' foo.py > out.txt", False), ("sed -n '/a|b/p' foo.py | tee out.txt", False), ("sed -n '/a;b/p' foo.py; echo done", True), ("echo '>' && sed 's/a/b/' foo.py", False), # The -c argument of a shell is quoted at the outer level; the inner # command is checked on its own. ('bash -lc "cat foo.py > copy.py"', False), ('bash -lc "cat foo.py | tee copy.py"', False), ('bash -lc "cat foo.py"', True), # A backslash-newline is a line continuation: the write on the next line # still counts (review of #4646). ("cat foo.py \\\n> copy.py", False), ("cat foo.py \\\n>> copy.py", False), ("cat foo.py | \\\ntee copy.py", False), ("sed -n '/x >/p' foo.py \\\n> out.txt", False), ("sed -n '1,60p' \\\nfoo.py", True), # A comment ends at the newline; its quote marks do not open a quote that # would hide the next line's separators (review of #4646). ('echo start # " unclosed in comment\nls; cat foo.py', True), ("echo ok # author's note\ntrue; cat foo.py", True), ("cat foo.py # > not a redirect", True), # A hash inside a word is not a comment. ("cat foo#bar.py > out.txt", False), ], ) def test_quoted_shell_operators_are_arguments(command: str, expected: bool) -> None: assert _is_read_command(command) is expected def test_heredoc_body_is_not_split_into_a_bogus_read() -> None: """A `;` inside a heredoc body must not produce a segment that looks like a read — the command as a whole writes a file.""" command = "cat > foo.py < None: monkeypatch.setenv("HEADROOM_PROTECT_READS", "1") monkeypatch.setenv("HEADROOM_SHELL_RESULT_MIN_CHARS", "2000") # Sixty source lines exceed the small-shell shortcut and reach read protection. content = "".join( f"def compute_{i}(value):\n" " return value * 2 # Preserve this source exactly for a later patch.\n" for i in range(30) ) assert len(content) >= 2000 messages = [ {"role": "user", "content": "Read the module."}, { "role": "assistant", "content": None, "tool_calls": [ { "id": "read-1", "type": "function", "function": { "name": "Bash", "arguments": json.dumps({"command": f"sed {flag} '1,60p' foo.py{comment}"}), }, } ], }, {"role": "tool", "tool_call_id": "read-1", "content": content}, ] router = ContentRouter( ContentRouterConfig( enable_code_aware=False, enable_kompress=False, protect_analysis_context=False, protect_recent_reads_fraction=0.0, ) ) result = router.apply(messages, EstimatingTokenCounter(), protect_recent=0) assert "router:shell_small_result_verbatim" not in result.transforms_applied assert "router:read_protected" in result.transforms_applied assert result.messages[2]["content"] == content @pytest.mark.parametrize( ("command", "expected"), [ ("sed -n '1,60p' foo.py # avoid -i here", True), ("sed -n '1,60p' foo.py # --unknown", True), ("sed -n '1,60p' foo.py # author's note", True), ("sed -n '1,60p' foo.py # unclosed \"quote", True), ("sed -n '1,60p' 'foo#bar.py'", True), ('sed -n "1,60p" "foo#bar.py"', True), ("sed -n '1,60p' foo#bar.py", True), (r"sed -n '1,60p' foo\#bar.py", True), ("sed -n '/# marker/p' foo.py", True), # Literal hashes must not hide real in-place options that follow them. ("sed -n '1,60p' foo#bar.py -i", False), ("sed -n '1,60p' 'foo#bar.py' -i", False), (r"sed -n '1,60p' foo\#bar.py -i", False), (r"sed -n '1,60p' foo\ #bar.py -i", False), ("sed -n '/# marker/p' foo.py -i", False), ("sed -n '1,60p' foo.py -i # --quiet", False), ("sed -n 'unterminated # quote", False), ], ) def test_sed_shell_comments_and_literal_hashes(command: str, expected: bool) -> None: assert _is_read_command(command) is expected