lambda-watcher 0.1.0__tar.gz → 0.1.1__tar.gz

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-watcher
-Version: 0.1.0
+Version: 0.1.1
 Summary: Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions.
 Author: Lambda Watcher contributors
 License: Apache-2.0
@@ -45,7 +45,7 @@ to how you work. You keep downloading zips; it does the rest.
 
 ```
 $ lambda-watcher watch
-lambda-watcher 0.1.0 — archiving into ~/.lambda-watcher
+lambda-watcher 0.1.1 — archiving into ~/.lambda-watcher
 watching ~/Downloads. Press Ctrl-C to stop.
                new  order-processor v0001  order-processor.zip — archived a new version
                new  order-processor v0002  order-processor (1).zip — 2 added, 2 modified, 3 renamed, 52 vendored

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/README.md

@@ -14,7 +14,7 @@ to how you work. You keep downloading zips; it does the rest.
 
 ```
 $ lambda-watcher watch
-lambda-watcher 0.1.0 — archiving into ~/.lambda-watcher
+lambda-watcher 0.1.1 — archiving into ~/.lambda-watcher
 watching ~/Downloads. Press Ctrl-C to stop.
                new  order-processor v0001  order-processor.zip — archived a new version
                new  order-processor v0002  order-processor (1).zip — 2 added, 2 modified, 3 renamed, 52 vendored

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lambda-watcher"
-version = "0.1.0"
+version = "0.1.1"
 description = "Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions."
 readme = "README.md"
 requires-python = ">=3.10"

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/src/lambda_watcher/__init__.py

@@ -1,4 +1,4 @@
 """Watch a downloads folder for AWS Lambda deployment packages and version them."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __all__ = ["__version__"]

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/src/lambda_watcher/cli.py

@@ -27,7 +27,13 @@ from .diffing.render_html import render_timeline, write_html
 from .diffing.render_text import render as render_diff
 from .gitmirror import git_available
 from .ingest import Ingestor
-from .service import ServiceError, ServiceStatus, current_status, get_manager
+from .service import (
+    ServiceError,
+    ServiceStatus,
+    current_status,
+    install_service,
+    stop_service,
+)
 from .store import Store
 from .utils import format_ts, human_size, relative_ts, rmtree, setup_logging, slugify
 
@@ -268,9 +274,14 @@ def _main(
 
 # --------------------------------------------------------------- dashboard
 def _home_relative(path: Path) -> str:
-    """``~/Downloads`` rather than ``/Users/someone/Downloads``, where it applies."""
+    """``~/Downloads`` rather than ``/Users/someone/Downloads``, where it applies.
+
+    The separator is the platform's, not a hardcoded slash: pasting ``~/`` onto
+    a Windows relative path produced ``~/.lambda-watcher\\config.yaml``, which
+    is a path from neither operating system.
+    """
     try:
-        return "~/" + str(path.relative_to(Path.home()))
+        return f"~{os.sep}{path.relative_to(Path.home())}"
     except ValueError:
         return str(path)
 
@@ -446,17 +457,23 @@ def _offer_backfill(cfg: Config, yes: bool) -> None:
 
 
 # ------------------------------------------------------------------ service
-def _start_service(cfg: Config) -> None:
-    """Install and start the background watcher, explaining whatever happens."""
-    manager = get_manager(cfg, _CONFIG_PATH)
+def _start_service(cfg: Config) -> bool:
+    """Install and start the background watcher, explaining whatever happens.
+
+    Returns whether it got one. Not being able to install a service is a
+    disappointment, not a catastrophe — everything else `setup` did still
+    stands, and `lw watch` still works — so this reports and lets the caller
+    decide whether that is fatal.
+    """
     try:
-        state = manager.install()
+        state = install_service(cfg, _CONFIG_PATH)
     except ServiceError as exc:
-        _fail(
-            f"{exc}\n"
-            "  Run [bold]lw watch[/bold] in a terminal instead, or see docs/autostart.md "
-            "for the manual recipe."
+        err_console.print(
+            f"  [yellow]![/yellow] could not install a background watcher: {exc}\n"
+            "    [dim]Run [bold]lw watch[/bold] in a terminal instead, or see docs/autostart.md "
+            "for the manual recipe.[/dim]"
         )
+        return False
     if state.running:
         console.print(f"  [green]●[/green] watching in the background   [dim]{state.manager}[/dim]")
     else:
@@ -469,13 +486,21 @@ def _start_service(cfg: Config) -> None:
             "  [dim]no systemd user session here, so this will not come back after a reboot; "
             "run [bold]lw start[/bold] again, or see docs/autostart.md[/dim]"
         )
+    elif state.manager == "startup-folder":
+        console.print(
+            "  [dim]registering a scheduled task was refused, so this starts from your "
+            "Startup folder instead — it will come back at logon, but nothing will "
+            "restart it if it crashes[/dim]"
+        )
+    return True
 
 
 @app.command(rich_help_panel="Watching")
 def start() -> None:
     """Watch in the background, now and after every reboot."""
     cfg = _cfg()
-    _start_service(cfg)
+    if not _start_service(cfg):
+        raise typer.Exit(1)
 
 
 @app.command(rich_help_panel="Watching")
@@ -486,12 +511,8 @@ def stop(
 ) -> None:
     """Stop the background watcher."""
     cfg = _cfg()
-    manager = get_manager(cfg, _CONFIG_PATH)
     try:
-        if remove:
-            manager.uninstall()
-        else:
-            manager.stop()
+        stop_service(cfg, _CONFIG_PATH, remove=remove)
     except ServiceError as exc:
         _fail(str(exc))
     console.print(
@@ -504,12 +525,12 @@ def stop(
 def restart() -> None:
     """Stop and start the background watcher — use it after editing the config."""
     cfg = _cfg()
-    manager = get_manager(cfg, _CONFIG_PATH)
     try:
-        state = manager.restart()
+        stop_service(cfg, _CONFIG_PATH)
     except ServiceError as exc:
         _fail(str(exc))
-    console.print(f"[dim]{state.summary} ({state.manager})[/dim]")
+    if not _start_service(cfg):
+        raise typer.Exit(1)
 
 
 # ----------------------------------------------------------------- checkup

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/src/lambda_watcher/service.py

@@ -19,6 +19,7 @@ that is exactly where a filesystem watcher gets used.
 
 from __future__ import annotations
 
+import getpass
 import os
 import shutil
 import signal
@@ -66,7 +67,7 @@ class ServiceStatus:
 
 
 # --------------------------------------------------------------- command
-def watch_argv(config_path: Path | None = None) -> list[str]:
+def watch_argv(config_path: Path | None = None, windowless: bool = False) -> list[str]:
     """The command a service manager should run, as absolute argv.
 
     A unit file is read by a daemon with no shell, no virtualenv activation and
