refactor(proxy-client): введён явный контекст запуска

Выбор путей, прав профиля, вывода Xray и подсказки остановки перенесён из глобальных переменных в неизменяемый RuntimeContext. Команды и управление процессом получают контекст явно. Проверка: прежние 72 теста без изменений прошли на Python 3.8 и 3.14; оба shell-набора прошли.
fix(proxy-client): исправлено восстановление установки службы
2026-11-03 07:17:23 +01:00 · 2026-11-02 22:30:43 +01:00 · 2026-11-02 22:16:12 +01:00
9 changed files with 1050 additions and 90 deletions
@@ -0,0 +1,10 @@
 # Термины dotfiles
 ## Прокси
 **Профиль прокси** — именованный набор настроек одного прокси: его тип,
 адрес и порт для приложений, исключения и, для управляемого Xray, VLESS-ссылка.
 Не следует называть профилем только VLESS-ссылку.
 **VLESS-ссылка** — параметры подключения к удалённому серверу VLESS.
 Она не задаёт локальный порт прокси и исключения для приложений.
@@ -4,6 +4,9 @@
 Статус: реализовано; 2026-09-28 упрощено по принципу ниже
 Расширение от 2026-11-02:
 [пользовательские профили и системная служба](2026-11-02-proxy-client-profiles-service-design.md).
 Точное поведение, форматы, сообщения и команды описаны в коде,
 `proxy-client --help` и [`proxy-client/README.md`](../../proxy-client/README.md).
 Здесь — то, чего по коду не видно: задача, границы, выбор и его причины, риски.
