freemyid 0.2.0.dev1__py3-none-any.whl

freemyid/scheduler/__init__.py

@@ -0,0 +1,203 @@
+"""Background re-check job: install / remove / status. Runs `freemyid run --scheduled`.
+
+Rendering lives in render.py (pure, testable). The functions here are the only code that
+touches the system, and only when the user explicitly asks (`freemyid schedule install`).
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from .. import paths
+from . import render
+
+__all__ = ["install", "job_command", "platform_name", "remove", "status", "windows_create_args",
+           "windows_delete_args", "windows_query_args"]
+
+
+def platform_name() -> str:
+    if sys.platform.startswith("linux"):
+        return "linux"
+    if sys.platform == "darwin":
+        return "macos"
+    if sys.platform == "win32":
+        return "windows"
+    raise RuntimeError("Scheduling is not supported on this system.")
+
+
+def _windowless_python() -> str:
+    """pythonw.exe next to python.exe (no console window); falls back to python.exe."""
+    exe = Path(sys.executable)
+    pw = exe.with_name("pythonw.exe")
+    return str(pw) if pw.exists() else str(exe)
+
+
+def job_command(frozen: bool | None = None, platform: str | None = None) -> list[str]:
+    """The command the scheduler runs. Arguments let tests render it for any OS."""
+    frozen = getattr(sys, "frozen", False) if frozen is None else frozen
+    win = (sys.platform == "win32") if platform is None else platform == "windows"
+    # Linux/macOS jobs run `run --headless --scheduled` (no prompts, fails closed).
+    # DEPENDENCY: the --headless flag is added to cli.py by another engineer.
+    tail = ["run", "--scheduled"] if win else ["run", "--headless", "--scheduled"]
+    if frozen:
+        exe = Path(sys.executable)
+        if win:   # the windowed FreeMyID.exe, so no console window flashes
+            gui = exe.with_name("FreeMyID.exe")
+            return [str(gui if gui.exists() else exe), *tail]
+        return [str(exe), *tail]
+    if win:
+        return [_windowless_python(), "-c", "from freemyid.cli import app; app()",
+                *tail]
+    exe_path = shutil.which("freemyid")
+    if exe_path:
+        return [exe_path, *tail]
+    return [sys.executable, "-c", "from freemyid.cli import app; app()", *tail]
+
+
+def _run(args: list[str], input: str | None = None) -> subprocess.CompletedProcess:
+    flags = getattr(subprocess, "CREATE_NO_WINDOW", 0) if sys.platform == "win32" else 0
+    return subprocess.run(args, input=input, check=False, capture_output=True, text=True,
+                          timeout=60, creationflags=flags)
+
+
+def _job_env() -> dict[str, str]:
+    """Settings the job needs that a systemd/launchd session would not inherit."""
+    return {k: os.environ[k] for k in render.ENV_PASSTHROUGH if os.environ.get(k)}
+
+
+def _uid() -> int:
+    return os.getuid()
+
+
+def _launchd_domain() -> str:
+    return f"gui/{_uid()}"
+
+
+def _systemd_dir() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "systemd" / "user"
+
+
+def _plist_path() -> Path:
+    return Path.home() / "Library" / "LaunchAgents" / f"{render.LABEL}.plist"
+
+
+def _has_systemd_user() -> bool:
+    if not shutil.which("systemctl"):
+        return False
+    try:
+        return _run(["systemctl", "--user", "show-environment"]).returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def _crontab_get() -> str:
+    r = _run(["crontab", "-l"])
+    return r.stdout if r.returncode == 0 else ""
+
+
+def _strip_cron(text: str) -> str:
+    return "".join(ln + "\n" for ln in text.splitlines() if render.CRON_MARK not in ln)
+
+
+def windows_create_args(xml_path: str) -> list[str]:
+    # No /RU or /RP: the task belongs to the current user and needs no admin rights.
+    return ["schtasks", "/Create", "/TN", render.TASK, "/XML", xml_path, "/F"]
+
+
+def windows_delete_args() -> list[str]:
+    return ["schtasks", "/Delete", "/TN", render.TASK, "/F"]
+
+
+def windows_query_args() -> list[str]:
+    return ["schtasks", "/Query", "/TN", render.TASK]
+
+
+def install() -> str:
+    cmd = job_command()
+    plat = platform_name()
+    if plat == "linux":
+        if _has_systemd_user():
+            d = _systemd_dir()
+            d.mkdir(parents=True, exist_ok=True)
+            (d / f"{render.UNIT}.service").write_text(render.systemd_service(cmd, _job_env()))
+            (d / f"{render.UNIT}.timer").write_text(render.systemd_timer())
+            _run(["systemctl", "--user", "daemon-reload"])
+            r = _run(["systemctl", "--user", "enable", "--now", f"{render.UNIT}.timer"])
+            if r.returncode != 0:
+                raise RuntimeError("Could not start the systemd timer.")
+            return ("Installed a daily systemd user timer. If the computer was off, the check "
+                    "runs when it next starts. On a server nobody logs in to, also run: "
+                    "loginctl enable-linger $USER")
+        if shutil.which("crontab"):
+            new = _strip_cron(_crontab_get()) + render.cron_lines(cmd)
+            if _run(["crontab", "-"], input=new).returncode != 0:
+                raise RuntimeError("Could not update crontab.")
+            return "Installed a daily cron job plus a run at startup."
+        raise RuntimeError("Neither systemd nor cron is available.")
+    if plat == "macos":
+        p = _plist_path()
+        p.parent.mkdir(parents=True, exist_ok=True)
+        paths.logs_dir().mkdir(parents=True, exist_ok=True)
+        p.write_text(render.launchd_plist(cmd, str(paths.logs_dir() / "scheduler.log"),
+                                          _job_env()))
+        _run(["launchctl", "bootout", f"{_launchd_domain()}/{render.LABEL}"])  # ok if absent
+        if _run(["launchctl", "bootstrap", _launchd_domain(), str(p)]).returncode != 0:
+            raise RuntimeError("Could not load the launchd agent.")
+        return "Installed a daily launchd agent. Missed runs happen when the Mac wakes."
+    xml = paths.home() / "freemyid-task.xml"
+    xml.write_text(render.windows_task_xml(cmd), encoding="utf-16")
+    try:   # /F replaces an existing task, so installing twice is harmless
+        r = _run(windows_create_args(str(xml)))
+    finally:
+        xml.unlink(missing_ok=True)
+    if r.returncode != 0:
+        raise RuntimeError("Could not create the scheduled task.")
+    return "Installed a daily scheduled task that also runs after a missed start."
+
+
+def remove() -> str:
+    plat = platform_name()
+    if plat == "linux":
+        if shutil.which("systemctl"):
+            _run(["systemctl", "--user", "disable", "--now", f"{render.UNIT}.timer"])
+        d = _systemd_dir()
+        for ext in ("service", "timer"):
+            (d / f"{render.UNIT}.{ext}").unlink(missing_ok=True)
+        if shutil.which("crontab"):
+            cur = _crontab_get()
+            if render.CRON_MARK in cur:
+                _run(["crontab", "-"], input=_strip_cron(cur))
+        return "Background checks removed."
+    if plat == "macos":
+        p = _plist_path()
+        _run(["launchctl", "bootout", f"{_launchd_domain()}/{render.LABEL}"])
+        p.unlink(missing_ok=True)
+        return "Background checks removed."
+    _run(windows_delete_args())    # fails harmlessly if it was never installed
+    return "Background checks removed."
+
+
+def status() -> str:
+    try:
+        plat = platform_name()
+    except RuntimeError as e:
+        return str(e)
+    if plat == "linux":
+        if (_systemd_dir() / f"{render.UNIT}.timer").exists():
+            en = _run(["systemctl", "--user", "is-enabled", f"{render.UNIT}.timer"])
+            ac = _run(["systemctl", "--user", "is-active", f"{render.UNIT}.timer"])
+            return (f"systemd timer: {ac.stdout.strip() or 'unknown'}, "
+                    f"{en.stdout.strip() or 'unknown'}")
+        if shutil.which("crontab") and render.CRON_MARK in _crontab_get():
+            return "cron job installed"
+        return "not installed"
+    if plat == "macos":
+        if not _plist_path().exists():
+            return "not installed"
+        r = _run(["launchctl", "print", f"{_launchd_domain()}/{render.LABEL}"])
+        return "launchd agent loaded" if r.returncode == 0 else "launchd agent installed, not loaded"
+    r = _run(windows_query_args())
+    return "scheduled task installed" if r.returncode == 0 else "not installed"

freemyid/scheduler/render.py

@@ -0,0 +1,91 @@
+"""Pure renderers for scheduler files. Nothing here touches the system."""
+from __future__ import annotations
+
+import shlex
+import subprocess
+from xml.sax.saxutils import escape as xesc
+
+LABEL = "org.freemyid.recheck"
+UNIT = "freemyid-recheck"
+TASK = "Free My ID Recheck"
+DAILY_HOUR = 10
+
+
+ENV_PASSTHROUGH = ("FREEMYID_HOME", "FREEMYID_PASSPHRASE_FILE")
+
+
+def systemd_service(cmd: list[str], env: dict[str, str] | None = None) -> str:
+    envs = "".join(f"Environment={_sd_quote(f'{k}={v}')}\n" for k, v in (env or {}).items())
+    return ("[Unit]\nDescription=Free My ID scheduled re-check (no UI, no email without approval)\n\n"
+            f"[Service]\nType=oneshot\nNice=10\n{envs}"
+            f"ExecStart={' '.join(_sd_quote(c) for c in cmd)}\n")
+
+
+def _sd_quote(s: str) -> str:
+    return '"' + s.replace("\\", "\\\\").replace('"', '\\"').replace("%", "%%") + '"'
+
+
+def systemd_timer() -> str:
+    # Persistent=true: a run missed while the machine was off/asleep fires at next boot/wake.
+    return ("[Unit]\nDescription=Run Free My ID re-check daily\n\n[Timer]\nOnCalendar=daily\n"
+            "Persistent=true\nRandomizedDelaySec=15min\n\n[Install]\nWantedBy=timers.target\n")
+
+
+CRON_MARK = "# freemyid-recheck"
+
+
+def cron_lines(cmd: list[str]) -> str:
+    c = " ".join(shlex.quote(x) for x in cmd)
+    return (f"0 {DAILY_HOUR} * * * {c} {CRON_MARK}\n"
+            f"@reboot sleep 120 && {c} {CRON_MARK}\n")
+
+
+def launchd_plist(cmd: list[str], log_path: str, env: dict[str, str] | None = None) -> str:
+    envx = ""
+    if env:
+        items = "".join(f"    <key>{xesc(k)}</key>\n    <string>{xesc(v)}</string>\n"
+                        for k, v in env.items())
+        envx = f"  <key>EnvironmentVariables</key>\n  <dict>\n{items}  </dict>\n"
+    args = "".join(f"    <string>{xesc(c)}</string>\n" for c in cmd)
+    # launchd runs a job missed during sleep when the Mac wakes.
+    return ('<?xml version="1.0" encoding="UTF-8"?>\n'
+            '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" '
+            '"http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0">\n<dict>\n'
+            f"  <key>Label</key>\n  <string>{LABEL}</string>\n{envx}"
+            f"  <key>ProgramArguments</key>\n  <array>\n{args}  </array>\n"
+            "  <key>StartCalendarInterval</key>\n  <dict>\n"
+            f"    <key>Hour</key>\n    <integer>{DAILY_HOUR}</integer>\n"
+            "    <key>Minute</key>\n    <integer>0</integer>\n  </dict>\n"
+            "  <key>RunAtLoad</key>\n  <false/>\n  <key>ProcessType</key>\n  <string>Background</string>\n"
+            f"  <key>StandardErrorPath</key>\n  <string>{xesc(log_path)}</string>\n"
+            f"  <key>StandardOutPath</key>\n  <string>{xesc(log_path)}</string>\n"
+            "</dict>\n</plist>\n")
+
+
+def windows_task_xml(cmd: list[str], hour: int = DAILY_HOUR) -> str:
+    """Per-user Task Scheduler XML (no admin needed).
+
+    Daily trigger; StartWhenAvailable = run as soon as possible after a missed start;
+    A windowed executable (FreeMyID.exe / pythonw.exe) = no console window flashes.
+    """
+    exe, args = cmd[0], subprocess.list2cmdline(cmd[1:])
+    return ('<?xml version="1.0" encoding="UTF-16"?>\n'
+            '<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">\n'
+            "  <RegistrationInfo><Description>Free My ID: quiet daily check for data-broker "
+            "listings. Only bothers you when it needs help.</Description></RegistrationInfo>\n"
+            "  <Triggers>\n    <CalendarTrigger>\n"
+            f"      <StartBoundary>2000-01-01T{hour:02d}:00:00</StartBoundary>\n"
+            "      <Enabled>true</Enabled>\n      <ScheduleByDay><DaysInterval>1</DaysInterval>"
+            "</ScheduleByDay>\n    </CalendarTrigger>\n  </Triggers>\n"
+            "  <Principals><Principal id=\"Author\"><LogonType>InteractiveToken</LogonType>"
+            "<RunLevel>LeastPrivilege</RunLevel></Principal></Principals>\n"
+            "  <Settings>\n    <StartWhenAvailable>true</StartWhenAvailable>\n"
+            "    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>\n"
+            "    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>\n"
+            "    <RunOnlyIfNetworkAvailable>true</RunOnlyIfNetworkAvailable>\n"
+            "    <WakeToRun>false</WakeToRun>\n    <Hidden>false</Hidden>\n"
+            "    <Enabled>true</Enabled>\n"
+            "    <ExecutionTimeLimit>PT2H</ExecutionTimeLimit>\n"
+            "    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\n  </Settings>\n"
+            f"  <Actions Context=\"Author\">\n    <Exec>\n      <Command>{xesc(exe)}</Command>\n"
+            f"      <Arguments>{xesc(args)}</Arguments>\n    </Exec>\n  </Actions>\n</Task>\n")