@@ -76,6 +77,15 @@ def watch_argv(config_path: Path | None = None) -> list[str]:
     but the console script reads far better in a file a human may open, so it
     wins whenever we can find it next to the running interpreter.
     """
+    if windowless:
+        # A launcher that runs at logon must not flash a console window, and
+        # only the interpreter has a windowless build - the console script does
+        # not.
+        argv = [_python_for_service(), "-m", "lambda_watcher"]
+        if config_path is not None:
+            argv += ["--config", str(Path(config_path).expanduser().resolve())]
+        return [*argv, "watch"]
+
     argv: list[str] = []
     script_dir = Path(sys.executable).parent
     suffixes = (".exe", "") if sys.platform.startswith("win") else ("",)
@@ -149,25 +159,23 @@ class Manager:
     """One platform's way of running something at login and keeping it up."""
 
     name = "none"
+    #: Launchers that run at logon with no console attached set this.
+    windowless = False
 
     def __init__(self, cfg: Config, config_path: Path | None = None) -> None:
         self.cfg = cfg
         self.config_path = config_path
 
-    # Subclasses implement these four; `restart` is derived from them.
+    # Every manager implements these four.
     def install(self) -> ServiceStatus: raise NotImplementedError
     def uninstall(self) -> None: raise NotImplementedError
     def stop(self) -> None: raise NotImplementedError
     def status(self) -> ServiceStatus: raise NotImplementedError
 
-    def restart(self) -> ServiceStatus:
-        self.stop()
-        return self.install()
-
     # -- shared helpers --------------------------------------------------
     @property
     def argv(self) -> list[str]:
-        return watch_argv(self.config_path)
+        return watch_argv(self.config_path, windowless=self.windowless)
 
     @property
     def log_path(self) -> Path:
