swarph-cli 0.7.2__tar.gz → 0.7.4__tar.gz

{swarph_cli-0.7.2/src/swarph_cli.egg-info → swarph_cli-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.7.2
+Version: 0.7.4
 Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.7.0 ships Phase 7 substrate-doc R7 §11.1.7 operator-tooling layer in 5 increments: PR-A `--new-instance` flag (sibling-spawn case) + PR-B auto-suffix on collision (sibling-slot persistence) + PR-C SessionStart hook (closes bare-claude operator-paste gap) + watchdog (stranded-session recovery) + PR-D swarph-shared cell.yaml relocation (cell-yaml schema graduates to swarph-shared 0.3.0 kernel-tier; substrate-doc R7 §11.1.5 (O5) RESOLVED).
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -138,6 +138,46 @@ Loud-on-down (PLAN §16.5): never silently exits. Cursor writes are atomic (writ
 
 `--auto-act` flag is documented for v0.5.1+ when handler registration via `@swarph.on_dm(...)` lands; v0.5.0 ships surface-only mode (DMs printed + JSONL-logged to `inbox.log`, no automatic replies).
 
+### `swarph watchdog` (Phase 7 — v0.7 stranded-session detection, v0.7.3 systemd install)
+
+Detects stranded Claude sessions (API throttle / harness death) via cursor-mtime + tmux pgrep AND-gate, and recovers via A1 tmux send-keys wake-prompt → A2 `swarph spawn` respawn. Cell.yaml-pinned cursor + tmux session (F4) since v0.7.2.
+
+**One-shot mode (cron-callable, v0.7+):**
+```bash
+*/5 * * * * swarph watchdog --check --cell lab >> ~/.local/log/swarph-watchdog.log 2>&1
+```
+
+**Systemd timer install (v0.7.3+ — closes ev_6954f748 substrate-component-installation-gap):**
+
+```bash
+# Preview without writing (any user):
+swarph watchdog --install-service --cell droplet --dry-run
+
+# Install + enable (requires root for /etc/systemd/system writes):
+sudo swarph watchdog --install-service --cell droplet
+```
+
+This writes three files:
+
+| Path | Purpose |
+|------|---------|
+| `/etc/systemd/system/swarph-watchdog.service` | `Type=oneshot`, runs `swarph watchdog --check` |
+| `/etc/systemd/system/swarph-watchdog.timer` | Fires every 5 minutes (`OnUnitActiveSec=5min`) |
+| `/etc/default/swarph-watchdog` | Sets `SWARPH_CELL=<role>` for the service env |
+
+Then runs `systemctl daemon-reload && systemctl enable --now swarph-watchdog.timer`. Idempotent — re-running overwrites with current package version (newer-version semantics).
+
+Monitoring:
+
+```bash
+systemctl status swarph-watchdog.timer       # is it scheduled?
+systemctl list-timers swarph-watchdog.timer  # next fire?
+journalctl -u swarph-watchdog.service -f     # live log
+tail -f /var/log/swarph-watchdog.log         # append-log alternative
+```
+
+Why this matters: pre-v0.7.3, swarph-cli shipped the watchdog code but no install path. Lab ran it via cron (manual setup); droplet never installed it at all. A real production silence-window (drop's ~24min mute 2026-05-14 08:38→09:02 UTC after an Anthropic API error) made the install-gap visible. v0.7.3 closes it for any peer with one command.
+
 ### `swarph onboard` + `swarph ratify` (Phase 5.5)
 
 Per PLAN.md §15, onboarding splits into a **mechanics phase** (`swarph onboard`) that automates the boring parts (registry POST, scaffolding, token resolution) and a **manual contract phase** (the new peer composes the handshake DM in their own words). A witness peer judges the handshake and runs `swarph ratify <peer>` to flip `ratified=true`, gating `task_claim` server-side.

{swarph_cli-0.7.2 → swarph_cli-0.7.4}/README.md

@@ -105,6 +105,46 @@ Loud-on-down (PLAN §16.5): never silently exits. Cursor writes are atomic (writ
 
 `--auto-act` flag is documented for v0.5.1+ when handler registration via `@swarph.on_dm(...)` lands; v0.5.0 ships surface-only mode (DMs printed + JSONL-logged to `inbox.log`, no automatic replies).
 
+### `swarph watchdog` (Phase 7 — v0.7 stranded-session detection, v0.7.3 systemd install)
+
+Detects stranded Claude sessions (API throttle / harness death) via cursor-mtime + tmux pgrep AND-gate, and recovers via A1 tmux send-keys wake-prompt → A2 `swarph spawn` respawn. Cell.yaml-pinned cursor + tmux session (F4) since v0.7.2.
+
+**One-shot mode (cron-callable, v0.7+):**
+```bash
+*/5 * * * * swarph watchdog --check --cell lab >> ~/.local/log/swarph-watchdog.log 2>&1
+```
+
+**Systemd timer install (v0.7.3+ — closes ev_6954f748 substrate-component-installation-gap):**
+
+```bash
+# Preview without writing (any user):
+swarph watchdog --install-service --cell droplet --dry-run
+
+# Install + enable (requires root for /etc/systemd/system writes):
+sudo swarph watchdog --install-service --cell droplet
+```
+
+This writes three files:
+
+| Path | Purpose |
+|------|---------|
+| `/etc/systemd/system/swarph-watchdog.service` | `Type=oneshot`, runs `swarph watchdog --check` |
+| `/etc/systemd/system/swarph-watchdog.timer` | Fires every 5 minutes (`OnUnitActiveSec=5min`) |
+| `/etc/default/swarph-watchdog` | Sets `SWARPH_CELL=<role>` for the service env |
+
+Then runs `systemctl daemon-reload && systemctl enable --now swarph-watchdog.timer`. Idempotent — re-running overwrites with current package version (newer-version semantics).
+
+Monitoring:
+
+```bash
+systemctl status swarph-watchdog.timer       # is it scheduled?
+systemctl list-timers swarph-watchdog.timer  # next fire?
+journalctl -u swarph-watchdog.service -f     # live log
+tail -f /var/log/swarph-watchdog.log         # append-log alternative
+```
+
+Why this matters: pre-v0.7.3, swarph-cli shipped the watchdog code but no install path. Lab ran it via cron (manual setup); droplet never installed it at all. A real production silence-window (drop's ~24min mute 2026-05-14 08:38→09:02 UTC after an Anthropic API error) made the install-gap visible. v0.7.3 closes it for any peer with one command.
+
 ### `swarph onboard` + `swarph ratify` (Phase 5.5)
 
 Per PLAN.md §15, onboarding splits into a **mechanics phase** (`swarph onboard`) that automates the boring parts (registry POST, scaffolding, token resolution) and a **manual contract phase** (the new peer composes the handshake DM in their own words). A witness peer judges the handshake and runs `swarph ratify <peer>` to flip `ratified=true`, gating `task_claim` server-side.

{swarph_cli-0.7.2 → swarph_cli-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.7.2"
+version = "0.7.4"
 description = "The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.7.0 ships Phase 7 substrate-doc R7 §11.1.7 operator-tooling layer in 5 increments: PR-A `--new-instance` flag (sibling-spawn case) + PR-B auto-suffix on collision (sibling-slot persistence) + PR-C SessionStart hook (closes bare-claude operator-paste gap) + watchdog (stranded-session recovery) + PR-D swarph-shared cell.yaml relocation (cell-yaml schema graduates to swarph-shared 0.3.0 kernel-tier; substrate-doc R7 §11.1.5 (O5) RESOLVED)."
 readme = "README.md"
 license = { text = "MIT" }
@@ -59,6 +59,12 @@ swarph = "swarph_cli.main:main"
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+# v0.7.3: ship bundled systemd unit + timer + default templates so
+# `swarph watchdog --install-service` can read them via importlib.resources.
+# Closes ev_6954f748 substrate-component-installation-gap.
+swarph_cli = ["systemd/*.service", "systemd/*.timer", "systemd/*.default"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-v --tb=short"

{swarph_cli-0.7.2 → swarph_cli-0.7.4}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.7.2"
+__version__ = "0.7.4"
 
 __all__ = ["__version__"]

{swarph_cli-0.7.2 → swarph_cli-0.7.4}/src/swarph_cli/commands/watchdog.py

@@ -66,6 +66,7 @@ import argparse
 import json
 import os
 import shlex
+import shutil
 import subprocess
 import sys
 import time
@@ -91,6 +92,7 @@ Usage:
                           [--gateway URL] [--tmux-session NAME]
                           [--peer NAME] [--no-respawn]
                           [--log PATH] [--verbose]
+  swarph watchdog --install-service [--cell ROLE] [--dry-run]
 
 Detects stranded Claude sessions (API throttle / harness death) and attempts
 recovery via tmux send-keys A1 wake-prompt, escalating to swarph spawn
@@ -99,6 +101,12 @@ respawn (A2) on persistent darkness.
 Designed for cron invocation:
   */5 * * * * swarph watchdog --check --cell lab >> ~/.local/log/swarph-watchdog.log 2>&1
 
+OR systemd timer (v0.7.3+, closes ev_6954f748 substrate-component-installation-gap):
+  sudo swarph watchdog --install-service [--cell <role>]
+  # → installs /etc/systemd/system/swarph-watchdog.{service,timer}
+  # → installs /etc/default/swarph-watchdog with SWARPH_CELL=<role>
+  # → daemon-reload + enable --now swarph-watchdog.timer
+
 Detection (mother #1021 AND-gate design):
   PRIMARY:  cursor file mtime — most-recent Claude action (drain script touches it)
   FALLBACK: pgrep claude on tmux session — confirms process aliveness
@@ -123,11 +131,12 @@ Flags:
   --verbose            also write diagnostics to stderr
 
 Exit codes:
-  0  no action taken (session healthy or no unread DMs queued)
+  0  no action taken (session healthy or no unread DMs queued); install ok
   1  A1 fired (wake-prompt sent)
   2  A2 fired (full respawn triggered)
   3  detection error (cursor unreadable / gateway unreachable)
-  4  configuration error (invalid args, no cell.yaml resolved)
+  4  configuration error (invalid args, no cell.yaml resolved); install needs sudo
+  5  install error (file write failed / systemctl failed)
 """
 
 
@@ -610,6 +619,148 @@ def run_check(args: argparse.Namespace) -> int:
     return 1 if sent else 4
 
 
+_SYSTEMD_UNIT_DIR = Path("/etc/systemd/system")
+_SYSTEMD_DEFAULT_DIR = Path("/etc/default")
+_SYSTEMD_UNIT_NAMES = ("swarph-watchdog.service", "swarph-watchdog.timer")
+_SYSTEMD_DEFAULT_NAME = "swarph-watchdog"  # /etc/default/swarph-watchdog
+# v0.7.3 bundled template's ExecStart placeholder — substituted at install time
+# by `_resolve_swarph_bin()` to the actual binary path on the install host.
+# Fixes the v0.7.3 hardcode that broke pipx-installed peers (binary at
+# ~/.local/bin/swarph not /usr/local/bin/swarph).
+_SWARPH_BIN_PLACEHOLDER = "/usr/local/bin/swarph"
+
+
+def _resolve_swarph_bin() -> str:
+    """Resolve the absolute path of the running swarph binary.
+
+    Resolution order:
+      1. ``sys.argv[0]`` if it's an absolute path — most reliable, equals
+         the path the user invoked
+      2. ``shutil.which(sys.argv[0])`` — bare-name invocation, look up in PATH
+      3. ``shutil.which("swarph")`` — generic PATH lookup as fallback
+      4. ``/usr/local/bin/swarph`` — last-resort default (matches v0.7.3
+         hardcode behavior; no regression if all three above fail)
+
+    ALWAYS returns an absolute path — systemd ExecStart requires absolute.
+    Relative inputs (e.g. ``venv/bin/swarph`` from editable installs) get
+    abspath'd against cwd. Never raises.
+    """
+    invoked = sys.argv[0] or "swarph"
+    if Path(invoked).is_absolute():
+        return invoked
+    resolved = shutil.which(invoked) or shutil.which("swarph")
+    if not resolved:
+        return _SWARPH_BIN_PLACEHOLDER
+    return os.path.abspath(resolved)
+
+
+def _bundled_systemd_files() -> dict[str, str]:
+    """Return {filename: content} for the 3 bundled systemd templates.
+
+    Reads from the package's bundled `systemd/` data directory via
+    importlib.resources. Works regardless of install method (pipx, pip,
+    editable, wheel-from-PyPI).
+    """
+    try:
+        from importlib.resources import files as _files
+    except ImportError:  # pragma: no cover — Python <3.9 not supported anyway
+        from importlib_resources import files as _files  # type: ignore[no-redef]
+
+    pkg_root = _files("swarph_cli") / "systemd"
+    out: dict[str, str] = {}
+    for name in (*_SYSTEMD_UNIT_NAMES, "swarph-watchdog.default"):
+        out[name] = (pkg_root / name).read_text(encoding="utf-8")
+    return out
+
+
+def run_install_service(args: argparse.Namespace) -> int:
+    """Install systemd timer + service for periodic watchdog --check.
+
+    Idempotent: overwrites existing unit files (newer-version semantics).
+    Requires sudo for /etc/systemd/system writes unless --dry-run.
+
+    Exit codes:
+      0  success (or dry-run completed)
+      4  configuration error (non-root without --dry-run)
+      5  install error (file write failed / systemctl failed)
+    """
+    files = _bundled_systemd_files()
+
+    # v0.7.4: substitute the bundled service template's ExecStart placeholder
+    # with the actual swarph binary path on this host. Fixes the v0.7.3 hardcode
+    # that broke pipx-installed peers (binary at ~/.local/bin/swarph not
+    # /usr/local/bin/swarph). Pipx is the recommended install path on droplet
+    # + lab, so the hardcode bit BOTH peers on first install attempt today.
+    swarph_bin = _resolve_swarph_bin()
+    service_content = files[_SYSTEMD_UNIT_NAMES[0]].replace(
+        f"ExecStart={_SWARPH_BIN_PLACEHOLDER}",
+        f"ExecStart={swarph_bin}",
+        1,
+    )
+
+    # Template the default file with the requested role
+    default_content = files["swarph-watchdog.default"].replace(
+        "SWARPH_CELL=lab",
+        f"SWARPH_CELL={args.cell}",
+        1,
+    )
+
+    targets = [
+        (_SYSTEMD_UNIT_DIR / _SYSTEMD_UNIT_NAMES[0], service_content),
+        (_SYSTEMD_UNIT_DIR / _SYSTEMD_UNIT_NAMES[1], files[_SYSTEMD_UNIT_NAMES[1]]),
+        (_SYSTEMD_DEFAULT_DIR / _SYSTEMD_DEFAULT_NAME, default_content),
+    ]
+
+    if args.dry_run:
+        print(f"# DRY RUN — cell={args.cell} swarph_bin={swarph_bin}", file=sys.stderr)
+        for path, content in targets:
+            print(f"\n# would write {path}:", file=sys.stderr)
+            print(content, file=sys.stderr)
+        print(
+            "\n# would then run:\n"
+            "#   sudo systemctl daemon-reload\n"
+            "#   sudo systemctl enable --now swarph-watchdog.timer",
+            file=sys.stderr,
+        )
+        return 0
+
+    if os.geteuid() != 0:
+        print(
+            "ERROR: --install-service requires root. Re-run with sudo, or use "
+            "--dry-run to preview the install without writing.",
+            file=sys.stderr,
+        )
+        return 4
+
+    try:
+        for path, content in targets:
+            path.write_text(content, encoding="utf-8")
+            print(f"wrote {path}", file=sys.stderr)
+    except (OSError, PermissionError) as exc:
+        print(f"ERROR: failed to write unit files: {exc}", file=sys.stderr)
+        return 5
+
+    try:
+        subprocess.run(["systemctl", "daemon-reload"], check=True)
+        subprocess.run(
+            ["systemctl", "enable", "--now", "swarph-watchdog.timer"],
+            check=True,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError) as exc:
+        print(f"ERROR: systemctl failed: {exc}", file=sys.stderr)
+        return 5
+
+    print(
+        f"\nswarph-watchdog.timer installed + enabled for cell={args.cell}.\n"
+        f"  status:  systemctl status swarph-watchdog.timer\n"
+        f"  logs:    journalctl -u swarph-watchdog.service -f\n"
+        f"           OR /var/log/swarph-watchdog.log\n"
+        f"  next:    systemctl list-timers swarph-watchdog.timer",
+        file=sys.stderr,
+    )
+    return 0
+
+
 def run_watchdog(argv: Optional[list[str]] = None) -> int:
     if argv is None:
         argv = sys.argv[2:]  # skip "swarph watchdog"
@@ -623,6 +774,16 @@ def run_watchdog(argv: Optional[list[str]] = None) -> int:
         "--check", action="store_true",
         help="One-shot check (cron-callable; exits with status code).",
     )
+    p.add_argument(
+        "--install-service", action="store_true",
+        help="Install systemd timer + service for periodic --check invocation. "
+             "Requires sudo. Closes ev_6954f748 substrate-component-install gap.",
+    )
+    p.add_argument(
+        "--dry-run", action="store_true",
+        help="With --install-service: show what would be written without "
+             "writing. Useful for review or non-root preview.",
+    )
     p.add_argument("--cell", default=os.environ.get("SWARPH_CELL", "lab"))
     p.add_argument("--cursor", default=None)
     p.add_argument("--threshold", type=int, default=_DEFAULT_THRESHOLD_SEC)
@@ -646,6 +807,9 @@ def run_watchdog(argv: Optional[list[str]] = None) -> int:
     except SystemExit as exc:
         return int(exc.code or 0)
 
+    if args.install_service:
+        return run_install_service(args)
+
     if not args.check:
         print(_USAGE, file=sys.stderr)
         return 4

swarph_cli-0.7.4/src/swarph_cli/systemd/swarph-watchdog.default

@@ -0,0 +1,9 @@
+# /etc/default/swarph-watchdog — environment for swarph-watchdog.service
+#
+# SWARPH_CELL sets the cell role for the watchdog. The watchdog reads
+# cell.yaml for this role to discover the cursor path + tmux session pin
+# (per F4 cell.yaml-pinning landed in v0.7.2).
+#
+# If unset, watchdog defaults to "lab" (per the --cell argparse default).
+# Override here per-vertex: droplet, gpu-wsl, razorpeter, etc.
+SWARPH_CELL=lab

swarph_cli-0.7.4/src/swarph_cli/systemd/swarph-watchdog.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=Swarph watchdog one-shot check (stranded-session recovery)
+Documentation=https://github.com/darw007d/swarph-cli
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+EnvironmentFile=-/etc/default/swarph-watchdog
+ExecStart=/usr/local/bin/swarph watchdog --check
+StandardOutput=append:/var/log/swarph-watchdog.log
+StandardError=append:/var/log/swarph-watchdog.log
+
+[Install]
+WantedBy=multi-user.target

swarph_cli-0.7.4/src/swarph_cli/systemd/swarph-watchdog.timer

@@ -0,0 +1,13 @@
+[Unit]
+Description=Run swarph watchdog every 5 minutes (stranded-session recovery)
+Documentation=https://github.com/darw007d/swarph-cli
+Requires=swarph-watchdog.service
+
+[Timer]
+OnBootSec=2min
+OnUnitActiveSec=5min
+AccuracySec=1min
+Persistent=true
+
+[Install]
+WantedBy=timers.target

{swarph_cli-0.7.2 → swarph_cli-0.7.4/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.7.2
+Version: 0.7.4
 Summary: The `swarph` binary — multi-LLM CLI with mesh-gateway integration. v0.7.0 ships Phase 7 substrate-doc R7 §11.1.7 operator-tooling layer in 5 increments: PR-A `--new-instance` flag (sibling-spawn case) + PR-B auto-suffix on collision (sibling-slot persistence) + PR-C SessionStart hook (closes bare-claude operator-paste gap) + watchdog (stranded-session recovery) + PR-D swarph-shared cell.yaml relocation (cell-yaml schema graduates to swarph-shared 0.3.0 kernel-tier; substrate-doc R7 §11.1.5 (O5) RESOLVED).
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -138,6 +138,46 @@ Loud-on-down (PLAN §16.5): never silently exits. Cursor writes are atomic (writ
 
 `--auto-act` flag is documented for v0.5.1+ when handler registration via `@swarph.on_dm(...)` lands; v0.5.0 ships surface-only mode (DMs printed + JSONL-logged to `inbox.log`, no automatic replies).
 
+### `swarph watchdog` (Phase 7 — v0.7 stranded-session detection, v0.7.3 systemd install)
+
+Detects stranded Claude sessions (API throttle / harness death) via cursor-mtime + tmux pgrep AND-gate, and recovers via A1 tmux send-keys wake-prompt → A2 `swarph spawn` respawn. Cell.yaml-pinned cursor + tmux session (F4) since v0.7.2.
+
+**One-shot mode (cron-callable, v0.7+):**
+```bash
+*/5 * * * * swarph watchdog --check --cell lab >> ~/.local/log/swarph-watchdog.log 2>&1
+```
+
+**Systemd timer install (v0.7.3+ — closes ev_6954f748 substrate-component-installation-gap):**
+
+```bash
+# Preview without writing (any user):
+swarph watchdog --install-service --cell droplet --dry-run
+
+# Install + enable (requires root for /etc/systemd/system writes):
+sudo swarph watchdog --install-service --cell droplet
+```
+
+This writes three files:
+
+| Path | Purpose |
+|------|---------|
+| `/etc/systemd/system/swarph-watchdog.service` | `Type=oneshot`, runs `swarph watchdog --check` |
+| `/etc/systemd/system/swarph-watchdog.timer` | Fires every 5 minutes (`OnUnitActiveSec=5min`) |
+| `/etc/default/swarph-watchdog` | Sets `SWARPH_CELL=<role>` for the service env |
+
+Then runs `systemctl daemon-reload && systemctl enable --now swarph-watchdog.timer`. Idempotent — re-running overwrites with current package version (newer-version semantics).
+
+Monitoring:
+
+```bash
+systemctl status swarph-watchdog.timer       # is it scheduled?
+systemctl list-timers swarph-watchdog.timer  # next fire?
+journalctl -u swarph-watchdog.service -f     # live log
+tail -f /var/log/swarph-watchdog.log         # append-log alternative
+```
+
+Why this matters: pre-v0.7.3, swarph-cli shipped the watchdog code but no install path. Lab ran it via cron (manual setup); droplet never installed it at all. A real production silence-window (drop's ~24min mute 2026-05-14 08:38→09:02 UTC after an Anthropic API error) made the install-gap visible. v0.7.3 closes it for any peer with one command.
+
 ### `swarph onboard` + `swarph ratify` (Phase 5.5)
 
 Per PLAN.md §15, onboarding splits into a **mechanics phase** (`swarph onboard`) that automates the boring parts (registry POST, scaffolding, token resolution) and a **manual contract phase** (the new peer composes the handshake DM in their own words). A witness peer judges the handshake and runs `swarph ratify <peer>` to flip `ratified=true`, gating `task_claim` server-side.

{swarph_cli-0.7.2 → swarph_cli-0.7.4}/src/swarph_cli.egg-info/SOURCES.txt

@@ -23,6 +23,9 @@ src/swarph_cli/commands/spawn.py
 src/swarph_cli/commands/watchdog.py
 src/swarph_cli/parsers/__init__.py
 src/swarph_cli/parsers/claude.py
+src/swarph_cli/systemd/swarph-watchdog.default
+src/swarph_cli/systemd/swarph-watchdog.service
+src/swarph_cli/systemd/swarph-watchdog.timer
 tests/test_cell_loader.py
 tests/test_chat_command.py
 tests/test_claude_parser.py

{swarph_cli-0.7.2 → swarph_cli-0.7.4}/tests/test_watchdog.py

@@ -562,3 +562,153 @@ def test_watchdog_log_appends_across_invocations(isolated_state, monkeypatch):
     parsed_second = json.loads(lines[1])
     assert parsed_first["details"]["decision"] == "healthy_cursor_fresh"
     assert parsed_second["details"]["decision"] == "noop_no_unread"
+
+
+# ---------------------------------------------------------------------------
+# --install-service (v0.7.3 — closes ev_6954f748 substrate-component-install)
+# ---------------------------------------------------------------------------
+
+
+def test_install_service_dry_run_writes_no_files(isolated_state, capsys):
+    """--dry-run prints what would be written without touching the filesystem."""
+    rc = run_watchdog(argv=["--install-service", "--cell", "droplet", "--dry-run"])
+    assert rc == 0
+    captured = capsys.readouterr()
+    # Dry-run output goes to stderr
+    assert "DRY RUN" in captured.err
+    assert "cell=droplet" in captured.err
+    # All three target files surface in the preview
+    assert "/etc/systemd/system/swarph-watchdog.service" in captured.err
+    assert "/etc/systemd/system/swarph-watchdog.timer" in captured.err
+    assert "/etc/default/swarph-watchdog" in captured.err
+    # SWARPH_CELL was templated to the requested role
+    assert "SWARPH_CELL=droplet" in captured.err
+    # The bundled service file's identifying line shows up
+    assert "Swarph watchdog one-shot check" in captured.err
+
+
+def test_install_service_dry_run_default_cell_is_lab(isolated_state, capsys):
+    """Without --cell, the dry-run preview keeps SWARPH_CELL=lab default."""
+    rc = run_watchdog(argv=["--install-service", "--dry-run"])
+    assert rc == 0
+    captured = capsys.readouterr()
+    assert "SWARPH_CELL=lab" in captured.err
+
+
+def test_install_service_without_sudo_returns_4(isolated_state, capsys, monkeypatch):
+    """Non-root install (no --dry-run) refuses with helpful message + exit 4."""
+    monkeypatch.setattr("os.geteuid", lambda: 1000)
+    rc = run_watchdog(argv=["--install-service", "--cell", "droplet"])
+    assert rc == 4
+    captured = capsys.readouterr()
+    assert "requires root" in captured.err
+    assert "--dry-run" in captured.err  # hint surfaces
+
+
+def test_bundled_systemd_files_readable():
+    """Package-data manifest correctness — importlib.resources can read all
+    three bundled templates. Regression guard for pyproject package-data
+    declaration."""
+    from swarph_cli.commands.watchdog import _bundled_systemd_files
+
+    files = _bundled_systemd_files()
+    assert set(files.keys()) == {
+        "swarph-watchdog.service",
+        "swarph-watchdog.timer",
+        "swarph-watchdog.default",
+    }
+    # Service file has the expected Type=oneshot shape
+    assert "Type=oneshot" in files["swarph-watchdog.service"]
+    assert "ExecStart=/usr/local/bin/swarph watchdog --check" in files["swarph-watchdog.service"]
+    # Timer fires every 5 minutes
+    assert "OnUnitActiveSec=5min" in files["swarph-watchdog.timer"]
+    # Default file has the SWARPH_CELL=lab template line
+    assert "SWARPH_CELL=lab" in files["swarph-watchdog.default"]
+
+
+# ---------------------------------------------------------------------------
+# v0.7.4 — _resolve_swarph_bin + ExecStart templating
+# ---------------------------------------------------------------------------
+#
+# v0.7.3 shipped a hardcoded ExecStart=/usr/local/bin/swarph that broke
+# pipx-installed peers (lab + drop both hit this on first install attempt
+# 2026-05-14). v0.7.4 resolves the path at install time via _resolve_swarph_bin
+# and substitutes into the bundled service template.
+
+
+def test_resolve_swarph_bin_absolute_argv0_wins(monkeypatch):
+    """If sys.argv[0] is absolute, it's the most reliable signal — use it."""
+    from swarph_cli.commands.watchdog import _resolve_swarph_bin
+
+    monkeypatch.setattr("sys.argv", ["/home/ubuntu/.local/bin/swarph", "watchdog"])
+    assert _resolve_swarph_bin() == "/home/ubuntu/.local/bin/swarph"
+
+
+def test_resolve_swarph_bin_bare_name_resolved_via_path(monkeypatch, tmp_path):
+    """Bare-name argv[0] resolves via PATH."""
+    from swarph_cli.commands.watchdog import _resolve_swarph_bin
+
+    fake_bin = tmp_path / "swarph"
+    fake_bin.write_text("#!/bin/sh\nexit 0\n")
+    fake_bin.chmod(0o755)
+    monkeypatch.setattr("sys.argv", ["swarph", "watchdog"])
+    monkeypatch.setattr("shutil.which", lambda name: str(fake_bin) if name == "swarph" else None)
+    assert _resolve_swarph_bin() == str(fake_bin)
+
+
+def test_resolve_swarph_bin_falls_back_to_placeholder_if_unresolvable(monkeypatch):
+    """All resolution paths fail → fall back to /usr/local/bin/swarph
+    (v0.7.3 hardcode behavior; no regression vs prior version)."""
+    from swarph_cli.commands.watchdog import _resolve_swarph_bin, _SWARPH_BIN_PLACEHOLDER
+
+    monkeypatch.setattr("sys.argv", ["swarph", "watchdog"])
+    monkeypatch.setattr("shutil.which", lambda name: None)
+    assert _resolve_swarph_bin() == _SWARPH_BIN_PLACEHOLDER
+
+
+def test_install_service_dry_run_substitutes_swarph_bin(isolated_state, capsys, monkeypatch):
+    """Dry-run preview shows resolved swarph path in ExecStart, not hardcoded
+    /usr/local/bin/swarph (when the host actually has swarph elsewhere)."""
+    pipx_path = "/home/ubuntu/.local/bin/swarph"
+    monkeypatch.setattr("sys.argv", [pipx_path, "watchdog"])
+    rc = run_watchdog(argv=["--install-service", "--cell", "droplet", "--dry-run"])
+    assert rc == 0
+    captured = capsys.readouterr()
+    # Header surfaces the resolved binary
+    assert f"swarph_bin={pipx_path}" in captured.err
+    # Service file's ExecStart now points at pipx path, NOT the placeholder
+    assert f"ExecStart={pipx_path} watchdog --check" in captured.err
+    # And the v0.7.3-hardcoded path no longer appears in the preview
+    assert "ExecStart=/usr/local/bin/swarph watchdog --check" not in captured.err
+
+
+def test_install_service_dry_run_preserves_default_path_when_absolute(isolated_state, capsys, monkeypatch):
+    """When sys.argv[0] IS /usr/local/bin/swarph (the v0.7.3 default path),
+    the substitution still happens but produces the same line — no diff vs
+    v0.7.3 for this case."""
+    monkeypatch.setattr("sys.argv", ["/usr/local/bin/swarph", "watchdog"])
+    rc = run_watchdog(argv=["--install-service", "--cell", "lab", "--dry-run"])
+    assert rc == 0
+    captured = capsys.readouterr()
+    assert "ExecStart=/usr/local/bin/swarph watchdog --check" in captured.err
+
+
+def test_resolve_swarph_bin_relative_with_slash_resolves_to_absolute(tmp_path, monkeypatch):
+    """Relative path with slash (e.g. editable install's venv/bin/swarph)
+    must be absolutized — systemd ExecStart needs absolute. Regression guard
+    for the abspath fix on top of v0.7.4 path-autodetect."""
+    from swarph_cli.commands.watchdog import _resolve_swarph_bin
+
+    fake = tmp_path / "swarph"
+    fake.write_text("#!/bin/sh\nexit 0\n")
+    fake.chmod(0o755)
+    # Simulate `./swarph` from cwd=tmp_path
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr("sys.argv", ["./swarph", "watchdog"])
+    # shutil.which('./swarph') returns the relative path as-is when the
+    # input contains a slash. _resolve_swarph_bin must abspath it.
+    resolved = _resolve_swarph_bin()
+    assert Path(resolved).is_absolute(), (
+        f"resolver returned non-absolute path: {resolved!r}"
+    )
+    assert resolved == str(fake)