claude-dev-env 4.2.0 → 7.0.0

package/.agents/skills/pull-request/scripts/recover_legacy_author.py

@@ -0,0 +1,251 @@
+"""Restore one explicitly selected legacy GitHub author-swap record."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import stat
+import subprocess
+import sys
+import time
+from collections.abc import Callable, Sequence
+from pathlib import Path
+
+from github_pr_command_constants.config.constants import (
+    ALL_GH_AUTH_SWITCH_COMMAND_HEAD,
+    LEGACY_RECORD_ACTIVE_MESSAGE,
+    LEGACY_RECORD_CHANGED_MESSAGE,
+    LEGACY_RECORD_CONFIRMATION_MESSAGE,
+    LEGACY_RECORD_INACTIVE_CONFIRMATION_FLAG,
+    LEGACY_RECORD_NAME_PATTERN,
+    LEGACY_RECORD_ORIGINAL_ACCOUNT_KEY,
+    LEGACY_RECORD_PERMISSION_MODE,
+    LEGACY_RECORD_REJECTED_MESSAGE,
+    LEGACY_RECORD_STALE_AGE_SECONDS,
+    LEGACY_RESTORE_FAILED_MESSAGE,
+    RECOVERY_CLEAN_EXIT_CODE,
+    RECOVERY_FAILED_EXIT_CODE,
+    RECOVERY_REJECTED_EXIT_CODE,
+    RECOVERY_UNRESOLVED_EXIT_CODE,
+)
+
+CommandRunner = Callable[..., subprocess.CompletedProcess[str]]
+FileFingerprint = tuple[int, int, int, int, int]
+VerifiedRecord = tuple[str, FileFingerprint]
+
+
+class LegacyRecordRejected(ValueError):
+    """Report an invalid legacy state record."""
+
+
+class LegacyRecordActive(ValueError):
+    """Report a legacy state record that is not old enough for recovery."""
+
+
+class LegacyRecordChanged(ValueError):
+    """Report a legacy state record that changed during recovery."""
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__, allow_abbrev=False)
+    parser.add_argument("state_file", type=Path)
+    parser.add_argument(LEGACY_RECORD_INACTIVE_CONFIRMATION_FLAG, action="store_true")
+    return parser
+
+
+def _posix_metadata_is_secure(
+    file_mode: int,
+    file_owner_id: int,
+    current_user_id: int | None,
+) -> bool:
+    if not stat.S_ISREG(file_mode):
+        return False
+    if current_user_id is None:
+        return True
+    return (
+        stat.S_IMODE(file_mode) == LEGACY_RECORD_PERMISSION_MODE
+        and file_owner_id == current_user_id
+    )
+
+
+def _secure_metadata(
+    state_file: Path,
+    current_user_id: int | None,
+) -> os.stat_result:
+    try:
+        file_metadata = state_file.lstat()
+    except OSError as error:
+        raise LegacyRecordRejected from error
+    if not _posix_metadata_is_secure(
+        file_metadata.st_mode,
+        file_metadata.st_uid,
+        current_user_id,
+    ):
+        raise LegacyRecordRejected
+    return file_metadata
+
+
+def _fingerprint(file_metadata: os.stat_result) -> FileFingerprint:
+    return (
+        file_metadata.st_dev,
+        file_metadata.st_ino,
+        file_metadata.st_mode,
+        file_metadata.st_size,
+        file_metadata.st_mtime_ns,
+    )
+
+
+def _parse_original_account(record_text: str) -> str:
+    try:
+        decoded_record = json.loads(record_text)
+    except json.JSONDecodeError as error:
+        raise LegacyRecordRejected from error
+    if not isinstance(decoded_record, dict):
+        raise LegacyRecordRejected
+    if set(decoded_record) != {LEGACY_RECORD_ORIGINAL_ACCOUNT_KEY}:
+        raise LegacyRecordRejected
+    original_account = decoded_record[LEGACY_RECORD_ORIGINAL_ACCOUNT_KEY]
+    if not isinstance(original_account, str) or not original_account.strip():
+        raise LegacyRecordRejected
+    return original_account.strip()
+
+
+def _read_verified_record(
+    state_file: Path,
+    now_seconds: float,
+    current_user_id: int | None,
+) -> VerifiedRecord:
+    if LEGACY_RECORD_NAME_PATTERN.fullmatch(state_file.name) is None:
+        raise LegacyRecordRejected
+    initial_metadata = _secure_metadata(state_file, current_user_id)
+    if now_seconds - initial_metadata.st_mtime < LEGACY_RECORD_STALE_AGE_SECONDS:
+        raise LegacyRecordActive
+    try:
+        record_text = state_file.read_text(encoding="utf-8")
+    except (OSError, UnicodeError) as error:
+        raise LegacyRecordRejected from error
+    original_account = _parse_original_account(record_text)
+    initial_fingerprint = _fingerprint(initial_metadata)
+    verified_metadata = _secure_metadata(state_file, current_user_id)
+    if _fingerprint(verified_metadata) != initial_fingerprint:
+        raise LegacyRecordChanged
+    return original_account, initial_fingerprint
+
+
+def _delete_unchanged_record(
+    state_file: Path,
+    expected_fingerprint: FileFingerprint,
+    current_user_id: int | None,
+) -> None:
+    current_metadata = _secure_metadata(state_file, current_user_id)
+    if _fingerprint(current_metadata) != expected_fingerprint:
+        raise LegacyRecordChanged
+    try:
+        state_file.unlink()
+    except OSError as error:
+        raise LegacyRecordChanged from error
+
+
+def _load_record_with_diagnostics(
+    state_file: Path,
+    now_seconds: float,
+    current_user_id: int | None,
+) -> tuple[VerifiedRecord | None, int]:
+    try:
+        return _read_verified_record(state_file, now_seconds, current_user_id), 0
+    except LegacyRecordActive:
+        sys.stderr.write(LEGACY_RECORD_ACTIVE_MESSAGE)
+        return None, RECOVERY_REJECTED_EXIT_CODE
+    except LegacyRecordChanged:
+        sys.stderr.write(LEGACY_RECORD_CHANGED_MESSAGE)
+        return None, RECOVERY_FAILED_EXIT_CODE
+    except LegacyRecordRejected:
+        sys.stderr.write(LEGACY_RECORD_REJECTED_MESSAGE)
+        return None, RECOVERY_REJECTED_EXIT_CODE
+
+
+def _restore_and_delete(
+    state_file: Path,
+    verified_record: VerifiedRecord,
+    current_user_id: int | None,
+    command_runner: CommandRunner,
+) -> int:
+    original_account, expected_fingerprint = verified_record
+    try:
+        completed_restore = command_runner(
+            [*ALL_GH_AUTH_SWITCH_COMMAND_HEAD, original_account],
+            capture_output=True,
+            check=False,
+            shell=False,
+            text=True,
+        )
+    except OSError:
+        sys.stderr.write(LEGACY_RESTORE_FAILED_MESSAGE)
+        return RECOVERY_FAILED_EXIT_CODE
+    if completed_restore.returncode != 0:
+        sys.stderr.write(LEGACY_RESTORE_FAILED_MESSAGE)
+        return RECOVERY_FAILED_EXIT_CODE
+    try:
+        _delete_unchanged_record(state_file, expected_fingerprint, current_user_id)
+    except (LegacyRecordChanged, LegacyRecordRejected):
+        sys.stderr.write(LEGACY_RECORD_CHANGED_MESSAGE)
+        return RECOVERY_FAILED_EXIT_CODE
+    return RECOVERY_CLEAN_EXIT_CODE
+
+
+def _recover_selected_record(
+    state_file: Path,
+    now_seconds: float,
+    current_user_id: int | None,
+    command_runner: CommandRunner,
+) -> int:
+    verified_record, exit_code = _load_record_with_diagnostics(
+        state_file, now_seconds, current_user_id
+    )
+    if verified_record is None:
+        return exit_code
+    return _restore_and_delete(
+        state_file, verified_record, current_user_id, command_runner
+    )
+
+
+def main(
+    all_arguments: Sequence[str],
+    *,
+    now_seconds: float,
+    current_user_id: int | None,
+    command_runner: CommandRunner,
+) -> int:
+    """Recover one confirmed-inactive legacy state record.
+
+    Args:
+        all_arguments: Command arguments after the script name.
+        now_seconds: Current wall-clock time in seconds.
+        current_user_id: Current POSIX user identifier, or None on Windows.
+        command_runner: Process runner used by tests and production.
+
+    Returns:
+        Zero on success, one on failure, two on rejection, or three when unresolved.
+    """
+    arguments = _build_parser().parse_args(list(all_arguments))
+    if not arguments.confirm_inactive:
+        sys.stderr.write(LEGACY_RECORD_CONFIRMATION_MESSAGE)
+        return RECOVERY_UNRESOLVED_EXIT_CODE
+    return _recover_selected_record(
+        arguments.state_file,
+        now_seconds,
+        current_user_id,
+        command_runner,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(
+        main(
+            sys.argv[1:],
+            now_seconds=time.time(),
+            current_user_id=os.getuid() if hasattr(os, "getuid") else None,
+            command_runner=subprocess.run,
+        )
+    )

package/.agents/skills/pull-request/scripts/test_github_pr_command_constants.py

@@ -0,0 +1,58 @@
+"""Tests for explicit GitHub pull request command constants."""
+
+import sys
+from pathlib import Path
+
+_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+
+from github_pr_command_constants.config import constants
+
+
+def test_action_and_linter_mappings_are_complete() -> None:
+    assert constants.ALL_LINTER_ACTIONS_BY_COMMAND == {
+        constants.ACTION_COMMENT: constants.LINTER_ACTION_COMMENT,
+        constants.ACTION_CREATE: constants.LINTER_ACTION_CREATE,
+        constants.ACTION_EDIT: constants.LINTER_ACTION_EDIT,
+        constants.ACTION_REVIEW: constants.LINTER_ACTION_REVIEW,
+    }
+
+
+def test_review_event_flags_are_complete() -> None:
+    assert constants.ALL_REVIEW_FLAGS_BY_EVENT == {
+        constants.REVIEW_EVENT_APPROVE: "--approve",
+        constants.REVIEW_EVENT_COMMENT: "--comment",
+        constants.REVIEW_EVENT_REQUEST_CHANGES: "--request-changes",
+    }
+
+
+def test_account_boundary_constants_are_safe_and_stable() -> None:
+    assert constants.SELECTED_ACCOUNT_ENVIRONMENT_KEY == "GITHUB_DEFAULT_ACCOUNT"
+    assert constants.ACCOUNT_LOOKUP_FAILURE_EXIT_CODE == 1
+    assert constants.ACCOUNT_LOOKUP_FAILED_MESSAGE.endswith("lookup failed\n")
+    assert constants.ACCOUNT_LOOKUP_EMPTY_MESSAGE.endswith("returned no value\n")
+
+
+def test_durable_post_linter_location_uses_managed_root() -> None:
+    assert constants.CONFIG_DIR_OVERRIDE_ENVIRONMENT_KEY == "CLAUDE_CONFIG_DIR"
+    assert constants.DEFAULT_MANAGED_ROOT_DIRECTORY_NAME == ".claude"
+    assert constants.ALL_DURABLE_POST_LINTER_RELATIVE_PATH_PARTS == (
+        "scripts",
+        "durable_post_lint.py",
+    )
+
+
+def test_legacy_recovery_constants_define_one_record_boundary() -> None:
+    assert constants.ALL_GH_AUTH_SWITCH_COMMAND_HEAD == (
+        "gh",
+        "auth",
+        "switch",
+        "--user",
+    )
+    assert constants.LEGACY_RECORD_NAME_PATTERN.fullmatch(
+        "gh_pr_author_swap_session-a.json"
+    )
+    assert not constants.LEGACY_RECORD_NAME_PATTERN.fullmatch("other.json")
+    assert constants.LEGACY_RECORD_STALE_AGE_SECONDS == 1800
+    assert constants.RECOVERY_UNRESOLVED_EXIT_CODE == 3

package/.agents/skills/pull-request/scripts/test_pull_request.py

@@ -0,0 +1,396 @@
+"""Contract tests for process-local pull request publication."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import threading
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from unittest.mock import Mock
+
+import pytest
+
+_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+
+import pull_request
+
+REPOSITORY = "jl-cmd/claude-dev-env"
+PR_NUMBER = "2518"
+PR_TITLE = "feat(skills): add guarded pull request publication"
+ACCOUNT_A = "JonEcho"
+ACCOUNT_B = "ReviewBot"
+BODY_FILENAME = "pull-request-body.md"
+LINTER_PATH = _SCRIPTS_DIRECTORY.parents[3] / "scripts/durable_post_lint.py"
+COMMENT_CLI = ["comment", "--repo", REPOSITORY, "--number", PR_NUMBER, "--body-file"]
+ACTION_CASES = [
+    (
+        [
+            "create",
+            "--repo",
+            REPOSITORY,
+            "--base",
+            "main",
+            "--head",
+            "feature/post",
+            "--title",
+            PR_TITLE,
+            "--body-file",
+            BODY_FILENAME,
+        ],
+        "pr-create",
+        [
+            "gh",
+            "pr",
+            "create",
+            "--draft",
+            "--repo",
+            REPOSITORY,
+            "--base",
+            "main",
+            "--head",
+            "feature/post",
+            "--title",
+            PR_TITLE,
+            "--body-file",
+            BODY_FILENAME,
+        ],
+    ),
+    (
+        [
+            "edit",
+            "--repo",
+            REPOSITORY,
+            "--number",
+            PR_NUMBER,
+            "--title",
+            PR_TITLE,
+            "--body-file",
+            BODY_FILENAME,
+        ],
+        "pr-edit",
+        [
+            "gh",
+            "pr",
+            "edit",
+            PR_NUMBER,
+            "--repo",
+            REPOSITORY,
+            "--title",
+            PR_TITLE,
+            "--body-file",
+            BODY_FILENAME,
+        ],
+    ),
+    (
+        [*COMMENT_CLI, BODY_FILENAME],
+        "pr-comment",
+        [
+            "gh",
+            "pr",
+            "comment",
+            PR_NUMBER,
+            "--repo",
+            REPOSITORY,
+            "--body-file",
+            BODY_FILENAME,
+        ],
+    ),
+    (
+        [
+            "review",
+            "--repo",
+            REPOSITORY,
+            "--number",
+            PR_NUMBER,
+            "--body-file",
+            BODY_FILENAME,
+        ],
+        "pr-review",
+        [
+            "gh",
+            "pr",
+            "review",
+            PR_NUMBER,
+            "--repo",
+            REPOSITORY,
+            "--comment",
+            "--body-file",
+            BODY_FILENAME,
+        ],
+    ),
+]
+
+
+def _completion(
+    all_arguments: list[str], code: int = 0, stdout: str = "", stderr: str = ""
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.CompletedProcess(all_arguments, code, stdout, stderr)
+
+
+@pytest.fixture
+def body_file(tmp_path: Path) -> Path:
+    post_file = tmp_path / BODY_FILENAME
+    post_file.write_text("Durable body text.", encoding="utf-8")
+    return post_file
+
+
+def _comment_arguments(body_file: Path) -> list[str]:
+    return [*COMMENT_CLI, str(body_file)]
+
+
+def _account_text(account_name: str) -> str:
+    return account_name[::-1]
+
+
+def _calls(command_runner: Mock) -> list[list[str]]:
+    return [each_call.args[0] for each_call in command_runner.call_args_list]
+
+
+def _run_comment(
+    body_file: Path, command_runner: Mock, environment: dict[str, str]
+) -> int:
+    return pull_request.main(
+        _comment_arguments(body_file),
+        all_environment=environment,
+        command_runner=command_runner,
+    )
+
+
+def _account_runner(
+    *, auth_code: int = 0, auth_stdout: str, action_code: int = 0, auth_stderr: str = ""
+) -> Mock:
+    return Mock(
+        side_effect=[
+            _completion([]),
+            _completion([], auth_code, auth_stdout, auth_stderr),
+            _completion([], action_code),
+        ]
+    )
+
+
+@pytest.mark.parametrize(
+    ("all_cli_arguments", "linter_action", "expected_gh"), ACTION_CASES
+)
+def test_actions_run_exact_linter_then_gh_arguments(
+    all_cli_arguments: list[str], linter_action: str, expected_gh: list[str]
+) -> None:
+    command_runner = Mock(side_effect=[_completion([]), _completion([])])
+    exit_code = pull_request.main(
+        all_cli_arguments, all_environment={}, command_runner=command_runner
+    )
+    title_arguments = ["--title", PR_TITLE] if "--title" in all_cli_arguments else []
+    expected_linter = [
+        sys.executable,
+        str(LINTER_PATH),
+        "--action",
+        linter_action,
+        *title_arguments,
+        "--body-file",
+        BODY_FILENAME,
+    ]
+    assert exit_code == 0
+    assert _calls(command_runner) == [expected_linter, expected_gh]
+
+
+def test_body_transport_uses_files_only(body_file: Path) -> None:
+    command_runner = Mock(side_effect=[_completion([]), _completion([])])
+    assert _run_comment(body_file, command_runner, {}) == 0
+    for each_command in _calls(command_runner):
+        assert "--body-file" in each_command
+        assert "--body" not in each_command
+        assert "Durable body text." not in each_command
+
+
+def test_linter_failure_stops_credential_lookup_and_action(body_file: Path) -> None:
+    command_runner = Mock(return_value=_completion([], 1))
+    exit_code = _run_comment(
+        body_file, command_runner, {"GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A}
+    )
+    assert exit_code == 1
+    assert command_runner.call_count == 1
+    assert Path(_calls(command_runner)[0][1]).name == "durable_post_lint.py"
+
+
+def test_account_lookup_scopes_action_environment(body_file: Path) -> None:
+    account_text = _account_text(ACCOUNT_A)
+    command_runner = _account_runner(auth_stdout=f"{account_text}\n")
+    parent_environment = {
+        "GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A,
+        "GITHUB_TOKEN": "parent-setting",
+        "UNCHANGED": "same",
+    }
+    assert _run_comment(body_file, command_runner, parent_environment) == 0
+    assert _calls(command_runner)[1] == ["gh", "auth", "token", "--user", ACCOUNT_A]
+    action_environment = command_runner.call_args_list[2].kwargs["env"]
+    assert action_environment["GH_TOKEN"] == account_text
+    assert "GITHUB_TOKEN" not in action_environment
+    assert action_environment["UNCHANGED"] == "same"
+
+
+def test_absent_account_uses_copied_parent_environment(body_file: Path) -> None:
+    command_runner = Mock(side_effect=[_completion([]), _completion([])])
+    parent_environment = {"GITHUB_TOKEN": "parent-setting", "UNCHANGED": "same"}
+    assert _run_comment(body_file, command_runner, parent_environment) == 0
+    action_environment = command_runner.call_args_list[1].kwargs["env"]
+    assert action_environment == parent_environment
+    assert action_environment is not parent_environment
+    assert command_runner.call_count == 2
+
+
+def test_token_lookup_failure_prints_generic_safe_stderr(
+    body_file: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account_text = _account_text(ACCOUNT_A)
+    command_runner = _account_runner(
+        auth_code=1, auth_stdout=account_text, auth_stderr=f"unsafe {account_text}"
+    )
+    exit_code = _run_comment(
+        body_file, command_runner, {"GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A}
+    )
+    captured = capsys.readouterr()
+    assert exit_code == 1
+    assert captured.err == "error: GitHub account lookup failed\n"
+    assert account_text not in captured.out + captured.err
+    assert command_runner.call_count == 2
+    command_runner = Mock(side_effect=[_completion([]), OSError("unavailable")])
+    assert (
+        _run_comment(body_file, command_runner, {"GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A})
+        == 1
+    )
+    assert capsys.readouterr().err == "error: GitHub account lookup failed\n"
+
+
+def test_empty_account_token_stops_before_action(
+    body_file: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    command_runner = _account_runner(auth_stdout=" \n")
+    exit_code = _run_comment(
+        body_file, command_runner, {"GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A}
+    )
+    captured = capsys.readouterr()
+    assert exit_code == 1
+    assert captured.err == "error: GitHub account lookup returned no value\n"
+    assert command_runner.call_count == 2
+
+
+def test_action_child_results_pass_through_or_report_safely(
+    body_file: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    command_runner = Mock(side_effect=[_completion([]), _completion([], 7)])
+    assert _run_comment(body_file, command_runner, {}) == 7
+    command_runner = Mock(side_effect=[_completion([]), OSError("unavailable")])
+    assert _run_comment(body_file, command_runner, {}) == 1
+    assert capsys.readouterr().err == "error: GitHub action failed\n"
+
+
+def test_supplied_parent_environment_remains_unchanged(body_file: Path) -> None:
+    command_runner = _account_runner(auth_stdout=_account_text(ACCOUNT_A))
+    parent_environment = {
+        "GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A,
+        "GITHUB_TOKEN": "parent-setting",
+        "GH_TOKEN": "parent-setting",
+    }
+    original_environment = dict(parent_environment)
+    assert _run_comment(body_file, command_runner, parent_environment) == 0
+    assert parent_environment == original_environment
+
+
+def test_process_environment_remains_unchanged(
+    body_file: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv("GITHUB_DEFAULT_ACCOUNT", ACCOUNT_A)
+    monkeypatch.setenv("GITHUB_TOKEN", "parent-setting")
+    monkeypatch.setenv("GH_TOKEN", "parent-setting")
+    original_environment = dict(os.environ)
+    command_runner = _account_runner(auth_stdout=_account_text(ACCOUNT_A))
+    exit_code = pull_request.main(
+        _comment_arguments(body_file),
+        all_environment=os.environ,
+        command_runner=command_runner,
+    )
+    assert exit_code == 0
+    assert dict(os.environ) == original_environment
+
+
+def _concurrent_runner(
+    all_environments: list[dict[str, str]],
+    all_commands: list[list[str]],
+    record_lock: threading.Lock,
+) -> Callable[..., subprocess.CompletedProcess[str]]:
+    def run_command(
+        all_arguments: list[str], **keyword_arguments: object
+    ) -> subprocess.CompletedProcess[str]:
+        with record_lock:
+            all_commands.append(all_arguments)
+        if all_arguments[0] == sys.executable:
+            return _completion(all_arguments)
+        if all_arguments[:3] == ["gh", "auth", "token"]:
+            if all_arguments[-1] == ACCOUNT_A:
+                return _completion(all_arguments, stdout=_account_text(ACCOUNT_A))
+            return _completion(all_arguments, 1)
+        child_environment = keyword_arguments["env"]
+        assert isinstance(child_environment, dict)
+        with record_lock:
+            all_environments.append(dict(child_environment))
+        return _completion(all_arguments)
+
+    return run_command
+
+
+def test_concurrent_accounts_keep_tokens_isolated(body_file: Path) -> None:
+    all_environments: list[dict[str, str]] = []
+    all_commands: list[list[str]] = []
+    command_runner = _concurrent_runner(
+        all_environments, all_commands, threading.Lock()
+    )
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        first_run = executor.submit(
+            pull_request.main,
+            _comment_arguments(body_file),
+            all_environment={"GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A},
+            command_runner=command_runner,
+        )
+        second_run = executor.submit(
+            pull_request.main,
+            _comment_arguments(body_file),
+            all_environment={"GITHUB_DEFAULT_ACCOUNT": ACCOUNT_B},
+            command_runner=command_runner,
+        )
+    assert {first_run.result(), second_run.result()} == {0, 1}
+    assert len(all_environments) == 1
+    assert all_environments[0]["GH_TOKEN"] == _account_text(ACCOUNT_A)
+    assert all(
+        each_command[:3] != ["gh", "auth", "switch"] for each_command in all_commands
+    )
+
+
+def test_token_never_reaches_captured_output(
+    body_file: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    account_text = _account_text(ACCOUNT_A)
+    command_runner = _account_runner(auth_stdout=f"{account_text}\n")
+    assert (
+        _run_comment(body_file, command_runner, {"GITHUB_DEFAULT_ACCOUNT": ACCOUNT_A})
+        == 0
+    )
+    captured = capsys.readouterr()
+    assert account_text not in captured.out + captured.err
+
+
+def test_cli_rejects_inline_body(capsys: pytest.CaptureFixture[str]) -> None:
+    command_runner = Mock()
+    with pytest.raises(SystemExit) as raised_exit:
+        pull_request.main(
+            [*COMMENT_CLI[:-1], "--body", "Inline body text."],
+            all_environment={},
+            command_runner=command_runner,
+        )
+    captured = capsys.readouterr()
+    assert raised_exit.value.code == 2
+    assert "--body-file" in captured.err
+    command_runner.assert_not_called()