@@ -347,9 +355,13 @@ class SchtasksManager(Manager):
     def install(self) -> ServiceStatus:
         self._prepare_logs()
         command = " ".join(_win_quote(a) for a in self.argv)
+        # /RU is not decoration. With ONLOGON and no /RU the task fires for *any*
+        # user who logs on, which is a machine-wide change and needs an elevated
+        # prompt - "ERROR: Access is denied." on an ordinary account. Naming the
+        # current user scopes the trigger to them, which they are allowed to do.
         _run([
             "schtasks", "/Create", "/TN", SCHEDULED_TASK, "/TR", command,
-            "/SC", "ONLOGON", "/F", "/RL", "LIMITED",
+            "/SC", "ONLOGON", "/RU", getpass.getuser(), "/F", "/RL", "LIMITED",
         ], check=True)
         # ONLOGON only fires at the *next* logon, so start it once by hand to
         # make `lw start` mean what it says.
@@ -400,8 +412,8 @@ class PidfileManager(Manager):
             proc = subprocess.Popen(
                 self.argv,
                 stdout=handle, stderr=handle, stdin=subprocess.DEVNULL,
-                start_new_session=True,
                 env={**os.environ, **service_environment(self.cfg)},
+                **_detach_kwargs(),
             )
         except OSError as exc:
             handle.close()
@@ -419,12 +431,7 @@ class PidfileManager(Manager):
         pid = self._recorded_pid()
         if pid is None:
             return
-        try:
-            os.kill(pid, signal.SIGTERM)
-        except ProcessLookupError:
-            pass
-        except OSError as exc:
-            raise ServiceError(f"could not stop pid {pid}: {exc}") from exc
+        _terminate(pid)
         self.pid_path.unlink(missing_ok=True)
 
     def status(self) -> ServiceStatus:
@@ -458,6 +465,12 @@ def _pid_alive(pid: int) -> bool:
     caller that outlives the watcher (the test suite, a `lw status` in the same
     session) from reporting a stopped watcher as running.
     """
+    if sys.platform.startswith("win"):
+        # `os.kill(pid, 0)` on Windows is TerminateProcess with an exit code of
+        # zero, not a probe, so asking whether a process is alive would end it.
+        # tasklist only looks.
+        proc = _run(["tasklist", "/FI", f"PID eq {pid}", "/NH", "/FO", "CSV"])
+        return f'"{pid}"' in proc.stdout
     try:
         reaped, _status = os.waitpid(pid, os.WNOHANG)
         if reaped == pid:
@@ -466,11 +479,6 @@ def _pid_alive(pid: int) -> bool:
         pass                                          # not ours; nothing to reap
     except (AttributeError, OSError):
         pass                                          # no usable waitpid here
-    if sys.platform.startswith("win"):
-        # `os.kill(pid, 0)` on Windows is TerminateProcess with an exit code of
-        # zero, not a probe. Nothing selects PidfileManager there, and this
-        # would be a spectacular way to find out otherwise.
-        return False
     try:
         os.kill(pid, 0)
     except ProcessLookupError:
@@ -482,21 +490,138 @@ def _pid_alive(pid: int) -> bool:
     return True
 
 
-# ---------------------------------------------------------------- factory
-def get_manager(cfg: Config, config_path: Path | None = None) -> Manager:
-    """The right manager for this machine.
+def _terminate(pid: int) -> None:
+    """Ask a process to stop, by whatever means the platform offers."""
+    if sys.platform.startswith("win"):
+        _run(["taskkill", "/PID", str(pid), "/T", "/F"])
+        return
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except ProcessLookupError:
+        pass
+    except OSError as exc:
+        raise ServiceError(f"could not stop pid {pid}: {exc}") from exc
+
+
+def _detach_kwargs() -> dict[str, object]:
+    """Popen arguments that outlive this process, per platform."""
+    if sys.platform.startswith("win"):
+        flags = getattr(subprocess, "DETACHED_PROCESS", 0) | getattr(
+            subprocess, "CREATE_NEW_PROCESS_GROUP", 0
+        )
+        return {"creationflags": flags}
+    return {"start_new_session": True}
+
+
+class StartupFolderManager(PidfileManager):
+    """Windows fallback: a launcher in this user's own Startup folder.
+
+    An account that may not register a scheduled task can still drop a file in
+    its own Startup folder — the oldest per-user autostart Windows has, and the
+    one that needs no privileges whatsoever. It is strictly less capable than
+    Task Scheduler (nothing restarts the watcher if it crashes), which is why it
+    is the second choice rather than the first.
+    """
+
+    name = "startup-folder"
+    windowless = True
+
+    @property
+    def script_path(self) -> Path:
+        appdata = os.environ.get("APPDATA")
+        base = Path(appdata) if appdata else Path.home() / "AppData" / "Roaming"
+        return (
+            base / "Microsoft" / "Windows" / "Start Menu" / "Programs" / "Startup"
+            / "lambda-watcher.cmd"
+        )
 