@@ -0,0 +1,176 @@
 # Профили proxy-client и системная служба
 Дата: 2026-11-02
 Статус: реализовано; запуск после загрузки ОС и восстановление настоящей
 службы systemd требуют отдельной проверки на Linux-ВМ.
 ## Задача и границы
 На Linux-ВМ, компьютерах и ноутбуках нужен прокси, доступный после загрузки
 без входа пользователя и ручного запуска. Приложения уже знают его адрес.
 Одновременно пользователь должен иметь возможность запустить другой прокси
 на другом порту в открытом терминале.
 Это расширяет [первоначальный дизайн](2026-07-15-proxy-client-design.md):
 добавляет системную службу и несколько пользовательских профилей.
 Остальные ограничения и принцип личного инструмента сохраняются.
 Термины определены в [CONTEXT.md](../../CONTEXT.md).
 Не добавляем несколько системных экземпляров, фоновый пользовательский режим,
 TUN, системную маршрутизацию, автоматический выбор прокси или поддержку Windows.
 Для системного режима требуется systemd; ручной режим сохраняет независимость
 от него. Пакет по-прежнему можно использовать отдельно от остальных dotfiles.
 ## Пользовательские профили
 Профиль по умолчанию сохраняет нынешние файлы
 `~/.config/proxy-client/config` и `default.url`. Отсутствие выбора профиля
 не меняет поведения существующих команд, включая прежний внешний прокси
 при отсутствии конфигурации. Учитываются существующие настройки XDG.
 Дополнительные профили размещаются в
 `~/.config/proxy-client/profiles/<имя>/`, каждый со своими `config` и
 `default.url`. Имя `default` обозначает существующий профиль по умолчанию.
 Неизвестное имя даёт ошибку, а не переход к другому профилю.
 Один общий параметр выбора профиля действует на запуск, остановку, проверку,
 вывод окружения и запуск дочерних команд. Существующий выбор файла VLESS-ссылки
 через `start -f` остаётся разовым переопределением ссылки выбранного профиля.
 Bash-команды без явного выбора продолжают использовать профиль по умолчанию.
 Каждый профиль получает собственные сведения о процессе, блокировку и
 сгенерированный JSON. Запуск и остановка одного не затрагивают остальные.
 Два экземпляра могут работать одновременно, если их локальные порты различны.
 Занятый порт даёт ошибку; чужой процесс не останавливается.
 Ручной запуск остаётся на переднем плане, с выводом в терминал и остановкой
 через Ctrl+C либо команду остановки выбранного профиля. Само обращение к прокси
 через `run` или `env` ничего не запускает.
 ## Bash-команды
 `proxy_on` без параметров выбирает профиль по умолчанию, с `--profile` —
 именованный. Он меняет только окружение текущего терминала после успешной
 проверки. `proxy_off` очищает переменные, но не останавливает процессы.
 `myip` использует текущее окружение.
 `pclaude` и `pcodex` принимают ведущий `--proxy-profile` для выбора профиля.
 Без него остаётся профиль по умолчанию; остальные аргументы и код возврата
 дочерней программы сохраняются. Обычный `--profile` относится к дочерней
 программе. Bash-модуль передаёт выбор CLI и не дублирует правила профилей.
 Выбор через `proxy_on` не меняет профиль по умолчанию: обычная команда
 наследует окружение, а обёртка с префиксом `p` явно выбирает свой профиль.
 Это различие должно быть показано в README пакета.
 ## Системная служба
 Одна служба `proxy-client.service` читает один комплект настроек из
 `/etc/proxy-client/`. Ей не нужны именованные профили или домашний каталог
 пользователя. Исполняемые файлы устанавливаются в системное расположение,
 без ссылок на пользовательский каталог исходников. Xray работает под отдельной
 непривилегированной учётной записью и слушает только loopback.
 Временные файлы процесса, блокировка и сгенерированный JSON находятся в
 закрытом `/run/proxy-client/`. Секреты доступны только администратору и
 служебной учётной записи. Пользовательские команды остановки не управляют
 системным экземпляром: за него отвечает systemd.
 Установка оформляется подкомандой `service install`, в соответствии с
 существующим интерфейсом CLI. Она размещает необходимые файлы и регистрирует
 службу. Запуск сейчас и автозапуск после загрузки выбираются явно; установщик
 может предоставить явные параметры для совмещения этих действий с установкой.
 Точное написание параметров определяется при реализации.
 Для первоначального заполнения можно скопировать выбранный пользовательский
 профиль. Источник должен быть указан однозначно: повышение прав не должно
 подменить его домашним каталогом root. Копия становится самостоятельной:
 дальнейшие изменения домашнего профиля не меняют службу. Повторная установка
 сохраняет существующие настройки и не перезапускает службу скрыто.
 Systemd отвечает за запуск, остановку и перезапуск после аварии. Явная
 остановка должна оставлять службу остановленной до следующего запуска.
 Если автозапуск включён, после перезагрузки она запускается снова.
 Отсутствие внешней сети при загрузке не должно приводить к окончательному
 отказу службы. Готовность локального порта и доступность удалённого маршрута
 различаются: автозапуск не гарантирует успешность первого запроса любого
 приложения. Для приложений, не умеющих повторять запрос, порядок запуска и
 ожидание готовности потребуют отдельной настройки.
 ## Журналы и совместная работа
 Вывод службы направляется в journald. Отдельный текстовый журнал и собственная
 ротация не нужны. Хранение между загрузками зависит от настройки journald;
 установщик проверяет её и сообщает результат, не меняя глобальную политику
 журналирования машины. Секреты не должны попадать в журнал.
 Если системная служба занимает порт прежнего пользовательского Xray, второй
 запуск на этом порту завершается ошибкой. Чтобы использовать системный прокси
 через пользовательские команды, подходит профиль типа `external`. Для второго
 Xray нужен другой порт. Установка службы не меняет домашний профиль молча.
 ## Устройство модулей
 Применяем `codebase-design`: выбор профиля и все его пути должны определяться
 в одном месте, чтобы команды не повторяли правила размещения файлов.
 Пути, правила доступа к профилю, вывод Xray и подсказка остановки собраны
 в неизменяемый контекст запуска. Он создаётся при выборе пользовательского
 или системного режима и явно передаётся функциям. Управление процессом
 использует готовые значения, без глобального переключателя режима.
 Системная установка скрывает размещение, права и взаимодействие с systemd
 за небольшим интерфейсом; не копирует разбор VLESS и управление Xray.
 Не вводим обобщённую поддержку других менеджеров служб и дополнительные
 слои ради возможного будущего использования. Реально различаются
 пользовательское и системное размещение, а также способ управления процессом.
 ## Проверки
 Согласованы три интерфейса для новых тестов TDD:
 1. CLI пользовательских профилей: прежнее поведение без имени, выбор
   именованного профиля, два одновременных процесса, независимая остановка,
   отказ при занятом порте и правильное окружение дочерней команды.
 2. Установка службы через CLI и управление через systemd: размещение файлов,
   сохранение настроек при повторной установке, явное включение автозапуска,
   запуск и остановка, восстановление после аварии и доступность журналов.
 3. Bash-команды: выбор профиля, передача аргументов и кода возврата,
   сохранение окружения при ошибке и отсутствие остановки процессов.
 Тесты проверяют наблюдаемое поведение через эти интерфейсы, а не внутренние
 функции и последовательности их вызовов. Идём по одному сценарию:
 падающий тест, минимальная реализация, следующий сценарий.
 Локальные проверки используют временные каталоги, синтетические профили и
 подставные внешние программы. Это не доказывает работу настоящего systemd.
 Окончательная проверка системного режима нужна в отдельной Linux-среде
 с systemd: запуск до входа пользователя после загрузки, восстановление после
 аварии, явная остановка и одновременная работа ручного экземпляра.
 Изменение текущей машины или её перезагрузка не входят в проверку по умолчанию.
 Локальный набор прошёл на Python 3.8 и 3.14: 72 теста, проверки Bash-команд
 и пользовательского установщика. Дополнительно проверены Bash-команды вместе
 с настоящим CLI и двумя локальными тестовыми портами. Unit прошёл статическую
 проверку в изолированном корне с тестовыми базовыми target-файлами.
 Shellcheck в среде отсутствует. Эти результаты не заменяют проверку загрузки ОС.
 ## Документация и альтернативы
 Подробные инструкции размещены в
 [`proxy-client/README.md`](../../proxy-client/README.md): профили, системная
 установка и обновление, управление, автозапуск, журналы и диагностика.
 В корневом README достаточно существующей ссылки на пакет. Этот документ
 хранит причины решений; рабочие команды и примеры живут в README пакета.
 Пользовательская служба с linger позволила бы запускать прокси до входа,
 но выбрано явное разделение системных и домашних настроек. Несколько
 именованных системных служб пока не нужны. Запуск в терминале сохраняется
 для дополнительных прокси, но сам по себе не решает задачу загрузки машины.
 Правила systemd сверены с документацией
 [каталогов службы](https://www.freedesktop.org/software/systemd/man/latest/systemd.exec.html#RuntimeDirectory=),
 [перезапуска](https://www.freedesktop.org/software/systemd/man/latest/systemd.service.html#Restart=)
 и [хранения журналов](https://www.freedesktop.org/software/systemd/man/latest/journald.conf.html#Storage=).
@@ -32,8 +32,12 @@ _proxy_apply_env() {
 }
 proxy_on() {
  if (( $# != 0 )) && { (( $# != 2 )) || [[ "$1" != --profile || -z "${2:-}" ]]; }; then
    echo "Использование: proxy_on [--profile NAME]" >&2
    return 2
  fi
  local output
-  if ! output="$(_proxy_cli env)" || ! _proxy_apply_env "$output"; then
+  if ! output="$(_proxy_cli "$@" env)" || ! _proxy_apply_env "$output"; then
    echo "Ошибка: прокси не включён" >&2
    return 1
  fi
@@ -53,7 +57,16 @@ _proxy_run() {
    return 2
  fi
  shift
-  _proxy_cli run -- "$command_name" "$@"
+  local -a profile_args=()
  if [[ "${1:-}" == --proxy-profile ]]; then
    if (( $# < 2 )) || [[ -z "$2" ]]; then
      echo "Ошибка: --proxy-profile требует имя профиля" >&2
      return 2
    fi
    profile_args=(--profile "$2")
    shift 2
  fi
  _proxy_cli "${profile_args[@]}" run -- "$command_name" "$@"
 }
 pclaude() { _proxy_run claude "$@"; }
@@ -30,6 +30,8 @@ import urllib.request
 import uuid
 import zipfile
 from pathlib import Path
 from dataclasses import dataclass
 from typing import Optional
 from urllib.parse import parse_qsl, unquote, urlsplit
@@ -120,23 +122,56 @@ class VlessProfile:
        return self.query["security"]
-def config_home():
+@dataclass(frozen=True)
-    root = os.environ.get("XDG_CONFIG_HOME")
+class RuntimeContext:
-    return (Path(root).expanduser() if root else Path.home() / ".config") / "proxy-client"
+    """Размещение и правила выбранного запуска; создаётся до выполнения команды."""
    config_dir: Path
    state_dir: Path
    xray_path: Optional[Path]
    profile_forbidden_mode: int
    profile_repair: str
    xray_output: Optional[int]
    stop_hint: str
    @property
    def state_path(self):
        return self.state_dir / "state.json"
    @property
    def generated_config_path(self):
        return self.state_dir / "client.json"
-def state_home():
+def user_context(profile="default"):
-    root = os.environ.get("XDG_STATE_HOME")
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_-]{0,63}", profile):
-    base = Path(root).expanduser() if root else Path.home() / ".local/state"
+        raise ProxyError("недопустимое имя профиля")
-    return base / "proxy-client"
+    config_root = os.environ.get("XDG_CONFIG_HOME")
    state_root = os.environ.get("XDG_STATE_HOME")
    config_dir = (Path(config_root).expanduser() if config_root else Path.home() / ".config") / "proxy-client"
    state_dir = (Path(state_root).expanduser() if state_root else Path.home() / ".local/state") / "proxy-client"
    stop_hint = "Ctrl+C или proxy-client stop"
    if profile != "default":
        config_dir = config_dir / "profiles" / profile
        state_dir = state_dir / "profiles" / profile
        if not (config_dir / "config").is_file():
            raise ProxyError("неизвестный профиль: {}".format(profile))
        stop_hint = "Ctrl+C или proxy-client --profile {} stop".format(profile)
    return RuntimeContext(config_dir, state_dir, None, 0o077,
                          "chmod 600 {0}", None, stop_hint)
-def state_path():
+def service_context(arguments):
-    return state_home() / "state.json"
+    config_dir = Path(arguments.config_dir)
-
+    state_dir = Path(arguments.runtime_dir)
-
+    xray_path = Path(arguments.xray)
-def generated_config_path():
+    if not all(path.is_absolute() for path in (config_dir, state_dir, xray_path)):
-    return state_home() / "client.json"
+        raise ProxyError("системные пути должны быть абсолютными")
    if not (config_dir / "config").is_file():
        raise ProxyError("нет системного config")
    return RuntimeContext(config_dir, state_dir, xray_path, 0o037,
                          "sudo chown root:proxy-client {0}; sudo chmod 640 {0}",
                          subprocess.DEVNULL, "sudo systemctl stop proxy-client")
 def validate_address(value):
@@ -157,8 +192,8 @@ def validate_address(value):
        raise ProxyError("поле address должно быть IP-адресом или простым ASCII-именем")
-def load_config():
+def load_config(context):
-    path = config_home() / "config"
+    path = context.config_dir / "config"
    if not path.exists():
        if path.is_symlink():
            raise ProxyError("машинный конфиг {} ссылается на отсутствующий файл".format(path))
@@ -225,9 +260,9 @@ def check_reachable(config):
        )
-def check_proxy(config):
+def check_proxy(config, context):
    if config.proxy_type == "xray":
-        require_supervised_xray(config)
+        require_supervised_xray(config, context)
    check_reachable(config)
@@ -274,13 +309,15 @@ def write_private_json(path, value):
    path.chmod(0o600)
-def load_profile(path):
+def load_profile(path, context):
    # Права проверяем у конечного файла: у симлинка они ничего не значат.
    resolved = path.expanduser().resolve(strict=True)
-    if resolved.stat().st_mode & 0o077:
+    if resolved.stat().st_mode & context.profile_forbidden_mode:
        target = shlex.quote(str(resolved))
        repair = context.profile_repair.format(target)
        raise ProxyError(
-            "файл профиля {} доступен другим пользователям; выполните: chmod 600 {}".format(
+            "файл профиля {} доступен другим пользователям; выполните: {}".format(
-                resolved, shlex.quote(str(resolved))
+                resolved, repair
            )
        )
    lines = [line.strip() for line in resolved.read_text(encoding="utf-8").splitlines()]
@@ -531,8 +568,8 @@ def build_xray_config(profile, local_address, local_port):
    }
-def resolve_xray():
+def resolve_xray(context):
-    found = shutil.which("xray")
+    found = str(context.xray_path) if context.xray_path is not None else shutil.which("xray")
    if found is None:
        raise ProxyError("xray не найден в PATH; установите его: proxy-client install")
    return str(Path(found).resolve(strict=True))
@@ -607,7 +644,8 @@ def install_xray(destination, downloader):
        shutil.rmtree(str(staging), ignore_errors=True)
-def command_install(replace=False, downloader=download_file):
+def command_install(replace=False, downloader=download_file, context=None):
    context = context if context is not None else user_context()
    destination = Path.home() / ".local/bin/xray"
    if destination.is_dir():
        raise ProxyError("назначение {} является каталогом".format(destination))
@@ -624,7 +662,7 @@ def command_install(replace=False, downloader=download_file):
    else:
        install_xray(destination, downloader)
        print("Xray {} установлен: {}".format(XRAY_VERSION, destination))
-        if managed_xray_running():
+        if managed_xray_running(context):
            print("Работающий Xray остался прежним; перезапустите proxy-client start")
    found = shutil.which("xray")
    if found is None or Path(found).resolve() != destination.resolve():
@@ -651,8 +689,8 @@ def run_xray_test(path, config_path):
        raise ProxyError("созданная конфигурация не прошла xray run -test")
-def read_state():
+def read_state(context):
-    path = state_path()
+    path = context.state_path
    try:
        state = json.loads(path.read_text(encoding="utf-8"))
        keys = ("supervisor_pid", "xray_pid", "xray_path", "address", "port")
@@ -685,32 +723,32 @@ def supervisor_running(state):
    return b"proxy-client" in cmdline
-def remove_state_files():
+def remove_state_files(context):
-    for path in (state_path(), generated_config_path()):
+    for path in (context.state_path, context.generated_config_path):
        try:
            path.unlink()
        except FileNotFoundError:
            pass
-def managed_state():
+def managed_state(context):
    """Состояние работающего Xray; устаревшие служебные файлы удаляет."""
-    state = read_state()
+    state = read_state(context)
    if not xray_running(state):
-        remove_state_files()
+        remove_state_files(context)
        raise ProxyError("управляемый Xray не запущен; устаревшие служебные файлы удалены")
    return state
-def managed_xray_running():
+def managed_xray_running(context):
    try:
-        return xray_running(read_state())
+        return xray_running(read_state(context))
    except ProxyError:
        return False
-def require_supervised_xray(config):
+def require_supervised_xray(config, context):
-    state = managed_state()
+    state = managed_state(context)
    if not supervisor_running(state):
        raise ProxyError(
            "Xray работает без proxy-client start (его процесс завершён); "
@@ -720,7 +758,7 @@ def require_supervised_xray(config):
        raise ProxyError(
            "Xray запущен на {}:{}, а {} указывает {}:{}; чтобы применить конфиг, "
            "выполните proxy-client stop, затем proxy-client start".format(
-                state["address"], state["port"], config_home() / "config",
+                state["address"], state["port"], context.config_dir / "config",
                config.address, config.port,
            )
        )
@@ -756,9 +794,9 @@ def check_port_available(address, port):
        raise ProxyError("локальный порт {} занят или недоступен".format(port))
-def acquire_start_lock():
+def acquire_start_lock(context):
-    private_directory(state_home())
+    private_directory(context.state_dir)
-    lock = (state_home() / "lock").open("a")
+    lock = (context.state_dir / "lock").open("a")
    try:
        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
    except BlockingIOError:
@@ -832,8 +870,8 @@ def interrupt(_signum, _frame):
    raise KeyboardInterrupt
-def command_status(config):
+def command_status(config, context):
-    check_proxy(config)
+    check_proxy(config, context)
    if config.proxy_type == "external":
        print("{} (external) доступен по адресу {}:{}".format(config.name, config.address, config.port))
    else:
@@ -841,21 +879,21 @@ def command_status(config):
    return 0
-def command_env(config):
+def command_env(config, context):
-    check_proxy(config)
+    check_proxy(config, context)
    lines = ["{}={}".format(key, value) for key, value in environment_values(config)]
    sys.stdout.write("\n".join(lines) + "\n")
    return 0
-def command_run(config, remainder):
+def command_run(config, remainder, context):
    if not remainder or remainder[0] != "--" or len(remainder) == 1:
        raise ProxyError("использование: proxy-client run -- COMMAND ARG...")
    command = remainder[1:]
    if shutil.which(command[0]) is None:
        sys.stderr.write("Ошибка: команда не найдена в PATH: {}\n".format(command[0]))
        return 127
-    check_proxy(config)
+    check_proxy(config, context)
    child_environment = os.environ.copy()
    child_environment.update(dict(environment_values(config)))
    try:
@@ -866,10 +904,10 @@ def command_run(config, remainder):
    return exit_code(completed.returncode)
-def command_start(config, profile_file):
+def command_start(config, profile_file, context):
    if config.proxy_type != "xray":
        raise ProxyError(
-            "start доступен только для type=xray; измените {}".format(config_home() / "config")
+            "start доступен только для type=xray; измените {}".format(context.config_dir / "config")
        )
    try:
        loopback = ipaddress.ip_address(config.address).is_loopback
@@ -877,39 +915,43 @@ def command_start(config, profile_file):
        loopback = False
    if not loopback:
        raise ProxyError("для type=xray поле address должно быть loopback-адресом, например 127.0.0.1")
-    lock = acquire_start_lock()
+    lock = acquire_start_lock(context)
    try:
-        return run_managed_xray(config, profile_file)
+        return run_managed_xray(config, profile_file, context)
    finally:
        lock.close()
-def run_managed_xray(config, profile_file):
+def run_managed_xray(config, profile_file, context):
-    if state_path().exists():
+    if context.state_path.exists():
-        if xray_running(read_state()):
+        if xray_running(read_state(context)):
            raise ProxyError(
                "Xray остался от прошлого proxy-client start; сначала выполните proxy-client stop"
            )
-        remove_state_files()
+        remove_state_files(context)
    check_port_available(ipaddress.ip_address(config.address), config.port)
-    profile_path = Path(profile_file) if profile_file else config_home() / "default.url"
+    profile_path = Path(profile_file) if profile_file else context.config_dir / "default.url"
-    profile = load_profile(profile_path)
+    profile = load_profile(profile_path, context)
-    executable = resolve_xray()
+    executable = resolve_xray(context)
    check_xray_version(executable)
    write_private_json(
-        generated_config_path(), build_xray_config(profile, config.address, config.port)
+        context.generated_config_path, build_xray_config(profile, config.address, config.port)
    )
    child = None
    try:
-        run_xray_test(executable, generated_config_path())
+        run_xray_test(executable, context.generated_config_path)
        print("Xray: {} ({})".format(executable, XRAY_VERSION))
        print_summary(profile, config.port)
        # SIGTERM (от proxy-client stop) и SIGHUP обрабатываем как Ctrl+C.
        signal.signal(signal.SIGTERM, interrupt)
        signal.signal(signal.SIGHUP, interrupt)
-        child = subprocess.Popen([executable, "run", "-c", str(generated_config_path())])
+        child = subprocess.Popen(
            [executable, "run", "-c", str(context.generated_config_path)],
            stdout=context.xray_output,
            stderr=context.xray_output,
        )
        write_private_json(
-            state_path(),
+            context.state_path,
            {
                "supervisor_pid": os.getpid(),
                "xray_pid": child.pid,
@@ -924,8 +966,8 @@ def run_managed_xray(config, profile_file):
            raise ProxyError("Xray не открыл локальный порт {}".format(config.port))
        diagnose_ip(config)
        print(
-            "Управляемый Xray работает на {}:{}; остановка: Ctrl+C или proxy-client stop".format(
+            "Управляемый Xray работает на {}:{}; остановка: {}".format(
-                config.address, config.port
+                config.address, config.port, context.stop_hint
            ),
            flush=True,
        )
@@ -940,11 +982,11 @@ def run_managed_xray(config, profile_file):
            except subprocess.TimeoutExpired:
                child.kill()
                child.wait()
-        remove_state_files()
+        remove_state_files(context)
-def command_stop():
+def command_stop(context):
-    state = managed_state()
+    state = managed_state(context)
    # Живой супервизор сам остановит Xray; иначе Xray гасим напрямую.
    running_supervisor = supervisor_running(state)
    target = state["supervisor_pid"] if running_supervisor else state["xray_pid"]
@@ -958,17 +1000,196 @@ def command_stop():
            os.kill(state["xray_pid"], signal.SIGKILL)
        if not wait_until(stopped, STOP_TIMEOUT):
            raise ProxyError("управляемый Xray не остановился за {} с".format(2 * STOP_TIMEOUT + 1))
-    remove_state_files()
+    remove_state_files(context)
    print("Управляемый Xray остановлен")
    return 0
 SERVICE_UNIT = """# Managed by proxy-client
 [Unit]
 Description=Proxy client (Xray)
 After=network.target
 StartLimitIntervalSec=0
 [Service]
 Type=simple
 User=proxy-client
 Group=proxy-client
 RuntimeDirectory=proxy-client
 RuntimeDirectoryMode=0700
 UMask=0077
 ExecStart=/usr/local/lib/proxy-client/proxy-client service run
 Restart=on-failure
 RestartSec=5
 TimeoutStopSec=15
 StandardOutput=journal
 StandardError=journal
 NoNewPrivileges=yes
 ProtectSystem=strict
 ProtectHome=yes
 PrivateTmp=yes
 RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
 [Install]
 WantedBy=multi-user.target
 """
 def report_journal_storage(root):
    # Приоритет каталогов соответствует journald.conf; одноимённый drop-in
    # из /etc перекрывает поставляемый системой файл.
    directories = ["usr/lib/systemd", "usr/local/lib/systemd", "run/systemd", "etc/systemd"]
    main = next((root / directory / "journald.conf"
                 for directory in reversed(directories)
                 if (root / directory / "journald.conf").exists()), None)
    dropins = {}
    for directory in directories:
        for path in (root / directory / "journald.conf.d").glob("*.conf"):
            dropins[path.name] = path
    storage = None
    for path in ([main] if main else []) + [dropins[name] for name in sorted(dropins)]:
        section = ""
        for line in path.read_text().splitlines():
            line = line.strip()
            if line.startswith("["):
                section = line
            elif section == "[Journal]" and re.match(r"Storage\s*=", line):
                storage = line.split("=", 1)[1].strip() or None
    if storage is None:
        print("journald: Storage не задан; сохранение журнала зависит от сборки systemd. "
              "Проверьте journalctl --list-boots после перезагрузки.")
        return
    persistent = storage == "persistent" or (
        storage == "auto" and (root / "var/log/journal").is_dir())
    print("journald: Storage={}; журнал {} между загрузками (по конфигурации).".format(
        storage, "сохраняется" if persistent else "не сохраняется"))
 def make_install_directory(path):
    if path.is_dir():
        return
    make_install_directory(path.parent)
    path.mkdir()
    path.chmod(0o755)
 def install_file(target, data, mode):
    make_install_directory(target.parent)
    descriptor, temporary = tempfile.mkstemp(prefix=".install-", dir=str(target.parent))
    try:
        with os.fdopen(descriptor, "wb") as stream:
            stream.write(data)
            os.fchmod(stream.fileno(), mode)
        os.replace(temporary, str(target))
    finally:
        if os.path.exists(temporary):
            os.unlink(temporary)
 def service_install(args):
    source = Path(args.config_dir)
    xray = Path(args.xray)
    root = Path(args.root) if args.root else Path("/")
    if not all(path.is_absolute() for path in (source, xray, root)):
        raise ProxyError("config-dir, xray и root должны быть абсолютными путями")
    if args.root and (args.enable or args.start):
        raise ProxyError("--root несовместим с --enable и --start")
    if not args.root and os.geteuid() != 0:
        raise ProxyError("системная установка требует root")
    settings = root / "etc/proxy-client"
    # При обновлении служба уже имеет собственные настройки вне HOME.
    if not (settings / "config").exists():
        config = parse_config((source / "config").read_text(encoding="utf-8"))
        if config.proxy_type != "xray" or not ipaddress.ip_address(config.address).is_loopback:
            raise ProxyError("службе нужен type=xray и loopback-адрес")
    if not (settings / "default.url").exists():
        load_profile(source / "default.url", user_context())
    check_xray_version(str(xray))
    files = {
        "usr/local/lib/proxy-client/proxy-client": (Path(__file__).read_bytes(), 0o755),
        "usr/local/lib/proxy-client/xray": (xray.read_bytes(), 0o755),
        "etc/systemd/system/proxy-client.service": (SERVICE_UNIT.encode(), 0o644),
        "usr/lib/sysusers.d/proxy-client.conf": (
            b'u proxy-client - "Proxy client" /nonexistent /usr/sbin/nologin\n', 0o644),
    }
    manifest = root / "usr/local/lib/proxy-client/installed.json"
    pending = manifest.with_name("installed.pending.json")
    # До любой записи проверяем все назначения и компоненты пути.
    targets = [root / name for name in files] + [
        manifest, pending, settings, settings / "config", settings / "default.url"]
    for target in targets:
        if any(part.is_symlink() for part in [target, *target.parents]):
            raise ProxyError("установка через симлинк запрещена: {}".format(target))
    owned = json.loads(manifest.read_text()) if manifest.exists() else {}
    interrupted = json.loads(pending.read_text()) if pending.exists() else {}
    for name in files:
        target = root / name
        if target.exists() and (
            not target.is_file() or
            hashlib.sha256(target.read_bytes()).hexdigest() not in
            [owned.get(name)] + interrupted.get(name, [])
        ):
            raise ProxyError("чужой или изменённый файл: {}".format(target))
    if not manifest.exists() and not pending.exists() and settings.exists():
        raise ProxyError("чужой каталог настроек: {}".format(settings))
    make_install_directory(manifest.parent)
    manifest.parent.chmod(0o755)
    # До замены сохраняем допустимые старые и новые хеши. После сбоя повтор
    # распознает уже записанную часть, не принимая произвольные чужие файлы.
    planned = {}
    for name, (data, _) in files.items():
        target = root / name
        planned[name] = [hashlib.sha256(data).hexdigest()]
        if target.exists():
            planned[name].append(hashlib.sha256(target.read_bytes()).hexdigest())
    install_file(pending, json.dumps(planned).encode(), 0o644)
    for name, (data, mode) in files.items():
        install_file(root / name, data, mode)
    settings.mkdir(parents=True, exist_ok=True)
    settings.chmod(0o750)
    for name in ("config", "default.url"):
        target = settings / name
        if not target.exists():
            install_file(target, (source / name).read_bytes(), 0o640)
    install_file(manifest, json.dumps({
        name: hashlib.sha256(data).hexdigest() for name, (data, _) in files.items()
    }).encode(), 0o644)
    pending.unlink()
    if not args.root:
        import grp
        subprocess.run(["systemd-sysusers", "/usr/lib/sysusers.d/proxy-client.conf"], check=True)
        gid = grp.getgrnam("proxy-client").gr_gid
        for path in (settings, settings / "config", settings / "default.url"):
            os.chown(str(path), 0, gid)
        subprocess.run(["systemctl", "daemon-reload"], check=True)
        if args.enable:
            subprocess.run(["systemctl", "enable", "proxy-client.service"], check=True)
        if args.start:
            subprocess.run(["systemctl", "start", "proxy-client.service"], check=True)
    print("Служба установлена. Конфигурация сохранена; автоматического перезапуска нет.")
    report_journal_storage(root)
    return 0
 def build_parser():
    parser = argparse.ArgumentParser(
        prog="proxy-client",
        description="Безопасный запуск команд через явно настроенный прокси.",
    )
    parser.add_argument("--profile", default="default", help="имя пользовательского профиля")
    subparsers = parser.add_subparsers(dest="subcommand")
    service = subparsers.add_parser("service", help="системная служба")
    actions = service.add_subparsers(dest="service_action", required=True)
    serve = actions.add_parser("run", help="запуск из systemd")
    serve.add_argument("--config-dir", default="/etc/proxy-client")
    serve.add_argument("--runtime-dir", default="/run/proxy-client")
    serve.add_argument("--xray", default="/usr/local/lib/proxy-client/xray")
    setup = actions.add_parser("install", help="установить системную службу")
    setup.add_argument("--config-dir", required=True)
    setup.add_argument("--xray", required=True)
    setup.add_argument("--root", help="изолированный корень без systemctl")
    setup.add_argument("--enable", action="store_true")
    setup.add_argument("--start", action="store_true")
    install_parser = subparsers.add_parser("install", help="установить проверенный Xray")
    install_parser.add_argument(
        "--replace", action="store_true", help="заменить существующий ~/.local/bin/xray"
@@ -992,20 +1213,28 @@ def main():
        return 2
    try:
        if arguments.subcommand == "service":
            if arguments.profile != "default":
                raise ProxyError("service не использует пользовательские профили")
            if arguments.service_action == "install":
                return service_install(arguments)
            context = service_context(arguments)
            return command_start(load_config(context), None, context)
        context = user_context(arguments.profile)
        if arguments.subcommand == "install":
-            return command_install(arguments.replace)
+            return command_install(arguments.replace, context=context)
        if arguments.subcommand == "stop":
-            return command_stop()
+            return command_stop(context)
-        config = load_config()
+        config = load_config(context)
        if arguments.subcommand == "status":
-            return command_status(config)
+            return command_status(config, context)
        if arguments.subcommand == "env":
-            return command_env(config)
+            return command_env(config, context)
        if arguments.subcommand == "run":
-            return command_run(config, arguments.arguments)
+            return command_run(config, arguments.arguments, context)
        if arguments.subcommand == "start":
-            return command_start(config, arguments.profile_file)
+            return command_start(config, arguments.profile_file, context)
-    except (ProxyError, OSError) as error:
+    except (ProxyError, OSError, ValueError, subprocess.CalledProcessError) as error:
        sys.stderr.write("Ошибка: {}\n".format(error))
        return 1
    return 2
@@ -1,7 +1,7 @@
 # proxy-client
 `proxy-client` — переносимый Linux/Bash-интерфейс для запуска команд через
-внешний прокси или через управляемый пользовательский Xray. Он добавляет команды
+внешний прокси или через управляемый Xray. Он добавляет команды
 `proxy_on`, `proxy_off`, `pclaude` и `pcodex`, но не подменяет обычные `claude`
 и `codex`.
@@ -78,7 +78,7 @@ source ~/.bash_custom
 ## Как выбирается прокси
-Режим определяется только машинным файлом
+Без выбора профиля режим определяется файлом
 `~/.config/proxy-client/config`:
 | Машинный конфиг | Используется | Что запускать |
@@ -212,14 +212,55 @@ proxy-client install
 proxy-client start
 ```
-Другой закрытый профиль можно выбрать без замены `default.url`:
+Другой файл VLESS-ссылки можно выбрать без замены `default.url`:
 ```bash
 proxy-client start -f ~/.config/proxy-client/work.url
 ```
-Для переключения профиля сначала выполните `proxy-client stop`. Все файлы с
+Для смены ссылки работающего экземпляра сначала выполните `proxy-client stop`.
-настоящими VLESS-ссылками должны иметь права `600` и не должны попадать в Git.
+Все файлы с настоящими VLESS-ссылками должны иметь права `600` и не должны
 попадать в Git.
 ## Именованные профили
 Профиль объединяет настройки локального входа, исключения и, для Xray,
 VLESS-ссылку. Без указания имени используется `default`: прежние `config` и
 `default.url` остаются на своих местах. Дополнительные профили живут в
 `~/.config/proxy-client/profiles/<имя>/`. При заданном `XDG_CONFIG_HOME`
 вместо `~/.config` используется этот каталог.
 Например, создайте профиль `work`:
 ```bash
 mkdir -p ~/.config/proxy-client/profiles/work
 cp ~/.config/proxy-client/examples/config.xray ~/.config/proxy-client/profiles/work/config
 $EDITOR ~/.config/proxy-client/profiles/work/config
 ```
 В `config` задайте свободный порт, например `12335`, если основной прокси
 занимает `12334`. Поместите VLESS-ссылку в `profiles/work/default.url` и
 ограничьте доступ:
 ```bash
 chmod 600 ~/.config/proxy-client/profiles/work/default.url
 proxy-client --profile work start
 ```
 Команда остаётся в терминале. В другом терминале можно проверить или
 остановить именно этот профиль:
 ```bash
 proxy-client --profile work status
 proxy-client --profile work stop
 ```
 Параметр `--profile` ставится перед подкомандой. Неизвестный профиль даёт
 ошибку; перехода на `default` нет. Разные профили могут работать одновременно
 на разных портах. Остановка одного не затрагивает остальные.
 `start -f FILE` переопределяет только файл ссылки выбранного профиля на этот
 запуск. Его порт и исключения по-прежнему берутся из `config`.
 ## Ежедневное использование
@@ -243,6 +284,24 @@ proxy-client start -f ~/.config/proxy-client/work.url
 обёрнуты и не выполняют предварительную проверку, но после `proxy_on` наследуют
 прокси-переменные, как и любой другой дочерний процесс.
 Для именованного профиля:
 ```bash
 proxy_on --profile work
 pclaude --proxy-profile work
 pcodex --proxy-profile work --search
 proxy-client --profile work run -- COMMAND ARG...
 ```
 У `pclaude` и `pcodex` параметр `--proxy-profile` должен быть первым.
 Обычный `--profile` передаётся запускаемой программе.
 `proxy_on --profile work` меняет окружение терминала, но не профиль по
 умолчанию: обычный `codex` наследует это окружение, а `pcodex` без параметра
 выберет `default`. `proxy_off` только очищает переменные — работающие прокси,
 включая системную службу, остаются запущенными. `myip` использует текущее
 окружение.
 ### Жизненный цикл Xray
 ```bash
@@ -253,7 +312,7 @@ proxy-client stop
 ```
 `start` сначала проверяет версию и конфигурацию Xray, затем остаётся на переднем
-плане. Systemd, фоновый автозапуск и скрытый запуск из `run` не используются.
+плане. Скрытого запуска из `run` нет; системная служба устанавливается отдельно.
 Один loopback-порт принимает HTTP CONNECT и SOCKS5.
 Остановить Xray можно двумя способами: `Ctrl+C` в окне `start` или
@@ -262,7 +321,102 @@ proxy-client stop
 остаться работать: `status` и `env` тогда сообщат об ошибке, а `stop` добьёт его
 и уберёт файлы. `stop` работает и после изменения машинного типа на `external`.
-Второй `start`, пока первый работает, завершится ошибкой.
+Второй `start` того же профиля, пока первый работает, завершится ошибкой.
 ## Системная служба
 Этот режим нужен, когда приложения должны получать прокси после загрузки
 Linux, до входа пользователя. Требуются systemd, `systemd-sysusers` и права
 администратора для установки. Служба одна; именованные профили остаются
 пользовательскими.
 Сначала подготовьте и проверьте профиль Xray обычным ручным запуском. Перед
 запуском службы остановите ручной экземпляр, если он занимает тот же порт.
 Установите службу, указав каталог настроек и уже установленный Xray:
 ```bash
 sudo "$HOME/.local/bin/proxy-client" service install \
  --config-dir "$HOME/.config/proxy-client" \
  --xray "$HOME/.local/bin/xray" --enable --start
 ```
 В качестве `--config-dir` можно указать каталог именованного профиля.
 Пути должны быть абсолютными. `--enable` включает запуск при загрузке,
 `--start` запускает сейчас. Без этих параметров команда только устанавливает
 файлы и регистрирует службу.
 Установщик копирует настройки в `/etc/proxy-client/`, а CLI и Xray — в
 `/usr/local/lib/proxy-client/`. Служба больше не зависит от домашнего каталога.
 Изменения исходного пользовательского профиля на неё не влияют. Системные
 настройки имеют владельца `root`, группу `proxy-client` и права `640`;
 каталог — `750`. Процесс работает под отдельным пользователем `proxy-client`.
 Временные файлы находятся в закрытом `/run/proxy-client/`.
 Управление и журнал:
 ```bash
 sudo systemctl status proxy-client
 sudo systemctl stop proxy-client
 sudo systemctl start proxy-client
 sudo systemctl restart proxy-client
 sudo journalctl -u proxy-client -b
 sudo journalctl -u proxy-client -f
 ```
 Для изменения настроек отредактируйте `/etc/proxy-client/config` или
 `/etc/proxy-client/default.url` с правами администратора, затем перезапустите
 службу. Сохраняйте владельца, группу и права файлов.
 После аварии systemd повторяет запуск с паузой в пять секунд. Явная команда
 `stop` оставляет службу остановленной, но не отменяет запуск при следующей
 загрузке. Чтобы отключить автозапуск и остановить её сразу:
 ```bash
 sudo systemctl disable --now proxy-client
 ```
 Чтобы включить обратно:
 ```bash
 sudo systemctl enable --now proxy-client
 ```
 При обновлении повторите установку из актуальной копии пакета. Существующие
 системные настройки сохраняются; исходный домашний профиль уже не нужен:
 ```bash
 sudo "$HOME/.local/bin/proxy-client" service install \
  --config-dir /etc/proxy-client --xray "$HOME/.local/bin/xray"
 sudo systemctl restart proxy-client
 ```
 Работающий процесс сам не перезапускается. Чужие или вручную изменённые
 исполняемые файлы и unit-файл установщик не заменяет; изменения параметров
 systemd делайте через `sudo systemctl edit proxy-client`. Файлы заменяются
 по одному атомарно, общего отката всей установки при сбое нет. После
 устранения причины сбоя повторите установку: журнал незавершённой установки
 позволяет продолжить её, сохраняя проверку принадлежности файлов.
 Вывод CLI поступает в journald. Сырой вывод Xray в системном режиме подавлен,
 чтобы сообщения с фрагментами конфигурации не раскрывали секреты; детальные
 сетевые журналы Xray поэтому недоступны. Установщик сообщает настройку хранения
 journald, но не меняет её. Сохранение журнала после перезагрузки зависит от
 настроек машины; проверить предыдущие загрузки можно через
 `sudo journalctl --list-boots`.
 Открытый локальный порт не гарантирует доступность удалённого сервера.
 На ноутбуке сеть может появиться позже службы. Приложениям без повторения
 запросов понадобится отдельная настройка ожидания готовности.
 Для `proxy_on`, `pclaude`, `pcodex` и `run` системная служба — внешний прокси:
 укажите в нужном пользовательском профиле `type = external`, адрес
 `127.0.0.1` и порт службы. Дополнительный профиль типа `xray` запускайте вручную
 на другом порту. Пользовательский `stop` системной службой не управляет.
 Для проверки размещения файлов без установки на машину есть
 `service install --config-dir DIR --xray FILE --root /absolute/staging`.
 Этот режим не вызывает systemd, не создаёт системную учётную запись и не
 назначает ей владельцев; он несовместим с `--enable` и `--start`.
 ## Прокси в настройках Codex и Claude Code
@@ -15,7 +15,7 @@ from urllib.parse import quote
 REPO_ROOT = Path(__file__).resolve().parents[1]
-CLI = REPO_ROOT / "proxy-client/.local/bin/proxy-client"
+CLI = Path(os.environ.get("PROXY_CLIENT_TEST_CLI", str(REPO_ROOT / "proxy-client/.local/bin/proxy-client")))
 UUID = "11111111-2222-4333-8444-555555555555"
 PATH_SECRET = "/tenant/PATH_SENTINEL_a1b2"
 PROFILE = (
@@ -28,7 +28,7 @@ REALITY_PROFILE = (
    "vless://{}@edge.example:443?type=tcp&security=reality&encryption=none"
    "&flow=xtls-rprx-vision&sni=front.example&fp=chrome&pbk={}&sid={}#Synthetic"
 ).format(UUID, PBK, SID)
-READY = "остановка: Ctrl+C или proxy-client stop"
+READY = "Управляемый Xray работает на"
 # Поддельный Xray — симлинк на интерпретатор Python: тогда /proc/PID/exe
 # совпадает с разрешённым путём к xray, как у настоящего бинарника.
@@ -102,6 +102,56 @@ class ManagedXrayTest(unittest.TestCase):
        self.write_machine_config()
        self.profile = self.write_profile(self.config_dir / "default.url")
    def test_profiles_run_independently_and_export_selected_environment(self):
        first = self.start()
        named = self.config_dir / "profiles/second"
        named.mkdir(parents=True)
        second_port = free_port()
        (named / "config").write_text(
            (self.config_dir / "config").read_text().replace(str(self.port), str(second_port)))
        # Переопределение -f должно работать без default.url у второго профиля.
        second = self.start("-f", str(self.profile), cli_prefix=["--profile", "second", "start"])
        self.assertIn("proxy-client --profile second stop", self.start_output)
        status = self.run_cli("--profile", "second", "status")
        self.assertEqual(status.returncode, 0, status.stderr)
        env = self.run_cli("--profile", "second", "env")
        self.assertIn("127.0.0.1:" + str(second_port), env.stdout)
        run = self.run_cli("--profile", "second", "run", "--", sys.executable,
                           "-c", "import os,sys; print(os.environ['HTTP_PROXY']); sys.exit(23)")
        self.assertEqual(run.returncode, 23, run.stderr)
        self.assertIn("127.0.0.1:" + str(second_port), run.stdout)
        collision = self.run_cli("--profile", "second", "start", "-f", str(self.profile))
        self.assertEqual(collision.returncode, 1)
        stopped = self.run_cli("--profile", "second", "stop")
        self.assertEqual(stopped.returncode, 0, stopped.stderr)
        second.communicate(timeout=10)
        self.assertIsNone(first.poll())
        self.assertEqual(self.run_cli("--profile", "default", "status").returncode, 0)
        self.assertEqual(self.run_cli("stop").returncode, 0)
        first.communicate(timeout=10)
    def test_service_run_uses_explicit_paths_and_pinned_binary(self):
        runtime = self.root / "service-runtime"
        process = self.start(cli_prefix=[
            "service", "run", "--config-dir", str(self.config_dir),
            "--runtime-dir", str(runtime), "--xray", str(self.xray),
        ], PATH="/usr/bin:/bin")
        self.assertTrue((runtime / "state.json").exists())
        self.assertFalse(self.state_dir.exists())
        process.terminate()
        process.communicate(timeout=10)
        self.assertEqual(process.returncode, 0)
        self.assertFalse((runtime / "client.json").exists())
    def test_system_profile_permission_hint_preserves_group_read(self):
        self.profile.chmod(0o644)
        result = self.run_cli("service", "run", "--config-dir", str(self.config_dir),
                              "--runtime-dir", str(self.root / "system-runtime"),
                              "--xray", str(self.xray))
        self.assertEqual(1, result.returncode)
        self.assertIn("chmod 640", result.stderr)
        self.assertIn("chown root:proxy-client", result.stderr)
    def write_machine_config(self, address="127.0.0.1"):
        self.config_dir.mkdir(parents=True, exist_ok=True)
        (self.config_dir / "config").write_text(
@@ -126,10 +176,10 @@ class ManagedXrayTest(unittest.TestCase):
            check=False,
        )
-    def start(self, *arguments, **environment):
+    def start(self, *arguments, cli_prefix=None, **environment):
        """Запускает start и ждёт строку готовности; возвращает процесс."""
        process = subprocess.Popen(
-            [str(CLI), "start"] + list(arguments),
+            [str(CLI)] + (cli_prefix or ["start"]) + list(arguments),
            cwd=str(self.root),
            env=dict(self.environment, **environment),
            text=True,
@@ -33,8 +33,13 @@ assert_eq() {
 PROXY_CLIENT_BIN="$TEST_ROOT/proxy-client"
 cat > "$PROXY_CLIENT_BIN" <<'EOF'
 #!/usr/bin/env bash
 if [ -n "${FAKE_CALL_LOG:-}" ]; then
  printf '<%s>\n' "$@" >> "$FAKE_CALL_LOG"
 fi
 if [ "$1" = env ]; then
  printf '%s\n' "$FAKE_ENV_OUTPUT"
 elif [ "$#" -eq 3 ] && [ "$1" = --profile ] && [ "$2" = work ] && [ "$3" = env ]; then
  printf '%s\n' "$FAKE_PROFILE_ENV_OUTPUT"
 else
  printf '<%s>\n' "$@"
 fi
@@ -69,6 +74,42 @@ source "$SHELL_MODULE"
 )
 ok "proxy_on применяет восемь переменных"
 # Выбор профиля меняет окружение только текущей оболочки.
 (
  unset "${PROXY_KEYS[@]}"
  FAKE_ENV_OUTPUT="$VALID_ENV" \
    FAKE_PROFILE_ENV_OUTPUT='HTTP_PROXY=http://work.test:4321
 HTTPS_PROXY=http://work.test:4321
 ALL_PROXY=socks5://work.test:4321
 NO_PROXY=work.test,localhost
 http_proxy=http://work.test:4321
 https_proxy=http://work.test:4321
 all_proxy=socks5://work.test:4321
 no_proxy=work.test,localhost' \
    proxy_on --profile work >/dev/null
  assert_eq http://work.test:4321 "$HTTP_PROXY" "proxy_on не выбрал профиль work"
  assert_eq socks5://work.test:4321 "$all_proxy" "SOCKS выбранного профиля"
  assert_eq work.test,localhost "$NO_PROXY" "исключения выбранного профиля"
 )
 ok "proxy_on выбирает именованный профиль"
 # Неверный синтаксис proxy_on отклоняется до изменения окружения.
 assert_invalid_proxy_on() (
  for key in "${PROXY_KEYS[@]}"; do export "$key=old"; done
  local rc=0
  FAKE_ENV_OUTPUT="$VALID_ENV" proxy_on "$@" >/dev/null 2>&1 || rc=$?
  assert_eq 2 "$rc" "proxy_on принял неверные аргументы: $*"
  for key in "${PROXY_KEYS[@]}"; do
    assert_eq old "${!key}" "$key изменился после неверных аргументов"
  done
 )
 assert_invalid_proxy_on env
 assert_invalid_proxy_on --profile
 assert_invalid_proxy_on --profile ""
 assert_invalid_proxy_on --profile work extra
 assert_invalid_proxy_on --unknown work
 ok "proxy_on отклоняет неверные аргументы без изменения окружения"
 # Ошибка CLI или непонятный вывод не меняют окружение ни на одну переменную.
 for case_spec in "1|$VALID_ENV" "0|$VALID_ENV
 EXTRA_PROXY=bad" "0|BROKEN-LINE"; do
@@ -85,15 +126,33 @@ EXTRA_PROXY=bad" "0|BROKEN-LINE"; do
 done
 ok "неуспешный env не меняет окружение"
 # Даже пригодный вывод не применяется, если проверка выбранного прокси не прошла.
 (
  for key in "${PROXY_KEYS[@]}"; do export "$key=old"; done
  unset no_proxy
  if FAKE_RC=1 FAKE_PROFILE_ENV_OUTPUT="$VALID_ENV" proxy_on --profile work >/dev/null 2>&1; then
    fail "proxy_on принял отказ проверки выбранного профиля"
  fi
  for key in "${PROXY_KEYS[@]}"; do
    if [[ "$key" == no_proxy ]]; then
      [ -z "${!key+set}" ] || fail "$key появился после ошибки"
    else
      assert_eq old "${!key}" "$key изменился после ошибки выбранного профиля"
    fi
  done
 )
 ok "отказ проверки выбранного профиля сохраняет окружение"
 # proxy_off очищает оба регистра.
 (
  for key in "${PROXY_KEYS[@]}"; do export "$key=x"; done
-  proxy_off >/dev/null
+  FAKE_CALL_LOG="$TEST_ROOT/off-calls" proxy_off >/dev/null
  [ ! -e "$TEST_ROOT/off-calls" ] || fail "proxy_off вызвал CLI"
  for key in "${PROXY_KEYS[@]}"; do
    [ -z "${!key+set}" ] || fail "$key не очищен"
  done
 )
-ok "proxy_off очищает восемь переменных"
+ok "proxy_off очищает восемь переменных без вызова CLI"
 # Обёртки передают CLI команду, аргументы и код возврата без искажений.
 (
@@ -116,6 +175,60 @@ ok "proxy_off очищает восемь переменных"
 )
 ok "pclaude и pcodex передают аргументы и код выхода"
 # Ведущий --proxy-profile относится к прокси, обычный --profile — к программе.
 (
  for wrapper in pclaude pcodex; do
    rc=0
    output="$(FAKE_RC=42 "$wrapper" --proxy-profile work --profile personal "a b" "")" || rc=$?
    assert_eq 42 "$rc" "$wrapper не сохранил код возврата с профилем"
    assert_eq $'<--profile>\n<work>\n<run>\n<-->\n<'"${wrapper#p}"$'>\n<--profile>\n<personal>\n<a b>\n<>' "$output" \
      "$wrapper исказил выбор профиля или аргументы ребенка"
  done
 )
 ok "обёртки выбирают профиль прокси и сохраняют аргументы ребенка"
 # Отсутствующее имя профиля не должно запускать дочернюю команду.
 (
  for wrapper in pclaude pcodex; do
    for empty_name in missing empty; do
      args=(--proxy-profile)
      if [[ "$empty_name" == empty ]]; then args+=(""); fi
      rc=0
      output="$("$wrapper" "${args[@]}" 2>/dev/null)" || rc=$?
      assert_eq 2 "$rc" "$wrapper принял --proxy-profile без имени"
      assert_eq "" "$output" "$wrapper вызвал CLI без имени профиля"
    done
  done
 )
 ok "обёртки отклоняют --proxy-profile без имени"
 # Только ведущий --proxy-profile выбирает профиль прокси.
 (
  for wrapper in pclaude pcodex; do
    output="$("$wrapper" --profile personal --proxy-profile child "a b" "")"
    assert_eq $'<run>\n<-->\n<'"${wrapper#p}"$'>\n<--profile>\n<personal>\n<--proxy-profile>\n<child>\n<a b>\n<>' "$output" \
      "$wrapper забрал аргументы ребенка"
  done
 )
 ok "обычный --profile и неведущий --proxy-profile остаются ребенку"
 # Запуск с профилем не меняет окружение вызывающей оболочки.
 (
  for key in "${PROXY_KEYS[@]}"; do export "$key=old"; done
  unset no_proxy
  for wrapper in pclaude pcodex; do
    "$wrapper" --proxy-profile work >/dev/null
    for key in "${PROXY_KEYS[@]}"; do
      if [[ "$key" == no_proxy ]]; then
        [ -z "${!key+set}" ] || fail "$wrapper экспортировал $key"
      else
        assert_eq old "${!key}" "$wrapper изменил $key"
      fi
    done
  done
 )
 ok "обёртки сохраняют окружение вызывающей оболочки"
 # .bash_custom подключает и общие функции, и proxy-модуль.
 (
  home="$TEST_ROOT/home"
@@ -0,0 +1,212 @@
 """Публичный CLI профилей и установка в изолированный корень."""
 import os
 import subprocess
 import tempfile
 import unittest
 from pathlib import Path
 CLI = Path(__file__).resolve().parents[1] / 'proxy-client/.local/bin/proxy-client'
 class ProfilesServiceTest(unittest.TestCase):
    def setUp(self):
        tmp = tempfile.TemporaryDirectory()
        self.addCleanup(tmp.cleanup)
        self.root = Path(tmp.name)
        self.config = self.root / 'config/proxy-client'
        self.config.mkdir(parents=True)
        self.env = dict(os.environ, HOME=str(self.root), XDG_CONFIG_HOME=str(self.root / 'config'),
                        XDG_STATE_HOME=str(self.root / 'state'))
    def cli(self, *args):
        return subprocess.run([str(CLI), *map(str, args)], env=self.env,
                              capture_output=True, text=True, timeout=15)
    def test_unknown_profile_never_falls_back_even_for_stop(self):
        for command in ('status', 'env', 'run', 'start', 'stop'):
            result = self.cli('--profile', 'missing', command)
            self.assertEqual(result.returncode, 1, result.stderr)
            self.assertIn('неизвестный профиль', result.stderr)
        result = self.cli('--profile', '../escape', 'stop')
        self.assertEqual(result.returncode, 1)
        self.assertIn('имя профиля', result.stderr)
    def install_args(self):
        source = self.root / 'source'
        source.mkdir(exist_ok=True)
        (source / 'config').write_text('[proxy]\ntype=xray\nname=Service\nno_proxy_extra=\naddress=127.0.0.1\nport=12345\n')
        (source / 'default.url').write_text(
            'vless://11111111-2222-4333-8444-555555555555@cdn.example:443'
            '?type=xhttp&security=tls&encryption=none&sni=cdn.example&fp=chrome&path=%2Ftest\n')
        (source / 'default.url').chmod(0o600)
        xray = self.root / 'xray'
        xray.write_text('#!/bin/sh\n[ "$1" != version ] || echo "Xray 26.10.10 (fake)"\nexit 0\n')
        xray.chmod(0o755)
        return ['service', 'install', '--config-dir', source, '--xray', xray,
                '--root', self.root / 'stage']
    def test_staged_install_is_standalone_and_preserves_config(self):
        args = self.install_args()
        result = self.cli(*args)
        self.assertEqual(result.returncode, 0, result.stderr)
        stage = self.root / 'stage'
        unit = (stage / 'etc/systemd/system/proxy-client.service').read_text()
        self.assertIn('User=proxy-client', unit)
        self.assertIn('Restart=on-failure', unit)
        self.assertIn('RuntimeDirectoryMode=0700', unit)
        self.assertIn('StandardOutput=journal', unit)
        self.assertNotIn(str(self.root), unit)
        self.assertTrue((stage / 'usr/local/lib/proxy-client/xray').is_file())
        self.assertTrue((stage / 'usr/lib/sysusers.d/proxy-client.conf').is_file())
        config = stage / 'etc/proxy-client/config'
        config.write_text(config.read_text() + '# preserved\n')
        result = self.cli(*args)
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertIn('# preserved', config.read_text())
        self.assertEqual((stage / 'etc/proxy-client/default.url').stat().st_mode & 0o777, 0o640)
        self.assertIn('journald', result.stdout)
    def test_install_refuses_foreign_files_before_writing(self):
        args = self.install_args()
        target = self.root / 'stage/etc/systemd/system/proxy-client.service'
        target.parent.mkdir(parents=True)
        target.write_text('foreign unit')
        result = self.cli(*args)
        self.assertEqual(result.returncode, 1)
        self.assertEqual(target.read_text(), 'foreign unit')
        self.assertFalse((self.root / 'stage/usr/local/lib/proxy-client/xray').exists())
    def test_install_reports_journal_storage_without_changing_policy(self):
        args = self.install_args()
        policy = self.root / 'stage/etc/systemd/journald.conf.d/storage.conf'
        policy.parent.mkdir(parents=True)
        policy.write_text('[Journal]\nStorage=volatile\n')
        result = self.cli(*args)
        self.assertEqual(result.returncode, 0, result.stderr)
        self.assertIn('Storage=volatile', result.stdout)
        self.assertIn('не сохраняется', result.stdout)
        self.assertEqual(policy.read_text(), '[Journal]\nStorage=volatile\n')
    def test_update_does_not_require_original_home_profile(self):
        args = self.install_args()
        first = self.cli(*args)
        self.assertEqual(0, first.returncode, first.stderr)
        for path in (self.root / 'source').iterdir():
            path.unlink()
        (self.root / 'source').rmdir()
        updated = self.cli(*args)
        self.assertEqual(0, updated.returncode, updated.stderr)
    def test_unspecified_journal_storage_is_not_guessed(self):
        result = self.cli(*self.install_args())
        self.assertEqual(0, result.returncode, result.stderr)
        self.assertIn('Storage не задан', result.stdout)
    def test_restrictive_umask_keeps_service_executable_accessible(self):
        args = self.install_args()
        result = subprocess.run(['bash', '-c', 'umask 077; exec "$@"', 'bash',
                                 str(CLI), *map(str, args)], env=self.env,
                                capture_output=True, text=True, timeout=15)
        self.assertEqual(0, result.returncode, result.stderr)
        stage = self.root / 'stage'
        for name in ('usr', 'usr/local', 'usr/local/lib', 'usr/local/lib/proxy-client'):
            self.assertEqual(0o755, (stage / name).stat().st_mode & 0o777, name)
    def test_interrupted_install_or_update_can_be_retried(self):
        args = self.install_args()
        injection = self.root / 'fault'
        injection.mkdir()
        (injection / 'sitecustomize.py').write_text(
            'import os, errno\noriginal = os.replace\n'
            'def replace(src, dst):\n'
            '    if str(dst).endswith("/xray"):\n'
            '        raise OSError(errno.ENOSPC, "synthetic disk full")\n'
            '    return original(src, dst)\n'
            'os.replace = replace\n')
        candidate = self.root / 'new-cli'
        candidate.write_bytes(CLI.read_bytes() + b'\n# next release\n')
        candidate.chmod(0o755)
        for updating in (False, True):
            with self.subTest(updating=updating):
                args[-1] = self.root / ('update' if updating else 'fresh')
                if updating:
                    result = self.cli(*args)
                    self.assertEqual(0, result.returncode, result.stderr)
                command = [str(candidate), *map(str, args)]
                failed = subprocess.run(command, env=dict(self.env, PYTHONPATH=str(injection)),
                                        capture_output=True, text=True, timeout=15)
                self.assertNotEqual(0, failed.returncode)
                retried = subprocess.run(command, env=self.env, capture_output=True,
                                         text=True, timeout=15)
                self.assertEqual(0, retried.returncode, retried.stderr)
    def test_system_actions_require_explicit_flags(self):
        args = self.install_args()[:-2]
        stage = self.root / 'system'
        fake = self.root / 'system-api'
        fake.mkdir()
        log = self.root / 'actions'
        # Подмена только ОС: корень файловой системы, root/group API и
        # внешние systemd-команды. CLI и установщик выполняются целиком.
        (fake / 'sitecustomize.py').write_text('''
 import os, pathlib, grp, types
 stage = os.environ['TEST_INSTALL_ROOT']
 OriginalPath = type(pathlib.Path())
 class StagedPath:
    def __new__(cls, *parts, **kwargs):
        if parts == ('/',):
            parts = (stage,)
        return OriginalPath(*parts, **kwargs)
 pathlib.Path = StagedPath
 os.geteuid = lambda: 0
 def group(name):
    assert os.path.exists(os.environ['TEST_INSTALL_ROOT'] + '/group-created')
    return types.SimpleNamespace(gr_gid=os.getgid())
 grp.getgrnam = group
 def chown(path, uid, gid):
    assert str(path).startswith(stage + '/')
    assert os.path.exists(stage + '/group-created')
    with open(os.environ['TEST_ACTION_LOG'], 'a') as stream:
        stream.write('chown ' + os.path.basename(path) + '\\n')
 os.chown = chown
 ''')
        for command in ('systemd-sysusers', 'systemctl'):
            path = fake / command
            path.write_text('#!/bin/sh\n'
                            'printf "%s %s\\n" "${0##*/}" "$*" >> "$TEST_ACTION_LOG"\n'
                            'if [ "${0##*/}" = systemd-sysusers ]; then\n'
                            '  touch "$TEST_INSTALL_ROOT/group-created"\nfi\n')
            path.chmod(0o755)
        env = dict(self.env, PYTHONPATH=str(fake), TEST_INSTALL_ROOT=str(stage),
                   TEST_ACTION_LOG=str(log), PATH=str(fake) + ':' + os.environ['PATH'])
        for flags in ([], ['--enable'], ['--start'], ['--enable', '--start']):
            with self.subTest(flags=flags):
                log.write_text('')
                result = subprocess.run([str(CLI), *map(str, args), *flags], env=env,
                                        capture_output=True, text=True, timeout=15)
                self.assertEqual(0, result.returncode, result.stderr)
                calls = log.read_text().splitlines()
                self.assertTrue(calls[0].startswith('systemd-sysusers '), calls)
                self.assertEqual(['chown proxy-client', 'chown config', 'chown default.url'], calls[1:4])
                self.assertIn('systemctl daemon-reload', calls)
                self.assertEqual('--enable' in flags, 'systemctl enable proxy-client.service' in calls)
                self.assertEqual('--start' in flags, 'systemctl start proxy-client.service' in calls)
                self.assertFalse(any('restart' in call for call in calls))
    def test_invalid_service_requests_do_not_install_files(self):
        args = self.install_args()
        for extra in (['--enable'], ['--start']):
            result = self.cli(*args, *extra)
            self.assertNotEqual(0, result.returncode)
            self.assertFalse((self.root / 'stage').exists())
        result = self.cli('--profile', 'work', *args)
        self.assertNotEqual(0, result.returncode)
        self.assertFalse((self.root / 'stage').exists())
        config = self.root / 'source/config'
        original = config.read_text()
        for invalid in (original.replace('type=xray', 'type=external'),
                        original.replace('127.0.0.1', '192.0.2.1')):
            config.write_text(invalid)
            result = self.cli(*args)
            self.assertNotEqual(0, result.returncode)
            self.assertFalse((self.root / 'stage').exists())