"""Name the programs holding ``apps/desktop/release`` open by working directory (#101789). Windows refuses to rename a directory that a live process uses as its current working directory. A resident helper that some Hermes window spawned (an IME cloud service such as Sogou's ``SogouCloud.exe``, an AV or assistant component) inherits that window's cwd inside ``release/win-unpacked`` and keeps it after the app exits, so the stage-and-swap promotion fails on every retry although the build succeeded. Its exe lives elsewhere, so the exe-under-release stop never sees it. These holders belong to the user, not to Hermes: they are NAMED in the failure and closed only with the user's consent, given either at an interactive terminal prompt or through the Desktop's "close it and retry" choice. That choice leaves a consent file in ``release/`` bound to the hand-off run it starts and to the exact processes (pid + start time) the user saw; the next swap attempt consumes it whatever its source, and only that run's swap may act on it. A non-interactive run with no matching consent never closes anything. """ from __future__ import annotations import contextlib import json import os import sys import time from dataclasses import dataclass from pathlib import Path from typing import Callable, Optional # windows.ps1 parses this exact prefix out of the update output (one line per holder). HOLDER_LINE_PREFIX = "Desktop app folder held by: " # Written by the Desktop when the user chooses "Close and retry"; removed at the start # of the next promotion swap attempt, so a consent covers exactly one retry. CONSENT_FILE_NAME = ".close-holders-consent.json" # psutil create_time is a float rebuilt from the OS on each read: equal within this tolerance. _START_TIME_TOLERANCE_S = 0.5 _CLOSE_WAIT_S = 5 @dataclass(frozen=True) class ReleaseHolder: pid: int name: str exe: str create_time: float def describe(self) -> str: return f"{self.name} (pid {self.pid}, {self.exe or 'path unreadable'})" def holder_line(self) -> str: """The machine-read line windows.ps1 hands to the Desktop (pid + start time identify it).""" return (f"{HOLDER_LINE_PREFIX}{self.name} (pid {self.pid}, started {self.create_time:.3f}, " f"{self.exe or 'path unreadable'})") @dataclass(frozen=True) class HolderConsent: """The processes the user agreed to close, as (pid, start time, normalized exe).""" holders: frozenset[tuple[int, float, str]] = frozenset() def covers(self, holder: ReleaseHolder) -> bool: return bool(holder.exe) and any( pid == holder.pid and abs(start - holder.create_time) <= _START_TIME_TOLERANCE_S and exe == _norm(holder.exe) for pid, start, exe in self.holders ) NO_CONSENT = HolderConsent() def _norm(path: str) -> str: return os.path.normcase(os.path.abspath(path)) def _inside(path: str, root: str) -> bool: return path == root or path.startswith(root.rstrip("\\/") + os.sep) def _release_root(release_dir: Path) -> Optional[str]: try: return _norm(str(release_dir.resolve())) except OSError: return None def _exe_or_empty(proc) -> str: """Read only for a matched holder: another process's exe is none of our business.""" try: return proc.exe() or "" except Exception: # health: allow BLE001 -- access denied for a protected process: named without a path return "" def find_release_cwd_holders(folder: Path) -> list[ReleaseHolder]: """Every other process whose working directory is ``folder`` (the app folder being renamed, e.g. ``release/win-unpacked``) or below it. A process whose cwd cannot be read (another user's, access denied) is skipped: it cannot be shown to hold the tree. Never raises. """ root = _release_root(folder) try: import psutil procs = psutil.process_iter(["pid", "name"]) except Exception: # health: allow BLE001 -- diagnostics on a failure path; no psutil = no names return [] if root is None: return [] me = os.getpid() holders: list[ReleaseHolder] = [] for proc in procs: try: if proc.pid == me: continue cwd = proc.cwd() if not cwd or not _inside(_norm(cwd), root): continue holders.append(ReleaseHolder( pid=int(proc.pid), name=proc.info.get("name") or "unknown program", exe=_exe_or_empty(proc), create_time=float(proc.create_time()), )) except Exception: # health: allow BLE001 -- psutil raises per-process (gone, denied, zombie) continue return holders def take_consent(release_dir: Path, run_id: Optional[str]) -> HolderConsent: """Consume the Desktop's consent at the start of a swap attempt: the file is removed whether or not it applies, and it applies only to the hand-off run that the Desktop started for it.""" path = release_dir / CONSENT_FILE_NAME try: raw = path.read_bytes() except OSError: return NO_CONSENT with contextlib.suppress(OSError): path.unlink() try: data = json.loads(raw.decode("utf-8-sig")) if not run_id or data.get("run_id") != run_id: return NO_CONSENT holders = frozenset( (int(h["pid"]), float(h["start_time"]), _norm(h["exe"])) for h in data["holders"] if isinstance(h.get("exe"), str) and h["exe"] ) except (ValueError, TypeError, KeyError, AttributeError): return NO_CONSENT return HolderConsent(holders) def _ask_at_terminal(holders: list[ReleaseHolder], input_fn: Callable[[str], str]) -> bool: """Only a person at a terminal can answer; a hidden hand-off or a pipe never consents.""" if not holders or not (sys.stdin and sys.stdin.isatty() and sys.stdout and sys.stdout.isatty()): return False names = ", ".join(h.describe() for h in holders) try: answer = input_fn(f" Close {names} and retry? [y/N] ") except (EOFError, KeyboardInterrupt): return False return answer.strip().lower() in ("y", "yes") def close_holders(holders: list[ReleaseHolder], folder: Path) -> list[int]: """Terminate exactly these holders, each re-checked right before: same pid AND creation time (no recycled pid), cwd still inside ``folder``, and not one of our ancestors.""" root = _release_root(folder) try: import psutil ancestors = {p.pid for p in psutil.Process(os.getpid()).parents()} except Exception: # health: allow BLE001 -- no process table means nothing can be verified return [] targets = [] for holder in holders: try: proc = psutil.Process(holder.pid) if proc.pid in ancestors or abs(proc.create_time() - holder.create_time) > _START_TIME_TOLERANCE_S: continue if root is None or not _inside(_norm(proc.cwd()), root): continue proc.terminate() targets.append(proc) except Exception: # health: allow BLE001 -- gone or denied: it is not closed by us continue if targets: with contextlib.suppress(Exception): _, alive = psutil.wait_procs(targets, timeout=_CLOSE_WAIT_S) for proc in alive: with contextlib.suppress(Exception): proc.kill() if alive: psutil.wait_procs(alive, timeout=_CLOSE_WAIT_S) return [int(p.pid) for p in targets if not p.is_running()] def release_after_refused_rename( folder: Path, *, consent: HolderConsent = NO_CONSENT, input_fn: Callable[[str], str] = input, ) -> tuple[list[ReleaseHolder], list[int]]: """After Windows refused to rename ``folder``: name every cwd holder inside it, then close the ones covered by ``consent`` (taken at the start of this swap attempt) or agreed to at the terminal. Returns (holders found, pids closed).""" holders = find_release_cwd_holders(folder) if not holders: return [], [] # Human lines only: the machine lines go out once, for the holders still in the way when the # swap is given up (describe_block), so a holder closed here is not offered to the Desktop again. for holder in holders: print(f" {holder.describe()}") chosen = [h for h in holders if consent.covers(h)] # A holder whose program path cannot be read is usually protected (another user, elevated): # it cannot be closed from here either, so the user closes it themselves. closable = [h for h in holders if h.exe] for holder in holders: if not holder.exe: print(f" Close {holder.name} (pid {holder.pid}) yourself: Hermes cannot close it.") if not chosen and _ask_at_terminal(closable, input_fn): chosen = closable if not chosen: return holders, [] closed = close_holders(chosen, folder) if closed: print(f" ✓ Closed with your consent: {', '.join(h.describe() for h in chosen if h.pid in closed)}") return holders, closed def describe_block(holders: list[ReleaseHolder], release_dir: Path) -> str: """The final report of a refused swap; ``holders`` are the ones still holding the folder.""" names = ", ".join(h.describe() for h in holders) pids = " ".join(f"/PID {h.pid}" for h in holders) return ( "".join(f" {h.holder_line()}\n" for h in holders) + f"✗ Windows would not replace the desktop app: {names} is using a folder inside {release_dir}.\n" f" It is not part of Hermes, so it was left running. Close it (Task Manager, or `taskkill {pids}`)\n" " and run `hermes desktop --force-build`, or run Update now in Hermes Desktop and choose to close it." ) def holder_names(holders: list[ReleaseHolder]) -> str: return ", ".join(f"{h.name} (pid {h.pid})" for h in holders)