-    Order is per-platform preference with a working fallback, never an error:
-    somebody on WSL should still get a background watcher out of ``lw start``,
-    just one that is honest about not surviving a reboot.
+    def install(self) -> ServiceStatus:
+        state = super().install()                      # running now, pid recorded
+        self.script_path.parent.mkdir(parents=True, exist_ok=True)
+        self.script_path.write_text(self._script(), encoding="utf-8")
+        state.unit_path = self.script_path
+        state.detail = "starts at logon from your Startup folder"
+        return state
+
+    def uninstall(self) -> None:
+        self.script_path.unlink(missing_ok=True)
+        super().uninstall()
+
+    def status(self) -> ServiceStatus:
+        state = super().status()
+        if self.script_path.exists():
+            state.installed = True
+            state.unit_path = self.script_path
+            if state.running:
+                state.detail = "starts at logon from your Startup folder"
+        return state
+
+    def _script(self) -> str:
+        command = " ".join(_cmd_quote(a) for a in self.argv)
+        env = "".join(f'set "{k}={v}"\n' for k, v in service_environment(self.cfg).items())
+        # `start ""` detaches, so the cmd window this script runs in closes at
+        # once instead of waiting on a watcher that never exits.
+        return f'@echo off\r\n{env}start "" {command}\r\n'
+
+
+# ---------------------------------------------------------------- factory
+def manager_chain(cfg: Config, config_path: Path | None = None) -> list[Manager]:
+    """Every manager this machine might use, best first.
+
+    A chain rather than a single choice because the first one can refuse at the
+    moment of use, not at the moment of selection: a Windows account without the
+    right to register a scheduled task only finds out when schtasks says "Access
+    is denied". Whatever the platform, the last entry always works, so `lw start`
+    ends with a watcher running.
     """
     if sys.platform == "darwin" and shutil.which("launchctl"):
-        return LaunchdManager(cfg, config_path)
+        return [LaunchdManager(cfg, config_path)]
     if sys.platform.startswith("win"):
-        return SchtasksManager(cfg, config_path)
+        return [SchtasksManager(cfg, config_path), StartupFolderManager(cfg, config_path)]
+    chain: list[Manager] = []
     if sys.platform.startswith(("linux", "freebsd")) and SystemdManager.available():
-        return SystemdManager(cfg, config_path)
-    return PidfileManager(cfg, config_path)
+        chain.append(SystemdManager(cfg, config_path))
+    chain.append(PidfileManager(cfg, config_path))
+    return chain
+
+
+def get_manager(cfg: Config, config_path: Path | None = None) -> Manager:
+    """The manager this machine would prefer to use."""
+    return manager_chain(cfg, config_path)[0]
+
+
+def install_service(cfg: Config, config_path: Path | None = None) -> ServiceStatus:
+    """Install the best background watcher this machine will actually accept.
+
+    Falls through the chain rather than reporting the first refusal, because a
+    refusal is usually about privileges rather than about the machine being
+    unable: the returned status names which manager took it, so the caller can
+    say what the user ended up with.
+    """
+    refusals: list[str] = []
+    for manager in manager_chain(cfg, config_path):
+        try:
+            return manager.install()
+        except ServiceError as exc:
+            LOG.debug("%s refused: %s", manager.name, exc)
+            refusals.append(f"{manager.name}: {exc}")
+    raise ServiceError("; ".join(refusals) or "no service manager available")
+
+
+def stop_service(cfg: Config, config_path: Path | None = None, remove: bool = False) -> None:
+    """Stop whichever manager is actually holding the watcher.
+
+    The one that installed it is not necessarily the one this machine would pick
+    today — a scheduled task registered before the account lost that right, say
+    — so every candidate is asked.
+    """
+    for manager in manager_chain(cfg, config_path):
+        try:
+            if not manager.status().installed:
+                continue
+            manager.uninstall() if remove else manager.stop()
+        except ServiceError as exc:
+            LOG.debug("%s could not be stopped: %s", manager.name, exc)
 
 
 def current_status(cfg: Config, config_path: Path | None = None) -> ServiceStatus:
