runspec-linux-core 0.3.0__tar.gz → 0.3.2__tar.gz

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/CHANGELOG.md

@@ -1,5 +1,46 @@
 # runspec-linux-core Changelog
 
+## [0.3.2] — 2026-06-21
+
+Add `venvs.py` — the pure logic behind three new `runspec-linux` runnables for
+Python virtualenv management:
+
+- **`create_venv(python, dest, *, run_as=None, become_method="sudo", group=None,
+  system_site_packages=False, upgrade_deps=False, clear=False, prompt=None)`** —
+  build a venv at `dest` from a *specific* interpreter (no system default
+  fallback; `python` must be an executable file), always with `--symlinks`. Then
+  creates `<dest>/logs` mode `2775` (setgid, so audit logs inherit the group) and
+  optionally `chgrp -R`s the venv to a shared `group` — the shape a service
+  account needs for a venv shared between several consoles.
+- **`install_into_venv(venv, packages="", *, project=None, editable=False,
+  upgrade=False, no_cache_dir=False, force_reinstall=False, run_as=None,
+  become_method="sudo")`** — `pip install` named packages and/or a local `project`
+  (a `pyproject.toml` directory or a wheel/sdist; `editable` for `-e`) into the
+  venv's bundled python. Package names reuse the shared injection guard.
+- **`configure_pip(index_url, *, extra_index_url=None, trusted_host=None,
+  cert=None, timeout=None, retries=None, proxy=None, require_virtualenv=False,
+  scope="user", venv=None, run_as=None, become_method="sudo")`** — write a
+  validated `pip.conf` (`[global]`) at user (`~/.config/pip/pip.conf`) or venv
+  (`<venv>/pip.conf`) scope for private-PyPI access.
+
+All three take a **runtime** `run_as` user (the service account is chosen
+per-invocation, so escalation is internal — `sudo -n -u <user>` or, via
+`become_method`, `su` — not a declarative `run_as`) and raise `ValueError` on bad
+input / `CommandError` on a failed step.
+
+## [0.3.1] — 2026-06-20
+
+Fix `enable_passwordless_sudo` failing with "visudo not installed" (and the same
+latent bug in `reboot_host`'s `shutdown` lookup). The console runs runnables over
+a non-login, non-interactive SSH shell whose `PATH` usually omits `/usr/sbin` and
+`/sbin`, so `shutil.which()` couldn't find these sbin-resident admin tools even
+when installed.
+
+New `_paths.which()` searches `PATH` first, then the standard sbin/bin dirs
+(`/usr/local/sbin`, `/usr/sbin`, `/sbin`, `/usr/local/bin`, `/usr/bin`, `/bin`),
+and returns an absolute path. `sudoers.py` and `power.py` resolve and invoke
+`visudo` / `shutdown` / `systemctl` through it, so they work regardless of `PATH`.
+
 ## [0.3.0] — 2026-06-20
 
 Add `enable_passwordless_sudo()` (new `sudoers.py`) — the one-time bootstrap that

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: runspec-linux-core
-Version: 0.3.0
+Version: 0.3.2
 Summary: Pure-Python Linux system-admin helpers — the importable core behind runspec-linux (no runspec dependency, no runnables)
 Requires-Python: >=3.10
 Provides-Extra: dev

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "runspec-linux-core"
-version = "0.3.0"
+version = "0.3.2"
 requires-python = ">=3.10"
 description = "Pure-Python Linux system-admin helpers — the importable core behind runspec-linux (no runspec dependency, no runnables)"
 dependencies = []

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/runspec_linux_core/__init__.py

@@ -32,6 +32,7 @@ from runspec_linux_core.security import last_logins, who
 from runspec_linux_core.services import check_service, list_services, restart_service
 from runspec_linux_core.sudoers import enable_passwordless_sudo
 from runspec_linux_core.system import check_memory, disk_usage, list_processes, system_info
+from runspec_linux_core.venvs import configure_pip, create_venv, install_into_venv
 
 __all__ = [
     # errors
@@ -76,6 +77,10 @@ __all__ = [
     "reboot_host",
     # sudoers
     "enable_passwordless_sudo",
+    # venvs
+    "create_venv",
+    "install_into_venv",
+    "configure_pip",
     # tcp
     "nc_send",
 ]

runspec_linux_core-0.3.2/runspec_linux_core/_paths.py

@@ -0,0 +1,33 @@
+"""Resolve system tools that may live in sbin dirs not on a non-login PATH.
+
+The console runs runnables over a non-login, non-interactive SSH shell whose
+``PATH`` often omits ``/usr/sbin`` and ``/sbin`` — so ``shutil.which()`` can't
+find admin tools like ``visudo`` and ``shutdown`` even when they are installed.
+``which()`` searches ``PATH`` first, then the standard sbin/bin locations, and
+returns an absolute path so the caller can invoke the tool regardless of PATH.
+"""
+
+import os
+import shutil
+
+# Searched in order after PATH — the standard admin-tool locations.
+_FALLBACK_DIRS = (
+    "/usr/local/sbin",
+    "/usr/sbin",
+    "/sbin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin",
+)
+
+
+def which(name: str) -> str | None:
+    """Return the absolute path to ``name`` (PATH first, then sbin/bin), or None."""
+    found = shutil.which(name)
+    if found:
+        return found
+    for directory in _FALLBACK_DIRS:
+        candidate = os.path.join(directory, name)
+        if os.path.isfile(candidate) and os.access(candidate, os.X_OK):
+            return candidate
+    return None

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/runspec_linux_core/power.py

@@ -1,8 +1,8 @@
 """Host power helpers: reboot."""
 
-import shutil
 import subprocess
 
+from runspec_linux_core._paths import which
 from runspec_linux_core.errors import CommandError, ToolNotFoundError
 
 
@@ -14,22 +14,26 @@ def reboot_host(delay_minutes: int = 0) -> dict:
     ``shutdown``, falling back to ``systemctl reboot`` for an immediate reboot if
     ``shutdown`` is absent. Returns ``{scheduled: True, delay_minutes, command}``.
 
-    Raises ToolNotFoundError if no usable tool is present, or CommandError if the
+    ``shutdown`` lives in /usr/sbin, often absent from a non-login SSH PATH, so
+    it is resolved to an absolute path (see ``_paths.which``). Raises
+    ToolNotFoundError if no usable tool is present, or CommandError if the
     command exits non-zero (for example when run as an unprivileged user).
     """
-    if shutil.which("shutdown"):
+    shutdown = which("shutdown")
+    if shutdown:
         when = "now" if delay_minutes <= 0 else f"+{delay_minutes}"
-        cmd = ["shutdown", "-r", when]
+        cmd = [shutdown, "-r", when]
         result = subprocess.run(cmd, capture_output=True, text=True)
         if result.returncode != 0:
             raise CommandError(result.stderr.strip() or "shutdown failed")
         return {"scheduled": True, "delay_minutes": max(delay_minutes, 0), "command": " ".join(cmd)}
 
     # No `shutdown` (unusual). systemctl can only do an immediate reboot.
-    if shutil.which("systemctl") and delay_minutes <= 0:
-        result = subprocess.run(["systemctl", "reboot"], capture_output=True, text=True)
+    systemctl = which("systemctl")
+    if systemctl and delay_minutes <= 0:
+        result = subprocess.run([systemctl, "reboot"], capture_output=True, text=True)
         if result.returncode != 0:
             raise CommandError(result.stderr.strip() or "systemctl reboot failed")
-        return {"scheduled": True, "delay_minutes": 0, "command": "systemctl reboot"}
+        return {"scheduled": True, "delay_minutes": 0, "command": f"{systemctl} reboot"}
 
     raise ToolNotFoundError("shutdown not available (and systemctl cannot schedule a delayed reboot)")

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/runspec_linux_core/sudoers.py

@@ -24,11 +24,11 @@ Two grant scopes:
 import getpass
 import os
 import re
-import shutil
 import subprocess
 import sys
 import tempfile
 
+from runspec_linux_core._paths import which
 from runspec_linux_core.errors import CommandError, ToolNotFoundError
 
 _DROP_IN = "/etc/sudoers.d/runspec"
@@ -56,10 +56,10 @@ def _sudoers_content(user: str, scope: str, bin_dir: str) -> str:
     return f"{_MANAGED_HEADER}{rule}\n"
 
 
-def _sudo(password: str, argv: list[str]) -> subprocess.CompletedProcess:
+def _sudo(sudo_path: str, password: str, argv: list[str]) -> subprocess.CompletedProcess:
     """Run ``sudo -S -p '' argv``, feeding ``password`` on stdin (never on argv)."""
     return subprocess.run(
-        ["sudo", "-S", "-p", "", *argv],
+        [sudo_path, "-S", "-p", "", *argv],
         input=password + "\n",
         capture_output=True,
         text=True,
@@ -90,9 +90,13 @@ def enable_passwordless_sudo(password: str, user: str | None = None, scope: str
     user = user or getpass.getuser()
     if not _USER_RE.match(user):
         raise ValueError(f"invalid user name: {user!r}")
-    if not shutil.which("sudo"):
+    # visudo lives in /usr/sbin, which is often absent from a non-login SSH PATH;
+    # resolve to absolute paths so the lookups (and invocations) work anyway.
+    sudo_path = which("sudo")
+    if not sudo_path:
         raise ToolNotFoundError("sudo is not installed")
-    if not shutil.which("visudo"):
+    visudo_path = which("visudo")
+    if not visudo_path:
         raise ToolNotFoundError("visudo is not installed (needed to validate the sudoers file)")
 
     content = _sudoers_content(user, scope, _runspec_bin_dir())
@@ -102,25 +106,25 @@ def enable_passwordless_sudo(password: str, user: str | None = None, scope: str
         tmp_path = tf.name
     try:
         # 1) Validate the generated syntax locally before touching the system.
-        check = subprocess.run(["visudo", "-cf", tmp_path], capture_output=True, text=True)
+        check = subprocess.run([visudo_path, "-cf", tmp_path], capture_output=True, text=True)
         if check.returncode != 0:
             detail = check.stdout.strip() or check.stderr.strip()
             raise CommandError(f"generated sudoers failed validation: {detail}")
 
         # 2) Idempotent: identical drop-in already present? (reading it needs root)
-        existing = _sudo(password, ["cat", _DROP_IN])
+        existing = _sudo(sudo_path, password, ["cat", _DROP_IN])
         if existing.returncode == 0 and existing.stdout == content:
             return {"user": user, "scope": scope, "path": _DROP_IN, "installed": True, "already_configured": True}
 
         # 3) Install atomically as root, 0440 root:root.
-        install = _sudo(password, ["install", "-m", "0440", "-o", "root", "-g", "root", tmp_path, _DROP_IN])
+        install = _sudo(sudo_path, password, ["install", "-m", "0440", "-o", "root", "-g", "root", tmp_path, _DROP_IN])
         if install.returncode != 0:
             raise CommandError(_auth_hint(install))
 
         # 4) Re-validate the whole sudoers tree; roll our drop-in back if broken.
-        verify = _sudo(password, ["visudo", "-c"])
+        verify = _sudo(sudo_path, password, [visudo_path, "-c"])
         if verify.returncode != 0:
-            _sudo(password, ["rm", "-f", _DROP_IN])
+            _sudo(sudo_path, password, ["rm", "-f", _DROP_IN])
             detail = verify.stdout.strip() or verify.stderr.strip()
             raise CommandError(f"sudoers validation failed after install — rolled back: {detail}")
 

runspec_linux_core-0.3.2/runspec_linux_core/venvs.py

@@ -0,0 +1,299 @@
+"""Python virtualenv management: create venvs, install into them, write pip.conf.
+
+All three helpers operate in user space (no root): a venv, a pip install into it,
+and a ``pip.conf`` under a home or a venv. The driving use case is a **service
+account that owns a venv shared between several consoles**, so each helper takes an
+optional ``run_as`` user and escalates *internally* — ``sudo -n -u <user>`` (or
+``su``) wrapping every command — rather than the console's declarative ``run_as``
+(the account is chosen per-invocation, not fixed in ``runspec.toml``). ``-n`` makes
+sudo fail fast instead of hanging on the TTY-less SSH channel; passwordless sudo is
+assumed (see ``enable-passwordless-sudo``).
+
+Each function returns plain data and raises on failure (``CommandError`` for a
+non-zero subprocess, ``ValueError`` for bad input). The thin ``runspec-linux``
+wrappers render the JSON/exit.
+"""
+
+import configparser
+import contextlib
+import io
+import os
+import pwd
+import re
+import shlex
+import shutil
+import subprocess
+import tempfile
+
+from runspec_linux_core.errors import CommandError
+
+# Mirrors sudoers._USER_RE: a POSIX-ish user/group name. Validated before it is
+# interpolated into a become command or a chgrp, so a crafted value can't inject
+# extra tokens (everything still goes to argv, never a shell, but this keeps the
+# error early and clear).
+_NAME_RE = re.compile(r"^[a-z_][a-z0-9_.-]*\$?$")
+
+_BECOME_METHODS = ("sudo", "su")
+
+
+def _tail(output: str, limit: int = 40) -> list[str]:
+    """The last ``limit`` non-empty-trimmed lines, so payloads stay bounded."""
+    return output.strip().splitlines()[-limit:]
+
+
+def _validate_name(value: str, what: str) -> str:
+    if not _NAME_RE.match(value):
+        raise ValueError(f"invalid {what}: {value!r}")
+    return value
+
+
+def _become(argv: list[str], run_as: str | None, method: str = "sudo") -> list[str]:
+    """Wrap ``argv`` so it runs as ``run_as`` via ``method`` (no escalation if empty).
+
+    ``sudo`` → ``sudo -n -u <user> <argv...>`` (``-n`` never prompts).
+    ``su``   → ``su <user> -c "<argv joined+quoted>"`` (su has no ``-n``; it only
+    works without a password when the caller is already root).
+    """
+    if not run_as:
+        return argv
+    _validate_name(run_as, "run-as user")
+    if method not in _BECOME_METHODS:
+        raise ValueError(f"invalid become-method: {method!r} (expected sudo or su)")
+    if method == "su":
+        return ["su", run_as, "-c", shlex.join(argv)]
+    return ["sudo", "-n", "-u", run_as, *argv]
+
+
+def _run(argv: list[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(argv, capture_output=True, text=True)
+
+
+def _check(result: subprocess.CompletedProcess[str], what: str, run_as: str | None) -> None:
+    """Raise CommandError on non-zero, with a passwordless-sudo hint when relevant."""
+    if result.returncode == 0:
+        return
+    err = result.stderr.strip()
+    if run_as and ("password is required" in err.lower() or "a terminal is required" in err.lower()):
+        raise CommandError(f"{what}: passwordless sudo is not configured for run-as {run_as!r} ({err})")
+    raise CommandError(err or f"{what} failed")
+
+
+def create_venv(
+    python: str,
+    dest: str,
+    *,
+    run_as: str | None = None,
+    become_method: str = "sudo",
+    group: str | None = None,
+    system_site_packages: bool = False,
+    upgrade_deps: bool = False,
+    clear: bool = False,
+    prompt: str | None = None,
+) -> dict:
+    """Create a virtualenv at ``dest`` from a specific ``python`` interpreter.
+
+    Always uses ``--symlinks``. Then creates ``<dest>/logs`` mode ``2775`` (setgid,
+    so new audit-log files inherit the directory's group) and, if ``group`` is set,
+    ``chgrp -R`` the venv to it — enabling a shared service-account venv that several
+    consoles read/write. With ``run_as`` set every step runs as that user (so the
+    venv is owned by it). Raises ValueError on a non-executable interpreter / bad
+    name, or CommandError on a failed step.
+    """
+    if not (os.path.isfile(python) and os.access(python, os.X_OK)):
+        raise ValueError(f"not an executable file: {python!r} (pick a real interpreter, not the system default)")
+
+    flags: list[str] = ["--symlinks"]
+    if system_site_packages:
+        flags.append("--system-site-packages")
+    if upgrade_deps:
+        flags.append("--upgrade-deps")
+    if clear:
+        flags.append("--clear")
+    if prompt:
+        flags += ["--prompt", prompt]
+
+    _check(_run(_become([python, "-m", "venv", *flags, dest], run_as, become_method)), "venv creation", run_as)
+
+    logs_dir = os.path.join(dest, "logs")
+    _check(_run(_become(["mkdir", "-p", logs_dir], run_as, become_method)), "logs dir", run_as)
+    if group:
+        _validate_name(group, "group")
+        _check(_run(_become(["chgrp", "-R", group, dest], run_as, become_method)), "chgrp", run_as)
+    _check(_run(_become(["chmod", "2775", logs_dir], run_as, become_method)), "chmod logs", run_as)
+
+    return {
+        "python": python,
+        "dest": dest,
+        "run_as": run_as or "",
+        "group": group or "",
+        "logs_dir": logs_dir,
+        "created": True,
+    }
+
+
+def install_into_venv(
+    venv: str,
+    packages: str = "",
+    *,
+    project: str | None = None,
+    editable: bool = False,
+    upgrade: bool = False,
+    no_cache_dir: bool = False,
+    force_reinstall: bool = False,
+    run_as: str | None = None,
+    become_method: str = "sudo",
+) -> dict:
+    """Install named packages and/or a local project into an existing venv's pip.
+
+    Targets ``<venv>/bin/python -m pip install``. ``packages`` is space-separated
+    named specs (validated against the shared package-token guard); ``project`` is a
+    path to a directory with a ``pyproject.toml`` (or a wheel/sdist), installed
+    editable when ``editable`` is set. At least one of ``packages``/``project`` is
+    required. Raises ValueError on bad input, CommandError on a failed install.
+    """
+    from runspec_linux_core.packages import _validate_packages
+
+    venv_python = os.path.join(venv, "bin", "python")
+    if not (os.path.isfile(venv_python) and os.access(venv_python, os.X_OK)):
+        raise ValueError(f"no python in venv: {venv_python!r}")
+
+    names = _validate_packages(packages) if packages.strip() else []
+    if project is not None and (project.startswith("-") or not os.path.exists(project)):
+        raise ValueError(f"project path not found: {project!r}")
+    if editable and project is None:
+        raise ValueError("--editable requires a project path")
+    if not names and project is None:
+        raise ValueError("nothing to install: give a package and/or a project")
+
+    opts: list[str] = []
+    if upgrade:
+        opts.append("-U")
+    if no_cache_dir:
+        opts.append("--no-cache-dir")
+    if force_reinstall:
+        opts.append("--force-reinstall")
+
+    target: list[str] = list(names)
+    if project is not None:
+        target += ["-e", project] if editable else [project]
+
+    cmd = _become([venv_python, "-m", "pip", "install", *opts, *target], run_as, become_method)
+    result = _run(cmd)
+    _check(result, "pip install", run_as)
+    return {
+        "venv": venv,
+        "packages": names,
+        "project": project or "",
+        "editable": editable,
+        "installed": True,
+        "output": _tail(result.stdout),
+    }
+
+
+def configure_pip(
+    index_url: str,
+    *,
+    extra_index_url: str | None = None,
+    trusted_host: str | None = None,
+    cert: str | None = None,
+    timeout: int | None = None,
+    retries: int | None = None,
+    proxy: str | None = None,
+    require_virtualenv: bool = False,
+    scope: str = "user",
+    venv: str | None = None,
+    run_as: str | None = None,
+    become_method: str = "sudo",
+) -> dict:
+    """Write a ``pip.conf`` at user or venv scope for private-PyPI access.
+
+    Builds a ``[global]`` section from the given settings (``index-url`` is the only
+    required one) and, when ``require_virtualenv`` is set, also pins
+    ``require-virtualenv`` + ``disable-pip-version-check``. The file is validated by
+    re-parsing before it is installed. ``scope="user"`` targets
+    ``<home>/.config/pip/pip.conf`` (the ``run_as`` user's home when escalating, else
+    the caller's); ``scope="venv"`` targets ``<venv>/pip.conf`` and requires ``venv``.
+    With ``run_as`` the file is installed via ``install -D -m 0644`` as that user (so
+    it is owned by it); otherwise it is written atomically with a ``.bak`` of any
+    existing file. Raises ValueError on bad input, CommandError on a failed step.
+    """
+    if scope not in ("user", "venv"):
+        raise ValueError(f"invalid scope: {scope!r} (expected user or venv)")
+    if scope == "venv":
+        if not venv:
+            raise ValueError("scope=venv requires a venv path")
+        path = os.path.join(venv, "pip.conf")
+    else:
+        if run_as:
+            _validate_name(run_as, "run-as user")
+            home = pwd.getpwnam(run_as).pw_dir
+        else:
+            home = os.path.expanduser("~")
+        path = os.path.join(home, ".config", "pip", "pip.conf")
+
+    cfg = configparser.ConfigParser()
+    section: dict[str, str] = {"index-url": index_url}
+    if extra_index_url:
+        section["extra-index-url"] = extra_index_url
+    if trusted_host:
+        section["trusted-host"] = trusted_host
+    if cert:
+        section["cert"] = cert
+    if timeout is not None:
+        section["timeout"] = str(timeout)
+    if retries is not None:
+        section["retries"] = str(retries)
+    if proxy:
+        section["proxy"] = proxy
+    if require_virtualenv:
+        section["require-virtualenv"] = "true"
+        section["disable-pip-version-check"] = "true"
+    cfg["global"] = section
+
+    buf = io.StringIO()
+    cfg.write(buf)
+    content = buf.getvalue()
+
+    # Validate it re-parses before we install it anywhere.
+    check = configparser.ConfigParser()
+    check.read_string(content)
+
+    # Write to a temp file the run-as user can read (0644 — pip.conf is non-secret),
+    # then install it atomically into place as that user (creating parent dirs).
+    fd, tmp = tempfile.mkstemp(prefix="pip.conf.", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as fh:
+            fh.write(content)
+        os.chmod(tmp, 0o644)
+        if run_as:
+            if _path_exists_as(path, run_as, become_method):
+                _check(
+                    _run(_become(["cp", path, f"{path}.bak"], run_as, become_method)),
+                    "backup pip.conf",
+                    run_as,
+                )
+            _check(
+                _run(_become(["install", "-D", "-m", "0644", tmp, path], run_as, become_method)),
+                "install pip.conf",
+                run_as,
+            )
+        else:
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            if os.path.exists(path):
+                shutil.copy2(path, f"{path}.bak")
+            shutil.copy2(tmp, path)
+    finally:
+        with contextlib.suppress(OSError):
+            os.unlink(tmp)
+
+    return {
+        "path": path,
+        "scope": scope,
+        "run_as": run_as or "",
+        "configured": True,
+    }
+
+
+def _path_exists_as(path: str, run_as: str | None, become_method: str) -> bool:
+    """True if ``path`` exists from the run-as user's view (``test -e``)."""
+    return _run(_become(["test", "-e", path], run_as, become_method)).returncode == 0

runspec_linux_core-0.3.2/tests/test_paths.py

@@ -0,0 +1,24 @@
+"""which() falls back to sbin/bin dirs when a tool isn't on PATH."""
+
+import pytest
+
+from runspec_linux_core._paths import which
+
+
+def test_which_prefers_path(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("runspec_linux_core._paths.shutil.which", lambda n: "/usr/bin/" + n)
+    assert which("sudo") == "/usr/bin/sudo"
+
+
+def test_which_falls_back_to_sbin(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Not on PATH (the non-login SSH case), but present in /usr/sbin.
+    monkeypatch.setattr("runspec_linux_core._paths.shutil.which", lambda n: None)
+    monkeypatch.setattr("runspec_linux_core._paths.os.path.isfile", lambda p: p == "/usr/sbin/visudo")
+    monkeypatch.setattr("runspec_linux_core._paths.os.access", lambda p, mode: True)
+    assert which("visudo") == "/usr/sbin/visudo"
+
+
+def test_which_none_when_absent(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("runspec_linux_core._paths.shutil.which", lambda n: None)
+    monkeypatch.setattr("runspec_linux_core._paths.os.path.isfile", lambda p: False)
+    assert which("nope") is None

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/tests/test_power.py

@@ -14,7 +14,7 @@ def _completed(returncode: int = 0, stderr: str = "") -> subprocess.CompletedPro
 
 def test_reboot_now_uses_shutdown(monkeypatch: pytest.MonkeyPatch) -> None:
     seen: list[list[str]] = []
-    monkeypatch.setattr("runspec_linux_core.power.shutil.which", lambda name: name == "shutdown")
+    monkeypatch.setattr("runspec_linux_core.power.which", lambda name: name if name == "shutdown" else None)
     monkeypatch.setattr(
         "runspec_linux_core.power.subprocess.run",
         lambda cmd, **kw: seen.append(cmd) or _completed(),
@@ -26,7 +26,7 @@ def test_reboot_now_uses_shutdown(monkeypatch: pytest.MonkeyPatch) -> None:
 
 def test_reboot_with_delay_schedules(monkeypatch: pytest.MonkeyPatch) -> None:
     seen: list[list[str]] = []
-    monkeypatch.setattr("runspec_linux_core.power.shutil.which", lambda name: name == "shutdown")
+    monkeypatch.setattr("runspec_linux_core.power.which", lambda name: name if name == "shutdown" else None)
     monkeypatch.setattr(
         "runspec_linux_core.power.subprocess.run",
         lambda cmd, **kw: seen.append(cmd) or _completed(),
@@ -38,7 +38,7 @@ def test_reboot_with_delay_schedules(monkeypatch: pytest.MonkeyPatch) -> None:
 
 def test_reboot_falls_back_to_systemctl(monkeypatch: pytest.MonkeyPatch) -> None:
     seen: list[list[str]] = []
-    monkeypatch.setattr("runspec_linux_core.power.shutil.which", lambda name: name == "systemctl")
+    monkeypatch.setattr("runspec_linux_core.power.which", lambda name: name if name == "systemctl" else None)
     monkeypatch.setattr(
         "runspec_linux_core.power.subprocess.run",
         lambda cmd, **kw: seen.append(cmd) or _completed(),
@@ -49,7 +49,7 @@ def test_reboot_falls_back_to_systemctl(monkeypatch: pytest.MonkeyPatch) -> None
 
 
 def test_reboot_non_zero_raises(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("runspec_linux_core.power.shutil.which", lambda name: name == "shutdown")
+    monkeypatch.setattr("runspec_linux_core.power.which", lambda name: name if name == "shutdown" else None)
     monkeypatch.setattr(
         "runspec_linux_core.power.subprocess.run",
         lambda cmd, **kw: _completed(returncode=1, stderr="Operation not permitted"),

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/tests/test_preconditions.py

@@ -101,12 +101,12 @@ def test_remove_package_requires_a_manager(monkeypatch: pytest.MonkeyPatch) -> N
 
 
 def test_reboot_host_requires_a_tool(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("runspec_linux_core.power.shutil.which", lambda _: None)
+    monkeypatch.setattr("runspec_linux_core.power.which", lambda _: None)
     with pytest.raises(ToolNotFoundError):
         core.reboot_host()
 
 
 def test_enable_passwordless_sudo_requires_sudo(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("runspec_linux_core.sudoers.shutil.which", lambda _: None)
+    monkeypatch.setattr("runspec_linux_core.sudoers.which", lambda _: None)
     with pytest.raises(ToolNotFoundError):
         core.enable_passwordless_sudo("pw", "alice", "scoped")

{runspec_linux_core-0.3.0 → runspec_linux_core-0.3.2}/tests/test_sudoers.py

@@ -19,7 +19,8 @@ def _ok(stdout: str = "", returncode: int = 0, stderr: str = "") -> subprocess.C
 
 @pytest.fixture(autouse=True)
 def _tools_present(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("runspec_linux_core.sudoers.shutil.which", lambda name: f"/usr/sbin/{name}")
+    # Resolver returns the bare name so the stubbed commands read cleanly.
+    monkeypatch.setattr("runspec_linux_core.sudoers.which", lambda name: name)
     monkeypatch.setattr("runspec_linux_core.sudoers._runspec_bin_dir", lambda: "/opt/rs/bin")
 
 
@@ -142,6 +143,6 @@ def test_post_validate_failure_rolls_back(monkeypatch: pytest.MonkeyPatch) -> No
 
 
 def test_requires_visudo(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("runspec_linux_core.sudoers.shutil.which", lambda name: None if name == "visudo" else "/usr/bin/sudo")
+    monkeypatch.setattr("runspec_linux_core.sudoers.which", lambda name: None if name == "visudo" else "/usr/bin/sudo")
     with pytest.raises(ToolNotFoundError, match="visudo"):
         sudoers.enable_passwordless_sudo("pw", "alice", "scoped")

runspec_linux_core-0.3.2/tests/test_venvs.py

@@ -0,0 +1,249 @@
+"""venv creation, install-into-venv, and pip.conf writing.
+
+The subprocess layer (``_run``) is stubbed so no real venv/pip is touched; the
+tests assert on the argv that *would* run (escalation prefix, flags, ordering)
+and on the input validation that happens before any subprocess.
+"""
+
+import configparser
+import os
+import subprocess
+
+import pytest
+
+from runspec_linux_core import venvs
+from runspec_linux_core.errors import CommandError
+
+
+def _completed(stdout: str = "", returncode: int = 0, stderr: str = "") -> subprocess.CompletedProcess:
+    return subprocess.CompletedProcess(args=[], returncode=returncode, stdout=stdout, stderr=stderr)
+
+
+def _record(monkeypatch: pytest.MonkeyPatch) -> list[list[str]]:
+    """Stub ``venvs._run`` to record every argv and always succeed."""
+    calls: list[list[str]] = []
+
+    def fake_run(argv: list[str]) -> subprocess.CompletedProcess:
+        calls.append(argv)
+        return _completed("Successfully installed foo\n")
+
+    monkeypatch.setattr(venvs, "_run", fake_run)
+    return calls
+
+
+# ── _become ───────────────────────────────────────────────────────────────────
+
+
+def test_become_no_user_is_noop() -> None:
+    assert venvs._become(["echo", "hi"], None) == ["echo", "hi"]
+    assert venvs._become(["echo", "hi"], "") == ["echo", "hi"]
+
+
+def test_become_sudo_prefix() -> None:
+    assert venvs._become(["echo", "hi"], "svc") == ["sudo", "-n", "-u", "svc", "echo", "hi"]
+
+
+def test_become_su_quotes() -> None:
+    assert venvs._become(["pip", "install", "a b"], "svc", "su") == ["su", "svc", "-c", "pip install 'a b'"]
+
+
+def test_become_rejects_bad_user() -> None:
+    with pytest.raises(ValueError):
+        venvs._become(["echo"], "bad;user")
+
+
+def test_become_rejects_bad_method() -> None:
+    with pytest.raises(ValueError):
+        venvs._become(["echo"], "svc", "doas")
+
+
+# ── create_venv ───────────────────────────────────────────────────────────────
+
+
+def test_create_venv_uses_symlinks_and_logs(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = _record(monkeypatch)
+    import sys
+
+    result = venvs.create_venv(sys.executable, "/opt/v1")
+
+    venv_cmd = calls[0]
+    assert venv_cmd[:4] == [sys.executable, "-m", "venv", "--symlinks"]
+    assert venv_cmd[-1] == "/opt/v1"
+    # mkdir -p logs, then chmod 2775 logs (no group → no chgrp step).
+    assert calls[1] == ["mkdir", "-p", "/opt/v1/logs"]
+    assert calls[2] == ["chmod", "2775", "/opt/v1/logs"]
+    assert result == {
+        "python": sys.executable,
+        "dest": "/opt/v1",
+        "run_as": "",
+        "group": "",
+        "logs_dir": "/opt/v1/logs",
+        "created": True,
+    }
+
+
+def test_create_venv_only_sets_chosen_flags(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = _record(monkeypatch)
+    import sys
+
+    venvs.create_venv(sys.executable, "/opt/v1", system_site_packages=True, clear=True)
+    venv_cmd = calls[0]
+    assert "--system-site-packages" in venv_cmd
+    assert "--clear" in venv_cmd
+    assert "--upgrade-deps" not in venv_cmd
+
+
+def test_create_venv_run_as_escalates_every_step(monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = _record(monkeypatch)
+    import sys
+
+    venvs.create_venv(sys.executable, "/opt/v1", run_as="svc", group="consoles")
+    for cmd in calls:
+        assert cmd[:4] == ["sudo", "-n", "-u", "svc"]
+    # chgrp -R consoles /opt/v1 runs between mkdir and chmod.
+    assert ["sudo", "-n", "-u", "svc", "chgrp", "-R", "consoles", "/opt/v1"] in calls
+
+
+def test_create_venv_rejects_non_executable(monkeypatch: pytest.MonkeyPatch) -> None:
+    _record(monkeypatch)
+    with pytest.raises(ValueError):
+        venvs.create_venv("/no/such/python", "/opt/v1")
+
+
+def test_create_venv_raises_on_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+    import sys
+
+    monkeypatch.setattr(venvs, "_run", lambda argv: _completed("", returncode=1, stderr="boom"))
+    with pytest.raises(CommandError):
+        venvs.create_venv(sys.executable, "/opt/v1")
+
+
+# ── install_into_venv ─────────────────────────────────────────────────────────
+
+
+def _fake_venv(tmp_path, monkeypatch: pytest.MonkeyPatch) -> str:
+    """A venv dir whose bin/python passes the executable check."""
+    import sys
+
+    venv = tmp_path / "venv"
+    (venv / "bin").mkdir(parents=True)
+    py = venv / "bin" / "python"
+    os.symlink(sys.executable, py)
+    return str(venv)
+
+
+def test_install_into_venv_builds_pip_argv(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    venv = _fake_venv(tmp_path, monkeypatch)
+    calls = _record(monkeypatch)
+
+    result = venvs.install_into_venv(venv, "httpx rich", upgrade=True)
+    cmd = calls[0]
+    assert cmd[:4] == [f"{venv}/bin/python", "-m", "pip", "install"]
+    assert "-U" in cmd
+    assert cmd[-2:] == ["httpx", "rich"]
+    assert result["installed"] is True
+    assert result["output"] == ["Successfully installed foo"]
+
+
+def test_install_into_venv_editable_project(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    venv = _fake_venv(tmp_path, monkeypatch)
+    proj = tmp_path / "proj"
+    proj.mkdir()
+    calls = _record(monkeypatch)
+
+    venvs.install_into_venv(venv, project=str(proj), editable=True, run_as="svc")
+    cmd = calls[0]
+    assert cmd[:4] == ["sudo", "-n", "-u", "svc"]
+    assert cmd[-2:] == ["-e", str(proj)]
+
+
+def test_install_into_venv_requires_a_target(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    venv = _fake_venv(tmp_path, monkeypatch)
+    _record(monkeypatch)
+    with pytest.raises(ValueError):
+        venvs.install_into_venv(venv)
+
+
+def test_install_into_venv_editable_needs_project(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    venv = _fake_venv(tmp_path, monkeypatch)
+    _record(monkeypatch)
+    with pytest.raises(ValueError):
+        venvs.install_into_venv(venv, "httpx", editable=True)
+
+
+def test_install_into_venv_rejects_missing_venv(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    _record(monkeypatch)
+    with pytest.raises(ValueError):
+        venvs.install_into_venv(str(tmp_path / "nope"), "httpx")
+
+
+def test_install_into_venv_rejects_injection(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    venv = _fake_venv(tmp_path, monkeypatch)
+    _record(monkeypatch)
+    with pytest.raises(ValueError):
+        venvs.install_into_venv(venv, "httpx; rm -rf /")
+
+
+# ── configure_pip ─────────────────────────────────────────────────────────────
+
+
+def test_configure_pip_user_scope_writes_ini(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(os.path, "expanduser", lambda p: str(tmp_path) if p == "~" else p)
+    result = venvs.configure_pip(
+        "https://nexus/repository/pypi/simple",
+        trusted_host="nexus",
+        timeout=60,
+        retries=5,
+        require_virtualenv=True,
+    )
+    path = result["path"]
+    assert path == str(tmp_path / ".config" / "pip" / "pip.conf")
+
+    cfg = configparser.ConfigParser()
+    cfg.read(path)
+    assert cfg["global"]["index-url"] == "https://nexus/repository/pypi/simple"
+    assert cfg["global"]["trusted-host"] == "nexus"
+    assert cfg["global"]["timeout"] == "60"
+    assert cfg["global"]["retries"] == "5"
+    assert cfg["global"]["require-virtualenv"] == "true"
+    assert cfg["global"]["disable-pip-version-check"] == "true"
+
+
+def test_configure_pip_venv_scope(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    venv = tmp_path / "venv"
+    venv.mkdir()
+    result = venvs.configure_pip("https://nexus/simple", scope="venv", venv=str(venv))
+    assert result["path"] == str(venv / "pip.conf")
+    cfg = configparser.ConfigParser()
+    cfg.read(result["path"])
+    assert cfg["global"]["index-url"] == "https://nexus/simple"
+
+
+def test_configure_pip_venv_scope_requires_venv() -> None:
+    with pytest.raises(ValueError):
+        venvs.configure_pip("https://nexus/simple", scope="venv")
+
+
+def test_configure_pip_bad_scope() -> None:
+    with pytest.raises(ValueError):
+        venvs.configure_pip("https://nexus/simple", scope="global")
+
+
+def test_configure_pip_run_as_installs_via_become(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    calls = _record(monkeypatch)
+    # run_as path resolves the user's home via pwd; stub it to tmp_path.
+    monkeypatch.setattr(
+        venvs.pwd,
+        "getpwnam",
+        lambda u: type("PW", (), {"pw_dir": str(tmp_path)})(),
+    )
+    result = venvs.configure_pip("https://nexus/simple", run_as="svc")
+    target = str(tmp_path / ".config" / "pip" / "pip.conf")
+    assert result["path"] == target
+    # An install -D -m 0644 <tmp> <target> ran as svc.
+    install_cmds = [c for c in calls if "install" in c and "-D" in c]
+    assert install_cmds, calls
+    cmd = install_cmds[0]
+    assert cmd[:4] == ["sudo", "-n", "-u", "svc"]
+    assert cmd[4:7] == ["install", "-D", "-m"]
+    assert cmd[-1] == target