Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.
C++
POSIX owner-only checks: repair our own folders whose mode drifted, note drives without modes, and name the chown command for folders another account owns
Niko122172fc52251bc2
diff --git a/strata_cli/bench.py b/strata_cli/bench.pyindex 80d673c15..a324f94c1 100644--- a/strata_cli/bench.py+++ b/strata_cli/bench.py@@ -34,6 +34,7 @@ from pathlib import Pathfrom strata_cli.client import ClientError, Endpoint, _NoRedirectfrom strata_control.profiles import ProfileErrorfrom strata_control import atomic as _atomic_mod+from strata_control import posix_ownerSCHEMA = 1@@ -698,9 +699,8 @@ def progress(path: Path) -> dict:try:details = target.lstat()if not stat.S_ISREG(details.st_mode) or details.st_size > 4096 or \- (os.name == "posix" and (details.st_uid != os.getuid() or- stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("benchmark progress must be an owner-only regular file under 4 KiB", 5)+ (os.name == "posix" and (posix_owner.owner_only_wrong(target, details))):+ raise ProfileError(posix_owner.owner_only_text("benchmark progress must be an owner-only regular file under 4 KiB", target), 5)record = json.loads(target.read_text(encoding="utf-8"))except (OSError, UnicodeError, ValueError) as exc:if isinstance(exc, ProfileError):diff --git a/strata_cli/connections.py b/strata_cli/connections.pyindex 586b73ce3..f5b8088bb 100644--- a/strata_cli/connections.py+++ b/strata_cli/connections.py@@ -13,6 +13,14 @@ except ImportError: # a thin bundle (monitordef _private_mkdir(path, *, parents=False, exist_ok=True):path.mkdir(mode=0o700, parents=parents, exist_ok=exist_ok)return path+try:+ from strata_control import posix_owner+except ImportError: # the same thin bundle: the old plain check+ import stat as _stat++ class posix_owner: # noqa: N801+ owner_only_wrong = staticmethod(lambda path, details: os.name == "posix" and (details.st_uid != os.getuid() or _stat.S_IMODE(details.st_mode) & 0o077))+ owner_only_text = staticmethod(lambda text, path: text)try:from strata_control import atomic as _atomic_modexcept ImportError: # the same thin bundle: a plain replace@@ -77,8 +85,8 @@ def connection_dir(*, create: bool = False) -> Path:if directory.exists() or directory.is_symlink():details = directory.lstat()if not stat.S_ISDIR(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ConnectionError("connection directory must be owner-only", 5)+ (posix_owner.owner_only_wrong(directory, details))):+ raise ConnectionError(posix_owner.owner_only_text("connection directory must be owner-only", directory), 5)return directory@@ -122,9 +130,8 @@ def load(name: str) -> tuple[dict, str]:try:details = path.lstat()if not stat.S_ISREG(details.st_mode) or details.st_size > MAX_BYTES or \- (os.name == "posix" and (details.st_uid != os.getuid() or- stat.S_IMODE(details.st_mode) & 0o077)):- raise ConnectionError("connection file must be a private regular file under 4 KiB", 5)+ (os.name == "posix" and (posix_owner.owner_only_wrong(path, details))):+ raise ConnectionError(posix_owner.owner_only_text("connection file must be a private regular file under 4 KiB", path), 5)data = path.read_bytes()value = json.loads(data.decode("utf-8"))except FileNotFoundError:@@ -187,8 +194,8 @@ def _lock(name: str):with os.fdopen(descriptor, "r+b") as stream:details = os.fstat(stream.fileno())if not stat.S_ISREG(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ConnectionError("connection lock must be owner-only", 5)+ (posix_owner.owner_only_wrong(path, details))):+ raise ConnectionError(posix_owner.owner_only_text("connection lock must be owner-only", path), 5)if os.name == "nt":import msvcrtstream.seek(0)diff --git a/strata_control/benchmarking.py b/strata_control/benchmarking.pyindex a66173543..9d89149f0 100644--- a/strata_control/benchmarking.py+++ b/strata_control/benchmarking.py@@ -17,6 +17,7 @@ from strata_cli.cli import _launch_plan, _sourcefrom strata_cli.client import ClientError, Endpointfrom strata_control import journal, profiles, runtimefrom strata_control.profiles import ProfileError+from strata_control import posix_owner#: Windows byte-range locks are mandatory: a locked byte cannot be read through any other handle. The lock@@ -33,8 +34,8 @@ def _lease_file(profile: str, *, create: bool) -> Path | None:return Nonedetails = directory.lstat()if not stat.S_ISDIR(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("benchmark lease directory must be owner-only", 5)+ (posix_owner.owner_only_wrong(directory, details))):+ raise ProfileError(posix_owner.owner_only_text("benchmark lease directory must be owner-only", directory), 5)return directory / f".bench-{profile}.lock"@@ -45,9 +46,9 @@ def _lease_descriptor(path: Path, *, create: bool) -> int:descriptor = os.open(path, flags, 0o600)details = os.fstat(descriptor)if not stat.S_ISREG(details.st_mode) or details.st_nlink != 1 or details.st_size > 65 or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):+ (posix_owner.owner_only_wrong(path, details))):os.close(descriptor)- raise ProfileError("benchmark lease file must be owner-only", 5)+ raise ProfileError(posix_owner.owner_only_text("benchmark lease file must be owner-only", path), 5)return descriptor@@ -139,8 +140,8 @@ def request_cancel(profile: str, path: Path) -> dict:directory = path.parent if path.name in ("results.json", "progress.json") else pathdetails = directory.lstat()if not stat.S_ISDIR(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("benchmark output directory must be owner-only", 5)+ (posix_owner.owner_only_wrong(directory, details))):+ raise ProfileError(posix_owner.owner_only_text("benchmark output directory must be owner-only", directory), 5)if benchmark_activity(profile, directory) != "active":raise ProfileError("the exact benchmark run is not active", 6)if bench.progress(directory)["state"] != "running":@@ -152,7 +153,7 @@ def request_cancel(profile: str, path: Path) -> dict:except FileExistsError:details = marker.lstat()if not stat.S_ISREG(details.st_mode) or details.st_nlink != 1 or details.st_size != 1 or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):+ (posix_owner.owner_only_wrong(marker, details))):raise ProfileError("benchmark cancellation marker is invalid", 5)else:try:@@ -175,7 +176,7 @@ def cancel_requested(directory: Path) -> bool:except FileNotFoundError:return Falseif not stat.S_ISREG(details.st_mode) or details.st_nlink != 1 or details.st_size != 1 or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):+ (posix_owner.owner_only_wrong(marker, details))):raise ProfileError("benchmark cancellation marker is invalid", 5)return True@@ -321,8 +322,8 @@ def job_status(profile: str, job_id: str) -> dict:if directory.exists() or directory.is_symlink():details = directory.lstat()if not stat.S_ISDIR(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("benchmark output directory must be owner-only", 5)+ (posix_owner.owner_only_wrong(directory, details))):+ raise ProfileError(posix_owner.owner_only_text("benchmark output directory must be owner-only", directory), 5)activity = benchmark_activity(profile, directory)try:phase = bench.progress(directory)diff --git a/strata_control/calibration.py b/strata_control/calibration.pyindex 2dcec1be1..8d76217c3 100644--- a/strata_control/calibration.py+++ b/strata_control/calibration.py@@ -27,6 +27,7 @@ from strata_control import profilesfrom strata_control.doctor import inspect as inspect_componentsfrom strata_control.profiles import ProfileErrorfrom strata_control import atomic as _atomic_mod+from strata_control import posix_ownerSUITE = "legacy-decode-v1"@@ -461,9 +462,8 @@ def _backup_directory(path: Path, *, create: bool = False) -> Path:except OSError as exc:raise ProfileError(f"cannot access calibration backup directory ({type(exc).__name__})", 5) from Noneif not stat.S_ISDIR(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or- stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("calibration backup directory must be owner-only and not a symlink", 5)+ (posix_owner.owner_only_wrong(directory, details))):+ raise ProfileError(posix_owner.owner_only_text("calibration backup directory must be owner-only and not a symlink", directory), 5)return directory@@ -483,9 +483,8 @@ def _load_application(path: Path, report: dict) -> dict:try:details = manifest.lstat()if not stat.S_ISREG(details.st_mode) or details.st_size > MAX_APPLICATION_BYTES or \- (os.name == "posix" and (details.st_uid != os.getuid() or- stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("calibration application record is not an owner-only regular file", 5)+ (os.name == "posix" and (posix_owner.owner_only_wrong(manifest, details))):+ raise ProfileError(posix_owner.owner_only_text("calibration application record is not an owner-only regular file", manifest), 5)data = json.loads(manifest.read_text(encoding="utf-8"))except FileNotFoundError:raise ProfileError("calibration application record was not found", 5) from None@@ -634,8 +633,8 @@ def _saved_bytes(path: Path, *, required: bool = True, owner_only: bool = False)raise ProfileError("calibration rollback file is missing", 5) from Noneif not stat.S_ISREG(details.st_mode) or details.st_size > MAX_REPORT_BYTES or \(owner_only and os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("calibration rollback file must be a regular owner-only file under 2 MiB", 5)+ (posix_owner.owner_only_wrong(path, details))):+ raise ProfileError(posix_owner.owner_only_text("calibration rollback file must be a regular owner-only file under 2 MiB", path), 5)try:return path.read_bytes()except OSError as exc:diff --git a/strata_control/calibration_jobs.py b/strata_control/calibration_jobs.pyindex 2f03541c8..29bf9f319 100644--- a/strata_control/calibration_jobs.py+++ b/strata_control/calibration_jobs.py@@ -14,6 +14,7 @@ from pathlib import Pathfrom strata_control import calibration, journal, profilesfrom strata_control.profiles import ProfileError+from strata_control import posix_ownerKINDS = {"measure": "engine.calibrate.measure", "apply": "engine.calibrate.apply",@@ -43,9 +44,9 @@ def _open_lease(profile: str, *, create: bool) -> int | None:details = os.fstat(descriptor)if not stat.S_ISREG(details.st_mode) or details.st_nlink != 1 or details.st_size > 32 or \(os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):+ (posix_owner.owner_only_wrong(_lease_path(profile), details))):os.close(descriptor)- raise ProfileError("calibration worker lease must be owner-only", 5)+ raise ProfileError(posix_owner.owner_only_text("calibration worker lease must be owner-only", _lease_path(profile)), 5)return descriptor@@ -129,7 +130,7 @@ def _cancel_requested(profile: str, job_id: str) -> bool:return Falseif not stat.S_ISREG(details.st_mode) or details.st_nlink != 1 or details.st_size != 1 or \(os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):+ (posix_owner.owner_only_wrong(path, details))):raise ProfileError("calibration cancellation marker is invalid", 5)descriptor = os.open(path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))try:@@ -187,8 +188,8 @@ def _load_progress(profile: str, job_id: str) -> dict | None:return Noneif not stat.S_ISREG(details.st_mode) or details.st_nlink != 1 or details.st_size > 1024 or \(os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("calibration progress file must be owner-only", 5)+ (posix_owner.owner_only_wrong(path, details))):+ raise ProfileError(posix_owner.owner_only_text("calibration progress file must be owner-only", path), 5)try:value = json.loads(path.read_text(encoding="utf-8"))except (OSError, UnicodeError, ValueError):diff --git a/strata_control/journal.py b/strata_control/journal.pyindex c8f51a37d..972fce9ef 100644--- a/strata_control/journal.py+++ b/strata_control/journal.py@@ -19,6 +19,7 @@ from pathlib import Pathfrom strata_control import profiles, recipesfrom strata_control.profiles import ProfileError+from strata_control import posix_ownerMAX_RECORDS = 500@@ -51,8 +52,8 @@ def _directory(profile: str, *, create: bool = False) -> Path:details = directory.lstat()if not stat.S_ISDIR(details.st_mode):raise ProfileError("operation journal directory must not be a symlink", 5)- if os.name == "posix" and (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077):- raise ProfileError("operation journal directory must be owner-only", 5)+ if os.name == "posix" and (posix_owner.owner_only_wrong(directory, details)):+ raise ProfileError(posix_owner.owner_only_text("operation journal directory must be owner-only", directory), 5)return directory@@ -186,8 +187,8 @@ def _load_file(path: Path, profile: str) -> dict:details = path.lstat()if not stat.S_ISREG(details.st_mode) or details.st_size > MAX_RECORD_BYTES:raise ProfileError("operation record must be a regular file under 64 KiB", 5)- if os.name == "posix" and (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077):- raise ProfileError("operation record must be owner-only", 5)+ if os.name == "posix" and (posix_owner.owner_only_wrong(path, details)):+ raise ProfileError(posix_owner.owner_only_text("operation record must be owner-only", path), 5)record = json.loads(path.read_text(encoding="utf-8"))except FileNotFoundError:raise ProfileError("operation record was not found", 5) from Nonediff --git a/strata_control/posix_owner.py b/strata_control/posix_owner.pynew file mode 100644index 000000000..a6f20d779--- /dev/null+++ b/strata_control/posix_owner.py@@ -0,0 +1,100 @@+"""POSIX 'owner-only' checks that repair what is ours and explain what is not.++Strata keeps its private state in folders (0700) and files (0600) of the user. The checks used to refuse as soon as a mode had drifted+(a `chmod -R`, an rsync, a restored backup) or the owner was not the current user (one `sudo strata ...` leaves root-owned folders behind).+Now:++* the folder or file is ours and only the mode bits are wrong: the mode is put back (0700 / 0600) and the command goes on;+* the filesystem cannot hold modes at all (a Windows drive seen from WSL, vfat, some network shares): one note, then it goes on;+* another account owns it (root after sudo): the check still refuses, because that is the real boundary, but the message names the+ cause and the exact command that fixes it.++Windows has no mode bits; its own check lives in `private_files` and is not touched here.+"""++from __future__ import annotations++import os+import stat+import sys+from pathlib import Path++POSIX = os.name == "posix"+_NOTED: set[str] = set()+++def owner_only_wrong(path: str | os.PathLike, details: os.stat_result) -> bool:+ """True when `path` (whose lstat or fstat is `details`) is not private to this user and could not be made so.++ Replaces `details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077`. Never follows a link and never touches+ a file that another account owns.+ """+ if not POSIX:+ return False+ if details.st_uid != os.getuid():+ return True+ if not stat.S_IMODE(details.st_mode) & 0o077:+ return False+ if stat.S_ISLNK(details.st_mode):+ return True+ want = 0o700 if stat.S_ISDIR(details.st_mode) else 0o600+ try:+ os.chmod(path, want) # not a link (checked above), so this is the file itself+ after = os.lstat(path)+ except (OSError, NotImplementedError):+ after = None+ if after is not None and after.st_uid == os.getuid() and not stat.S_IMODE(after.st_mode) & 0o077:+ return False+ # The mode did not stick although the owner is right: the filesystem has no real modes. Say it once and carry on.+ folder = str(path if stat.S_ISDIR(details.st_mode) else Path(path).parent)+ if folder not in _NOTED:+ _NOTED.add(folder)+ print(f"strata: {folder} is on a drive that cannot keep files private to your account (a Windows drive seen from Linux, "+ "a USB stick or a network share). Strata goes on; keep your data on the Linux disk to make it private.", file=sys.stderr)+ return False+++def _owner_name(uid: int) -> str:+ try:+ import pwd+ return pwd.getpwuid(uid).pw_name+ except (ImportError, KeyError):+ return f"user {uid}"+++def fix_target(path: str | os.PathLike) -> Path:+ """The highest folder above `path` (below the home folder) that another account owns: one `chown` there fixes the whole tree."""+ target = Path(path)+ home = Path.home()+ uid = os.getuid()+ best = target+ current = target+ for _ in range(6):+ parent = current.parent+ if parent == current or parent == home or parent == Path(parent.anchor):+ break+ try:+ if parent.lstat().st_uid == uid:+ break+ except OSError:+ break+ best = parent+ current = parent+ return best+++def owner_only_text(text: str, path: str | os.PathLike) -> str:+ """The message for a refused check. `text` is the old sentence ("recipe directory must be owner-only"); when another account owns+ `path` it becomes a sentence with the cause and the exact command, otherwise it is returned unchanged."""+ if not POSIX:+ return text+ try:+ owner = os.lstat(path).st_uid+ except OSError:+ return text+ if owner == os.getuid():+ return text+ subject = text.split(" must ")[0].split(" is not ")[0].strip()+ target = fix_target(path)+ return (f"{subject} belongs to {_owner_name(owner)}, not to you (usually from running Strata once with sudo). "+ f"Run this once, then try again: sudo chown -R \"$USER\" {target}")diff --git a/strata_control/recipes.py b/strata_control/recipes.pyindex 0451e524d..2c85631a6 100644--- a/strata_control/recipes.py+++ b/strata_control/recipes.py@@ -22,6 +22,7 @@ from pathlib import Pathfrom strata_control import profilesfrom strata_control.profiles import ProfileError+from strata_control import posix_ownerKINDS = frozenset({"runtime.restart", "engine.calibrate.measure", "components.verify"})@@ -44,8 +45,8 @@ def _directory(profile: str, *, create: bool = False) -> Path:details = path.lstat()if not stat.S_ISDIR(details.st_mode):raise ProfileError("recipe directory must not be a symlink", 5)- if os.name == "posix" and (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077):- raise ProfileError("recipe directory must be owner-only (mode 0700)", 5)+ if os.name == "posix" and (posix_owner.owner_only_wrong(path, details)):+ raise ProfileError(posix_owner.owner_only_text("recipe directory must be owner-only (mode 0700)", path), 5)if create:_private_mkdir(directory.parent, exist_ok=True)_private_mkdir(directory, exist_ok=True)@@ -53,8 +54,8 @@ def _directory(profile: str, *, create: bool = False) -> Path:details = directory.lstat()if not stat.S_ISDIR(details.st_mode):raise ProfileError("recipe directory must not be a symlink", 5)- if os.name == "posix" and (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077):- raise ProfileError("recipe directory must be owner-only (mode 0700)", 5)+ if os.name == "posix" and (posix_owner.owner_only_wrong(directory, details)):+ raise ProfileError(posix_owner.owner_only_text("recipe directory must be owner-only (mode 0700)", directory), 5)return directory@@ -80,8 +81,8 @@ def _history_dir(profile: str, name: str, *, create: bool = False) -> Path:if path.exists():details = path.lstat()if not stat.S_ISDIR(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)):- raise ProfileError("recipe history directory must be owner-only", 5)+ (posix_owner.owner_only_wrong(path, details))):+ raise ProfileError(posix_owner.owner_only_text("recipe history directory must be owner-only", path), 5)return directory@@ -182,8 +183,8 @@ def load(profile: str, name: str) -> tuple[dict, str]:details = path.lstat()if not stat.S_ISREG(details.st_mode) or details.st_size > MAX_BYTES:raise ProfileError("recipe must be a regular file under 64 KiB", 5)- if os.name == "posix" and (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077):- raise ProfileError("recipe file must be owner-only (mode 0600)", 5)+ if os.name == "posix" and (posix_owner.owner_only_wrong(path, details)):+ raise ProfileError(posix_owner.owner_only_text("recipe file must be owner-only (mode 0600)", path), 5)data = path.read_bytes()value = json.loads(data.decode("utf-8-sig"))except FileNotFoundError:@@ -227,7 +228,7 @@ def save(profile: str, name: str, proposed: dict, expected_revision: str) -> tupif backup.exists() or backup.is_symlink():details = backup.lstat()if not stat.S_ISREG(details.st_mode) or (os.name == "posix" and- (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077)) or \+ (posix_owner.owner_only_wrong(backup, details))) or \backup.read_bytes() != old:raise ProfileError("recipe history conflicts with the saved revision", 5)else:@@ -258,8 +259,8 @@ def rollback(profile: str, name: str, target_revision: str) -> tuple[dict, str,details = path.lstat()if not stat.S_ISREG(details.st_mode) or details.st_size > MAX_BYTES:raise ProfileError("recipe history must be a regular file under 64 KiB", 5)- if os.name == "posix" and (details.st_uid != os.getuid() or stat.S_IMODE(details.st_mode) & 0o077):- raise ProfileError("recipe history file must be owner-only", 5)+ if os.name == "posix" and (posix_owner.owner_only_wrong(path, details)):+ raise ProfileError(posix_owner.owner_only_text("recipe history file must be owner-only", path), 5)data = path.read_bytes()if profiles._revision(data) != target_revision:raise ProfileError("recipe history content does not match its revision", 5)diff --git a/strata_control/runtime.py b/strata_control/runtime.pyindex c88a94551..852de017c 100644--- a/strata_control/runtime.py+++ b/strata_control/runtime.py@@ -38,7 +38,7 @@ try:except ImportError: # Windows has no qualified owner transport yet.fcntl = None-from strata_control import owner_transport, paths, private_files, procs, profiles, readiness, winproc+from strata_control import owner_transport, paths, posix_owner, private_files, procs, profiles, readiness, winprocfrom serve import launch_identityfrom strata_control.profiles import ProfileError@@ -56,7 +56,7 @@ def _is_private(details: os.stat_result, path: Path) -> bool:return private_files.is_unshared(path)except OSError:return False- return details.st_uid == os.getuid() and not stat.S_IMODE(details.st_mode) & 0o077+ return not posix_owner.owner_only_wrong(path, details)def _lock_file(descriptor: int, *, exclusive: bool) -> bool:diff --git a/tests/terminal/test_connections.py b/tests/terminal/test_connections.pyindex 0bec26e31..9d829f00a 100644--- a/tests/terminal/test_connections.py+++ b/tests/terminal/test_connections.py@@ -3,6 +3,7 @@import ioimport jsonimport os+import statimport subprocessimport sysimport tempfile@@ -149,10 +150,12 @@ class ConnectionTests(unittest.TestCase):connections.create("local", "http://127.0.0.1:8095")if os.name == "posix":record = self.directory / "local.json"- record.chmod(0o644)- with self.assertRaisesRegex(connections.ConnectionError, "private regular"):- connections.load("local")- record.chmod(0o600)+ record.chmod(0o644) # our own file with drifted modes is put back, not refused+ connections.load("local")+ self.assertEqual(stat.S_IMODE(record.stat().st_mode), 0o600)+ with mock.patch("os.getuid", return_value=os.getuid() + 1): # a file that belongs to another account is refused+ with self.assertRaisesRegex(connections.ConnectionError, "belongs to .*sudo chown"):+ connections.load("local")record = self.directory / "local.json"corrupted = json.loads(record.read_text())corrupted["url"] = 42diff --git a/tests/terminal/test_posix_owner.py b/tests/terminal/test_posix_owner.pynew file mode 100644index 000000000..85b01e96d--- /dev/null+++ b/tests/terminal/test_posix_owner.py@@ -0,0 +1,88 @@+"""POSIX owner-only checks: our own folders with drifted modes are repaired; another account's folders get a message with the exact fix."""++import os+import stat+import tempfile+import unittest+from pathlib import Path+from unittest import mock++from strata_control import posix_owner++posix_only = unittest.skipUnless(os.name == "posix", "POSIX modes")+++@posix_only+class Repair(unittest.TestCase):+ def setUp(self):+ self.tmp = tempfile.TemporaryDirectory()+ self.root = Path(self.tmp.name)+ self.addCleanup(self.tmp.cleanup)++ def test_our_folder_with_open_modes_is_put_back_to_0700(self):+ d = self.root / "recipes"+ d.mkdir()+ os.chmod(d, 0o755)+ self.assertFalse(posix_owner.owner_only_wrong(d, d.lstat()))+ self.assertEqual(stat.S_IMODE(d.lstat().st_mode), 0o700)++ def test_our_file_with_open_modes_is_put_back_to_0600(self):+ f = self.root / "x.json"+ f.write_text("{}")+ os.chmod(f, 0o666)+ self.assertFalse(posix_owner.owner_only_wrong(f, f.lstat()))+ self.assertEqual(stat.S_IMODE(f.lstat().st_mode), 0o600)++ def test_a_private_one_is_left_alone(self):+ d = self.root / "ok"+ d.mkdir(mode=0o700)+ self.assertFalse(posix_owner.owner_only_wrong(d, d.lstat()))++ def test_a_link_is_never_followed_or_repaired(self):+ target = self.root / "t"+ target.mkdir()+ os.chmod(target, 0o755)+ link = self.root / "l"+ os.symlink(target, link)+ self.assertTrue(posix_owner.owner_only_wrong(link, link.lstat()))+ self.assertEqual(stat.S_IMODE(target.lstat().st_mode), 0o755)++ def test_a_folder_owned_by_someone_else_is_refused_and_not_touched(self):+ d = self.root / "root-made"+ d.mkdir()+ os.chmod(d, 0o755)+ with mock.patch.object(posix_owner.os, "getuid", return_value=os.getuid() + 1):+ self.assertTrue(posix_owner.owner_only_wrong(d, d.lstat()))+ text = posix_owner.owner_only_text("recipe directory must be owner-only (mode 0700)", d)+ self.assertEqual(stat.S_IMODE(d.lstat().st_mode), 0o755)+ self.assertIn("recipe directory belongs to", text)+ self.assertIn("sudo", text)+ self.assertIn("sudo chown -R \"$USER\"", text)+ self.assertNotIn("0700", text)++ def test_a_filesystem_that_keeps_no_modes_warns_once_and_goes_on(self):+ d = self.root / "drvfs"+ d.mkdir()+ os.chmod(d, 0o777)+ posix_owner._NOTED.discard(str(d))+ with mock.patch.object(posix_owner.os, "chmod"), mock.patch("sys.stderr") as err:+ self.assertFalse(posix_owner.owner_only_wrong(d, d.lstat()))+ self.assertFalse(posix_owner.owner_only_wrong(d, d.lstat()))+ printed = "".join(str(c.args[0]) for c in err.write.call_args_list)+ self.assertEqual(printed.count("cannot keep files private"), 1)++ def test_the_text_of_our_own_folder_is_unchanged(self):+ d = self.root / "mine"+ d.mkdir()+ self.assertEqual(posix_owner.owner_only_text("x must be owner-only", d), "x must be owner-only")+++class Windows(unittest.TestCase):+ def test_nothing_changes_off_posix(self):+ with mock.patch.object(posix_owner, "POSIX", False):+ self.assertFalse(posix_owner.owner_only_wrong(".", os.stat(".")))+ self.assertEqual(posix_owner.owner_only_text("x", "."), "x")+++if __name__ == "__main__":+ unittest.main()