@@ -507,9 +632,13 @@ def current_status(cfg: Config, config_path: Path | None = None) -> ServiceStatu
     machine without a user bus, say), so every manager that could plausibly know
     something gets asked before we report "not installed".
     """
-    manager = get_manager(cfg, config_path)
-    candidates: list[Manager] = [manager]
-    if isinstance(manager, PidfileManager) and sys.platform.startswith("linux"):
+    chain = manager_chain(cfg, config_path)
+    manager = chain[0]
+    candidates = list(chain)
+    if sys.platform.startswith("linux") and not any(
+        isinstance(c, SystemdManager) for c in candidates
+    ):
+        # A unit written while a user session existed outlives the session.
         candidates.append(SystemdManager(cfg, config_path))
     for candidate in candidates:
         try:
@@ -543,6 +672,11 @@ def _sh_quote(value: str) -> str:
     return f'"{escaped}"'
 
 
+def _cmd_quote(value: str) -> str:
+    """Quote one argument inside a .cmd script — plain quotes, unlike /TR."""
+    return f'"{value}"' if " " in value else value
+
+
 def _win_quote(value: str) -> str:
     """Quote one argument inside a schtasks /TR command string.
 

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/src/lambda_watcher.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-watcher
-Version: 0.1.0
+Version: 0.1.1
 Summary: Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions.
 Author: Lambda Watcher contributors
 License: Apache-2.0
