feat(proxy-client): добавлены профили и системная служба

Добавлены независимые пользовательские профили, их выбор в Bash-командах и явная установка службы systemd. Инструкции размещены в README пакета.

Проверка: 67 тестов на Python 3.8 и 3.14, shell-наборы и интеграция Bash с CLI. Загрузка ОС и восстановление настоящей службы требуют отдельной проверки.

tests/test_proxy_client_managed.py

@@ -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,47 @@ 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 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 +167,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,

tests/test_proxy_launchers.sh

@@ -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"

tests/test_proxy_profiles_service.py

@@ -0,0 +1,103 @@
+"""Публичный 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)