fix: don't leak the wrapper's own internal state into the child process

appmap-python is a plain Python script, so it gets self-instrumented at
interpreter startup via appmap.pth (AppMap instruments any process by
default), before runner.py's own code has computed the environment the
target command should actually run with. That incidental self-init
writes internal, process-scoped state under _APPMAP*-prefixed env var
names using whatever it inherited — notably _APPMAP_MESSAGES_SHOWN, the
once-per-process guard around the startup config-dump log lines.

Since os.execvpe inherits the current environment, that stale marker
carried into the exec'd child, so anyone using the wrapper (e.g.
`appmap-python --enable-log flask run`) never saw the config-dump log
lines, even with everything else configured correctly: the wrapper's
own throwaway initialization had already tripped the "already shown"
guard before the child process's real initialization ran.

Strip all _APPMAP*-prefixed env vars before exec'ing the child and let
the already-computed envvars re-set whatever it actually needs, so the
child always starts from a clean slate regardless of what the wrapper's
incidental self-init happened to do.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014Nw1eEFHvABs5hdjMej5bf

Author: claude

_appmap/test/test_runner.py

@@ -1,3 +1,4 @@
+import os
 import re
 
 import pytest
@@ -64,3 +65,19 @@ def test_recording_type_present(self, script_runner):
         )
         assert result.returncode == 0
         assert re.match(r"true", result.stdout) is not None
+
+    def test_internal_state_not_leaked_to_child(self, script_runner):
+        # appmap-python is itself instrumented at interpreter startup (via
+        # appmap.pth), which can set internal, process-scoped _APPMAP*
+        # markers using whatever it inherited, before this script has
+        # computed the environment the child command should actually run
+        # with. Simulate that by pre-setting one such marker (the
+        # once-per-process "startup messages already shown" guard) and
+        # confirm it doesn't leak into the child's environment, which would
+        # otherwise silently suppress the child's own startup logging.
+        env = {**os.environ, "_APPMAP_MESSAGES_SHOWN": "true"}
+        result = script_runner.run(
+            ["appmap-python", "printenv", "_APPMAP_MESSAGES_SHOWN"], env=env
+        )
+        assert result.returncode != 0
+        assert result.stdout == ""

appmap/command/runner.py

@@ -130,7 +130,17 @@ def run():
             print(f"{k}={v}")
         sys.exit(0)
 
-    os.execvpe(cmd[0], cmd, {**os.environ, **envvars})
+    # appmap-python is itself instrumented on interpreter startup (via
+    # appmap.pth), before this point, using whatever environment it inherited
+    # rather than the envvars computed above. That incidental self-init can
+    # set internal, process-scoped state under _APPMAP*-prefixed names (e.g.
+    # the once-per-process "startup messages already shown" guard); left in
+    # place, it would carry over into the child's environment and suppress
+    # or corrupt the child's own startup behavior. Drop all of it and let
+    # envvars below re-set whatever the child actually needs.
+    child_env = {k: v for k, v in os.environ.items() if not k.startswith("_APPMAP")}
+    child_env.update(envvars)
+    os.execvpe(cmd[0], cmd, child_env)
 
 
 if __name__ == "__main__":