@@ -45,7 +45,7 @@ to how you work. You keep downloading zips; it does the rest.
 
 ```
 $ lambda-watcher watch
-lambda-watcher 0.1.0 — archiving into ~/.lambda-watcher
+lambda-watcher 0.1.1 — archiving into ~/.lambda-watcher
 watching ~/Downloads. Press Ctrl-C to stop.
                new  order-processor v0001  order-processor.zip — archived a new version
                new  order-processor v0002  order-processor (1).zip — 2 added, 2 modified, 3 renamed, 52 vendored

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/tests/test_cli.py

@@ -98,6 +98,45 @@ def test_status_names_the_archive_and_what_to_do_with_it(archived: Path):
     assert 'lw diff "order-processor"' in output
 
 
+def test_setup_survives_a_machine_that_will_not_take_a_service(
+    home: Path, downloads: Path, tmp_path: Path, monkeypatch
+):
+    """Everything else setup did still stands; a refused service is not fatal."""
+    from lambda_watcher import service
+
+    def refuse(*_a, **_k):
+        raise service.ServiceError("ERROR: Access is denied.")
+
+    monkeypatch.setattr(cli, "install_service", refuse)
+    config = _config_watching(tmp_path / "config.yaml", downloads)
+    result = runner.invoke(app, ["--config", str(config), "setup"])
+    assert result.exit_code == 0, "the archive was set up; only the service was refused"
+    assert config.exists()
+    assert "could not install a background watcher" in result.output
+    assert "lw watch" in result.output, "it has to name the way forward"
+
+
+def test_start_still_fails_loudly_when_no_service_can_be_installed(home: Path, monkeypatch):
+    """`setup` shrugs it off, but `start` has one job."""
+    from lambda_watcher import service
+
+    def refuse(*_a, **_k):
+        raise service.ServiceError("nothing doing")
+
+    monkeypatch.setattr(cli, "install_service", refuse)
+    assert runner.invoke(app, ["start"]).exit_code == 1
+
+
+def test_paths_are_shortened_with_the_platforms_own_separator(monkeypatch, tmp_path: Path):
+    """`~/` pasted onto a Windows relative path produced `~/.lambda-watcher\\config.yaml`."""
+    monkeypatch.setattr(Path, "home", classmethod(lambda _cls: tmp_path))
+    import os
+
+    assert cli._home_relative(tmp_path / "a" / "b") == f"~{os.sep}a{os.sep}b"
+    outside = Path("/somewhere/else") if os.sep == "/" else Path("D:/elsewhere")
+    assert cli._home_relative(outside) == str(outside)
+
+
 def test_setup_writes_a_config_and_reports_the_watch_folder(
     home: Path, downloads: Path, tmp_path: Path
 ):

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/tests/test_docs.py

@@ -45,6 +45,11 @@ _VARIABLE = [
     # `doctor` reports the machine's free space, which is not a property of the
     # tool at all: the page quotes whatever the run that produced it saw.
     (re.compile(r"^(disk free)\s+\S+\s+.*$"), r"\1 <this machine>"),
+    # The banner carries the version, which moves with every release while the
+    # captures around it do not. Pinning it here would make a version bump a
+    # documentation edit, and the captures are demonstrating the watcher's
+    # output rather than which release printed it.
+    (re.compile(r"^lambda-watcher \d+\.\d+\.\d+\S*(?= — archiving into)"), "lambda-watcher <version>"),
 ]
 
 

{lambda_watcher-0.1.0 → lambda_watcher-0.1.1}/tests/test_service.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import plistlib
+import subprocess
 import sys
 import time
 from pathlib import Path
@@ -12,12 +13,17 @@ import pytest
 from lambda_watcher import service
 from lambda_watcher.config import Config
 from lambda_watcher.service import (
+    ServiceError,
+    ServiceStatus,
     LaunchdManager,
     PidfileManager,
     SchtasksManager,
+    StartupFolderManager,
     SystemdManager,
     current_status,
     get_manager,
+    install_service,
+    manager_chain,
     service_environment,
     watch_argv,
 )
@@ -59,14 +65,14 @@ def test_the_launch_agent_is_a_readable_plist(cfg: Config):
 
 
 def test_the_launch_agent_escapes_a_path_that_needs_it(cfg: Config, monkeypatch):
-    monkeypatch.setattr(service, "watch_argv", lambda _p=None: ["/Apps/A & B/lw", "watch"])
+    monkeypatch.setattr(service, "watch_argv", lambda *_a, **_k: ["/Apps/A & B/lw", "watch"])
     parsed = plistlib.loads(LaunchdManager(cfg)._plist(Path("/tmp/x.log")).encode("utf-8"))
     assert parsed["ProgramArguments"][0] == "/Apps/A & B/lw"
 
 
 def test_the_systemd_unit_quotes_an_executable_with_a_space(cfg: Config, monkeypatch):
     """systemd unquotes ExecStart itself, so a space has to be inside quotes."""
-    monkeypatch.setattr(service, "watch_argv", lambda _p=None: ["/opt/my tools/lw", "watch"])
+    monkeypatch.setattr(service, "watch_argv", lambda *_a, **_k: ["/opt/my tools/lw", "watch"])
     unit = SystemdManager(cfg)._unit()
     assert 'ExecStart="/opt/my tools/lw" watch' in unit
     assert "WantedBy=default.target" in unit
@@ -95,13 +101,79 @@ def test_linux_without_a_systemd_user_session_still_gets_a_watcher(cfg: Config,
     assert isinstance(get_manager(cfg), PidfileManager)
 
 
+def test_windows_gets_a_fallback_when_the_task_scheduler_refuses(cfg: Config, monkeypatch):
+    """An ordinary account may not register a scheduled task; it still gets a watcher."""
+    monkeypatch.setattr(sys, "platform", "win32")
+    chain = [m.name for m in manager_chain(cfg)]
+    assert chain == ["schtasks", "startup-folder"]
+
+
+def test_the_scheduled_task_is_scoped_to_this_user(cfg: Config, monkeypatch):
+    """ONLOGON with no /RU fires for *any* user, which needs elevation to register."""
+    monkeypatch.setattr(sys, "platform", "win32")
+    monkeypatch.setattr(service.getpass, "getuser", lambda: "someone")
+    calls = _fake_run(monkeypatch)
+    SchtasksManager(cfg).install()
+    create = next(c for c in calls if "/Create" in c)
+    assert create[create.index("/RU") + 1] == "someone"
+
+
+def test_a_refused_manager_falls_through_to_one_that_works(cfg: Config, monkeypatch):
+    monkeypatch.setattr(
+        SchtasksManager, "install",
+        lambda _self: (_ for _ in ()).throw(ServiceError("ERROR: Access is denied.")),
+    )
+    monkeypatch.setattr(
+        StartupFolderManager, "install",
+        lambda self: ServiceStatus(self.name, installed=True, running=True),
+    )
+    monkeypatch.setattr(sys, "platform", "win32")
+    assert install_service(cfg).manager == "startup-folder"
+
+
+def test_when_everything_refuses_the_reasons_are_all_reported(cfg: Config, monkeypatch):
+    monkeypatch.setattr(sys, "platform", "win32")
+    for manager in (SchtasksManager, StartupFolderManager):
+        monkeypatch.setattr(
+            manager, "install",
+            lambda _self, name=manager.name: (_ for _ in ()).throw(ServiceError(f"{name} said no")),
+        )
+    with pytest.raises(ServiceError) as caught:
+        install_service(cfg)
+    assert "schtasks said no" in str(caught.value)
+    assert "startup-folder said no" in str(caught.value)
+
+
+def test_the_startup_launcher_detaches_and_shows_no_console(cfg: Config, monkeypatch):
+    monkeypatch.setattr(sys, "platform", "win32")
+    monkeypatch.setenv("APPDATA", "C:\\Users\\someone\\AppData\\Roaming")
+    manager = StartupFolderManager(cfg)
+    assert manager.script_path.name == "lambda-watcher.cmd"
+    assert manager.script_path.parent.name == "Startup"
+
+    script = manager._script()
+    assert script.startswith("@echo off")
+    # `start ""` lets the launching cmd window close instead of waiting forever.
+    assert 'start ""' in script
+    # -m, not the console script: only the interpreter has a windowless build.
+    assert "-m lambda_watcher" in script
+    assert script.endswith("\r\n"), "a .cmd file wants CRLF"
+
+
+def test_the_windowless_command_avoids_the_console_script():
+    plain = watch_argv()
+    quiet = watch_argv(windowless=True)
+    assert plain[-1] == quiet[-1] == "watch"
+    assert quiet[1:3] == ["-m", "lambda_watcher"]
+
+
 # ------------------------------------------------------------------ lifecycle
 @pytest.fixture
 def idle_watcher(monkeypatch):
     """Stand in for `lw watch` with a process that just sits there."""
     monkeypatch.setattr(
         service, "watch_argv",
-        lambda _p=None: [sys.executable, "-c", "import time; time.sleep(30)"],
+        lambda *_a, **_k: [sys.executable, "-c", "import time; time.sleep(30)"],
     )
 
 
@@ -135,11 +207,29 @@ def test_starting_twice_does_not_start_a_second_watcher(cfg: Config, idle_watche
         manager.uninstall()
 
 
-def test_liveness_never_signals_a_windows_process(cfg: Config, monkeypatch):
-    """`os.kill(pid, 0)` is TerminateProcess on Windows, not a probe."""
+def _fake_run(monkeypatch, stdout: str = "", returncode: int = 0) -> list[list[str]]:
+    """Record what would have been run, and answer with canned output."""
+    calls: list[list[str]] = []
+
+    def run(argv, check=False):
+        calls.append(argv)
+        return subprocess.CompletedProcess(argv, returncode, stdout=stdout, stderr="")
+
+    monkeypatch.setattr(service, "_run", run)
+    return calls
+
+
+@pytest.mark.parametrize(
+    ("listing", "alive"),
+    [('"python.exe","4","Console","1","9,000 K"\n', True), ("INFO: No tasks are running.\n", False)],
+)
+def test_windows_liveness_asks_tasklist_instead_of_signalling(monkeypatch, listing, alive):
+    """`os.kill(pid, 0)` is TerminateProcess on Windows — asking would end it."""
     monkeypatch.setattr(sys, "platform", "win32")
     monkeypatch.setattr(service.os, "kill", lambda *_a: pytest.fail("signalled a live process"))
-    assert service._pid_alive(4) is False
+    calls = _fake_run(monkeypatch, stdout=listing)
+    assert service._pid_alive(4) is alive
+    assert calls[0][0] == "tasklist"
 
 
 def test_a_stale_pidfile_reads_as_not_running(cfg: Config):