pushraker 0.1.0.dev0__tar.gz → 0.2.1__tar.gz

pushraker-0.2.1/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: pushraker
+Version: 0.2.1
+Summary: Push notifications for Klipper printers: a Moonraker component with pictures, sent through Apprise (ntfy, Pushover, Telegram, Discord, webhooks, email)
+Author: noon92
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/noon92/pushraker
+Project-URL: Issues, https://github.com/noon92/pushraker/issues
+Keywords: klipper,moonraker,notifications,ntfy,apprise,3d-printing
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: apprise>=1.9
+Requires-Dist: requests
+Requires-Dist: Pillow>=10
+Dynamic: license-file
+
+# pushraker
+
+Push notifications for Klipper printers, as a Moonraker component: print
+started, paused, resumed, complete, cancelled, progress, first layer, faults
+and shutdowns, power-loss recovery, chamber temperature, filament (Spoolman,
+backup spools, MMUs), with pictures (camera snapshot, model preview, spool
+drawings). Sent through [Apprise](https://github.com/caronc/apprise): ntfy,
+Pushover, Gotify, Telegram, Discord, a webhook, email. Configured from its
+own web page, live, with no Moonraker or Klipper restart.
+
+It grew out of the Push Notifications feature of the
+[Snapmaker U1 Extended Firmware](https://github.com/paxx12-snapmaker-u1/SnapmakerU1-Extended-Firmware),
+where it is built in; the user documentation lives there
+for now: [notifications](https://snapmakeru1-extended-firmware.pages.dev/notifications).
+
+**Status: 0.2.** The component has been in
+use on the Snapmaker U1 for a while; the page, the settings file and the
+installer are new. Other printers: the generic parts work (Klipper's
+standard objects: print_stats, exclude_object, heater_generic, tmc
+drivers, Moonraker's webcams and Spoolman); printer-specific parts are
+behind `printers/`, one module per printer; `snapmaker_u1.py` is the
+first. Notifications a printer can't produce (the U1's touchscreen
+calibrations, coded warnings, power-loss recovery, toolhead-map refills,
+MMU slots) start off on other printers and are left off the page; turn
+one on in `pushraker.conf` and it shows on the page and is sent like any
+other.
+
+## Install (any Moonraker printer)
+
+```sh
+pip install pushraker            # into the Python Moonraker runs with
+python -m pushraker install      # ~/moonraker and ~/printer_data by default
+```
+
+`install` puts a one-file shim into Moonraker's `components/` folder, adds
+`[pushraker]` to `moonraker.conf`, includes the Klipper macro
+file from `printer.cfg`, and creates `printer_data/config/pushraker.conf`.
+Restart Moonraker and Klipper. Then serve the settings page
+(`src/pushraker/web/index.html`, or `python -c "import pushraker, os;
+print(os.path.dirname(pushraker.__file__) + '/web')"`) from the same nginx
+that serves Fluidd or Mainsail, e.g.
+
+```nginx
+location /notifications/ {
+    alias /path/to/site-packages/pushraker/web/;
+    index index.html;
+}
+```
+
+and open `http://<printer>/notifications/`. The page talks to Moonraker
+through the `/server/` proxy of that nginx; without one it falls back to
+Moonraker's own port, which needs the page's origin in `cors_domains`
+under `[authorization]` in `moonraker.conf`. With Moonraker's
+authorization on, the page asks for an API key the first time.
+
+Call `_PRINT_END_NTFY` at the start of your `PRINT_END` macro and
+`_CANCEL_PRINT_NTFY` at the start of `CANCEL_PRINT` for the print-end and
+cancel snapshots to be taken before the printer parks (the Snapmaker U1
+extended firmware does that through its hook system).
+
+`python -m pushraker install --help` lists the paths and options (include
+directories, the printer's default name, the error-code index link, moving
+settings over from an INI section). `python -m pushraker uninstall` takes
+it out again; `--purge` also removes the settings and secrets.
+
+## Where things live on the printer
+
+- `printer_data/config/pushraker.conf`: the settings, a plain INI file
+  (also editable by hand; the component re-reads it when it changes).
+- `printer_data/pushraker.secrets`: tokens and passwords, mode 0600,
+  outside the config folder so Moonraker never serves it.
+- Moonraker endpoints: `GET/POST /server/pushraker/config`,
+  `POST /server/pushraker/test`, `GET /server/pushraker/status` (also
+  under `/server/push_notifications/`, the 0.1 names).
+
+## Layout
+
+- `src/pushraker/component.py` — the Moonraker component
+- `src/pushraker/settings.py` — the settings: validation, storage, the
+  Apprise URLs built from them
+- `src/pushraker/printers/` — what differs between printers (the harness
+  side of the package), one module per printer; `snapmaker_u1.py` is the
+  first
+- `src/pushraker/images.py` — spool pictures (Pillow)
+- `src/pushraker/email_html.py`, `src/pushraker/discord.py` — email card,
+  Discord senders
+- `src/pushraker/web/index.html` — the settings page
+- `src/pushraker/klipper/pushraker.cfg` — the Klipper macro file
+- `src/pushraker/__main__.py` — `python -m pushraker install|uninstall|status`
+- `tests/` — `python tests/test_pushraker.py` (the component against a
+  stand-in Moonraker; also runs `test_settings.py`)
+
+## License
+
+GPL-3.0-or-later.

pushraker-0.2.1/README.md

@@ -0,0 +1,95 @@
+# pushraker
+
+Push notifications for Klipper printers, as a Moonraker component: print
+started, paused, resumed, complete, cancelled, progress, first layer, faults
+and shutdowns, power-loss recovery, chamber temperature, filament (Spoolman,
+backup spools, MMUs), with pictures (camera snapshot, model preview, spool
+drawings). Sent through [Apprise](https://github.com/caronc/apprise): ntfy,
+Pushover, Gotify, Telegram, Discord, a webhook, email. Configured from its
+own web page, live, with no Moonraker or Klipper restart.
+
+It grew out of the Push Notifications feature of the
+[Snapmaker U1 Extended Firmware](https://github.com/paxx12-snapmaker-u1/SnapmakerU1-Extended-Firmware),
+where it is built in; the user documentation lives there
+for now: [notifications](https://snapmakeru1-extended-firmware.pages.dev/notifications).
+
+**Status: 0.2.** The component has been in
+use on the Snapmaker U1 for a while; the page, the settings file and the
+installer are new. Other printers: the generic parts work (Klipper's
+standard objects: print_stats, exclude_object, heater_generic, tmc
+drivers, Moonraker's webcams and Spoolman); printer-specific parts are
+behind `printers/`, one module per printer; `snapmaker_u1.py` is the
+first. Notifications a printer can't produce (the U1's touchscreen
+calibrations, coded warnings, power-loss recovery, toolhead-map refills,
+MMU slots) start off on other printers and are left off the page; turn
+one on in `pushraker.conf` and it shows on the page and is sent like any
+other.
+
+## Install (any Moonraker printer)
+
+```sh
+pip install pushraker            # into the Python Moonraker runs with
+python -m pushraker install      # ~/moonraker and ~/printer_data by default
+```
+
+`install` puts a one-file shim into Moonraker's `components/` folder, adds
+`[pushraker]` to `moonraker.conf`, includes the Klipper macro
+file from `printer.cfg`, and creates `printer_data/config/pushraker.conf`.
+Restart Moonraker and Klipper. Then serve the settings page
+(`src/pushraker/web/index.html`, or `python -c "import pushraker, os;
+print(os.path.dirname(pushraker.__file__) + '/web')"`) from the same nginx
+that serves Fluidd or Mainsail, e.g.
+
+```nginx
+location /notifications/ {
+    alias /path/to/site-packages/pushraker/web/;
+    index index.html;
+}
+```
+
+and open `http://<printer>/notifications/`. The page talks to Moonraker
+through the `/server/` proxy of that nginx; without one it falls back to
+Moonraker's own port, which needs the page's origin in `cors_domains`
+under `[authorization]` in `moonraker.conf`. With Moonraker's
+authorization on, the page asks for an API key the first time.
+
+Call `_PRINT_END_NTFY` at the start of your `PRINT_END` macro and
+`_CANCEL_PRINT_NTFY` at the start of `CANCEL_PRINT` for the print-end and
+cancel snapshots to be taken before the printer parks (the Snapmaker U1
+extended firmware does that through its hook system).
+
+`python -m pushraker install --help` lists the paths and options (include
+directories, the printer's default name, the error-code index link, moving
+settings over from an INI section). `python -m pushraker uninstall` takes
+it out again; `--purge` also removes the settings and secrets.
+
+## Where things live on the printer
+
+- `printer_data/config/pushraker.conf`: the settings, a plain INI file
+  (also editable by hand; the component re-reads it when it changes).
+- `printer_data/pushraker.secrets`: tokens and passwords, mode 0600,
+  outside the config folder so Moonraker never serves it.
+- Moonraker endpoints: `GET/POST /server/pushraker/config`,
+  `POST /server/pushraker/test`, `GET /server/pushraker/status` (also
+  under `/server/push_notifications/`, the 0.1 names).
+
+## Layout
+
+- `src/pushraker/component.py` — the Moonraker component
+- `src/pushraker/settings.py` — the settings: validation, storage, the
+  Apprise URLs built from them
+- `src/pushraker/printers/` — what differs between printers (the harness
+  side of the package), one module per printer; `snapmaker_u1.py` is the
+  first
+- `src/pushraker/images.py` — spool pictures (Pillow)
+- `src/pushraker/email_html.py`, `src/pushraker/discord.py` — email card,
+  Discord senders
+- `src/pushraker/web/index.html` — the settings page
+- `src/pushraker/klipper/pushraker.cfg` — the Klipper macro file
+- `src/pushraker/__main__.py` — `python -m pushraker install|uninstall|status`
+- `tests/` — `python tests/test_pushraker.py` (the component against a
+  stand-in Moonraker; also runs `test_settings.py`)
+
+## License
+
+GPL-3.0-or-later.

{pushraker-0.1.0.dev0 → pushraker-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pushraker"
-version = "0.1.0.dev0"
+version = "0.2.1"
 description = "Push notifications for Klipper printers: a Moonraker component with pictures, sent through Apprise (ntfy, Pushover, Telegram, Discord, webhooks, email)"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{pushraker-0.1.0.dev0 → pushraker-0.2.1}/src/pushraker/__init__.py

@@ -4,4 +4,4 @@
 
 """Push notifications for Klipper printers, as a Moonraker component."""
 
-__version__ = "0.1.0.dev0"
+__version__ = "0.2.1"

pushraker-0.2.1/src/pushraker/__main__.py

@@ -0,0 +1,354 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+# SPDX-PackageHomePage: https://github.com/noon92/pushraker
+# SPDX-FileCopyrightText: Copyright (c) 2026 @noon92
+
+"""python -m pushraker install|uninstall|status: wire the package into a
+Moonraker + Klipper installation.
+
+  install     put the component shim into Moonraker's components folder,
+              enable [pushraker] in Moonraker's config, include
+              the Klipper macro file, and (once) move settings over from
+              an INI section such as the Snapmaker U1 extended firmware's
+              extended2.cfg [notifications]
+  uninstall   take those out again (the settings and secrets stay unless
+              --purge)
+  status      say what is in place
+
+Paths default to a standard printer_data layout under the running user's
+home (~/moonraker, ~/printer_data); the Snapmaker U1 extended firmware's
+harness passes its own.
+"""
+
+from __future__ import annotations
+import argparse
+import os
+import shutil
+import sys
+from typing import List, Optional
+
+from . import __version__
+from . import settings as cfgmod
+
+SHIM_NAME = "pushraker.py"
+SECTION = "pushraker"
+# What 0.1.x installed under the old component name: replaced on install
+OLD_SHIM_NAME = "push_notifications.py"
+OLD_SECTION = "push_notifications"
+MOONRAKER_INCLUDE = "pushraker.cfg"
+KLIPPER_INCLUDE = "pushraker.cfg"
+SHIM = '''# pushraker: Moonraker loads components from this folder; this file hands
+# over to the installed package. Written by `python -m pushraker install`.
+import sys
+for _p in {paths!r}:
+    if _p and _p not in sys.path:
+        sys.path.append(_p)
+from pushraker.component import load_component  # noqa: E402,F401
+'''
+
+
+def home(sub: str) -> str:
+    return os.path.join(os.path.expanduser("~"), sub)
+
+
+def parse(argv: List[str]) -> argparse.Namespace:
+    p = argparse.ArgumentParser(prog="python -m pushraker",
+                                description=__doc__.split("\n\n")[0])
+    p.add_argument("command", choices=["install", "uninstall", "status"])
+    p.add_argument("--moonraker-dir", default=home("moonraker"),
+                   help="Moonraker's source directory (holds moonraker/components)")
+    p.add_argument("--data-dir", default=home("printer_data"),
+                   help="printer_data (config/, the secrets file lives here)")
+    p.add_argument("--moonraker-conf", default=None,
+                   help="moonraker.conf (default: <data-dir>/config/moonraker.conf)")
+    p.add_argument("--moonraker-include-dir", default=None,
+                   help="a directory moonraker.conf already includes: the "
+                        "[pushraker] section is written there as "
+                        "pushraker.cfg instead of into moonraker.conf")
+    p.add_argument("--printer-cfg", default=None,
+                   help="printer.cfg (default: <data-dir>/config/printer.cfg)")
+    p.add_argument("--klipper-include-dir", default=None,
+                   help="a directory printer.cfg already includes: the macro "
+                        "file is copied there instead of being included from "
+                        "printer.cfg")
+    p.add_argument("--site-packages", action="append", default=[],
+                   help="extra sys.path entries for the shim (the package's "
+                        "venv, when Moonraker's Python can't see it)")
+    p.add_argument("--name", default="Printer",
+                   help="the printer's default name in notifications")
+    p.add_argument("--error-index-url", default="",
+                   help="the printer maker's error-code index, linked from "
+                        "fault notifications")
+    p.add_argument("--import-ini", nargs=2, metavar=("FILE", "SECTION"),
+                   help="settings to move into pushraker.conf when it doesn't "
+                        "exist yet (e.g. extended2.cfg notifications)")
+    p.add_argument("--import-secrets", nargs=2, metavar=("FILE", "SECTION"),
+                   help="the secrets that go with --import-ini (e.g. "
+                        "moonraker.secrets notifications)")
+    p.add_argument("--purge", action="store_true",
+                   help="uninstall: also remove pushraker.conf and the secrets")
+    p.add_argument("--owner", default="",
+                   help="user[:group] the written files belong to (default: "
+                        "whoever owns the directory they go into)")
+    return p.parse_args(argv)
+
+
+def write(path: str, text: str, mode: int = 0o644,
+          owner: str = "") -> bool:
+    """Write if different; returns whether it changed. Files take the
+    owner of their directory unless --owner says otherwise."""
+    try:
+        with open(path, encoding="utf-8") as f:
+            if f.read() == text:
+                return False
+    except (OSError, UnicodeDecodeError):
+        pass
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tmp = path + ".tmp"
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, mode)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(text)
+    os.chmod(tmp, mode)
+    chown(tmp, owner, os.path.dirname(path))
+    os.replace(tmp, path)
+    return True
+
+
+def chown(path: str, owner: str, like: str) -> None:
+    try:
+        if owner:
+            import pwd
+            import grp
+            user, _, group = owner.partition(":")
+            uid = pwd.getpwnam(user).pw_uid
+            gid = grp.getgrnam(group).gr_gid if group else \
+                pwd.getpwnam(user).pw_gid
+        else:
+            st = os.stat(like)
+            uid, gid = st.st_uid, st.st_gid
+        os.chown(path, uid, gid)
+    except (KeyError, OSError, ImportError):
+        pass
+
+
+def remove(path: str) -> bool:
+    try:
+        os.remove(path)
+        return True
+    except OSError:
+        return False
+
+
+SAVE_CONFIG_HEADER = "#*# <---------------------- SAVE_CONFIG"
+
+
+def read_lines(conf: str) -> List[str]:
+    try:
+        with open(conf, encoding="utf-8") as f:
+            return f.read().splitlines(True)
+    except (OSError, UnicodeDecodeError):
+        return []
+
+
+def is_header(line: str, section: str) -> bool:
+    s = line.strip()
+    return s.startswith("[") and s.endswith("]") and \
+        s.lower().replace(" ", "") == f"[{section}]".lower().replace(" ", "")
+
+
+def ensure_section(conf: str, section: str, text: str, owner: str) -> bool:
+    """Add a section to a config file if it has none: before Klipper's
+    SAVE_CONFIG block when there is one (Klipper refuses anything after
+    that header and drops the saved calibration), else at the end."""
+    lines = read_lines(conf)
+    if any(is_header(ln, section) for ln in lines):
+        return False
+    at = next((i for i, ln in enumerate(lines)
+               if ln.startswith(SAVE_CONFIG_HEADER)), len(lines))
+    block = text if text.endswith("\n") else text + "\n"
+    before = "".join(lines[:at])
+    if before and not before.endswith("\n"):
+        before += "\n"
+    if before and not before.endswith("\n\n"):
+        before += "\n"
+    after = "".join(lines[at:])
+    return write(conf, before + block + ("\n" + after if after else ""),
+                 owner=owner)
+
+
+def drop_section(conf: str, section: str, owner: str) -> bool:
+    """Remove a section from a config file: an [include ...] is its one
+    line; anything else runs to the next header or Klipper's SAVE_CONFIG
+    block."""
+    lines = read_lines(conf)
+    if not lines:
+        return False
+    out: List[str] = []
+    skipping = False
+    one_line = section.lower().startswith("include ")
+    for ln in lines:
+        s = ln.strip()
+        if is_header(ln, section):
+            if one_line:
+                continue
+            skipping = True
+            continue
+        if skipping and ((s.startswith("[") and s.endswith("]"))
+                         or ln.startswith(SAVE_CONFIG_HEADER)):
+            skipping = False
+        if not skipping:
+            out.append(ln)
+    text = "".join(out)
+    if text == "".join(lines):
+        return False
+    return write(conf, text, owner=owner)
+
+
+def macro_file() -> str:
+    return os.path.join(os.path.dirname(__file__), "klipper", KLIPPER_INCLUDE)
+
+
+def places(a: argparse.Namespace) -> dict:
+    config_dir = os.path.join(a.data_dir, "config")
+    return dict(
+        shim=os.path.join(a.moonraker_dir, "moonraker", "components",
+                          SHIM_NAME),
+        old_shim=os.path.join(a.moonraker_dir, "moonraker", "components",
+                              OLD_SHIM_NAME),
+        moonraker_conf=a.moonraker_conf
+        or os.path.join(config_dir, "moonraker.conf"),
+        moonraker_include=os.path.join(a.moonraker_include_dir,
+                                       MOONRAKER_INCLUDE)
+        if a.moonraker_include_dir else "",
+        printer_cfg=a.printer_cfg or os.path.join(config_dir, "printer.cfg"),
+        klipper_include=os.path.join(a.klipper_include_dir, KLIPPER_INCLUDE)
+        if a.klipper_include_dir else os.path.join(config_dir,
+                                                   KLIPPER_INCLUDE),
+        store=cfgmod.Store(config_dir, a.data_dir, name=a.name))
+
+
+def section_text(a: argparse.Namespace) -> str:
+    lines = [f"[{SECTION}]",
+             "# pushraker (python -m pushraker install); settings are in "
+             "pushraker.conf",
+             f"name: {a.name}"]
+    if a.error_index_url:
+        lines.append(f"error_index_url: {a.error_index_url}")
+    return "\n".join(lines) + "\n"
+
+
+def cmd_install(a: argparse.Namespace) -> int:
+    p = places(a)
+    changed = []
+    if p["moonraker_include"] and os.path.realpath(p["moonraker_include"]) \
+            == os.path.realpath(p["klipper_include"]):
+        print("ERROR: --moonraker-include-dir and the Klipper include "
+              "directory are the same; both files are named pushraker.cfg")
+        return 1
+    if not os.path.isdir(os.path.dirname(p["shim"])):
+        print(f"ERROR: no Moonraker components directory at "
+              f"{os.path.dirname(p['shim'])} (--moonraker-dir)")
+        return 1
+    if write(p["shim"], SHIM.format(paths=list(a.site_packages)),
+             owner=a.owner):
+        changed.append(p["shim"])
+    # 0.1.x's names: the old shim and section would load the component a
+    # second time
+    if remove(p["old_shim"]):
+        changed.append(f"removed {p['old_shim']}")
+    if p["moonraker_include"]:
+        if write(p["moonraker_include"], section_text(a), owner=a.owner):
+            changed.append(p["moonraker_include"])
+    else:
+        if drop_section(p["moonraker_conf"], OLD_SECTION, a.owner):
+            changed.append(f"[{OLD_SECTION}] removed from {p['moonraker_conf']}")
+        if ensure_section(p["moonraker_conf"], SECTION, section_text(a),
+                          a.owner):
+            changed.append(p["moonraker_conf"])
+    with open(macro_file()) as f:
+        macros = f.read()
+    if write(p["klipper_include"], macros, owner=a.owner):
+        changed.append(p["klipper_include"])
+    if not a.klipper_include_dir:
+        if ensure_section(p["printer_cfg"], f"include {KLIPPER_INCLUDE}",
+                          f"[include {KLIPPER_INCLUDE}]\n", a.owner):
+            changed.append(p["printer_cfg"])
+    store = p["store"]
+    if not store.exists():
+        s = None
+        if a.import_ini:
+            s = cfgmod.import_ini(a.import_ini[0], a.import_ini[1],
+                                  *(a.import_secrets or ("", "")),
+                                  name=a.name)
+            if s["enabled"] or s["server"] or s["secret"]:
+                print(f"Moving settings from {a.import_ini[0]} "
+                      f"[{a.import_ini[1]}] to {store.settings_path}")
+            else:
+                s = None
+        if s is not None:
+            store.save(s)
+            chown(store.settings_path, a.owner,
+                  os.path.dirname(store.settings_path))
+            if os.path.exists(store.secrets_path):
+                chown(store.secrets_path, a.owner, a.data_dir)
+            changed.append(store.settings_path)
+        # Otherwise the component writes it at its first start, with the
+        # defaults for the printer it finds
+    for path in changed:
+        print(f"Updated: {path}")
+    if not changed:
+        print("Already installed; nothing changed.")
+    print(f"pushraker {__version__} is set up. Restart Moonraker and "
+          "Klipper to load it, then open the notifications page.")
+    return 0
+
+
+def cmd_uninstall(a: argparse.Namespace) -> int:
+    p = places(a)
+    removed = []
+    for path in (p["shim"], p["old_shim"], p["moonraker_include"],
+                 p["klipper_include"]):
+        if path and remove(path):
+            removed.append(path)
+    if not p["moonraker_include"]:
+        for section in (SECTION, OLD_SECTION):
+            if drop_section(p["moonraker_conf"], section, a.owner):
+                removed.append(f"[{section}] in {p['moonraker_conf']}")
+    if not a.klipper_include_dir and drop_section(
+            p["printer_cfg"], f"include {KLIPPER_INCLUDE}", a.owner):
+        removed.append(f"[include {KLIPPER_INCLUDE}] in {p['printer_cfg']}")
+    if a.purge:
+        for path in (p["store"].settings_path, p["store"].secrets_path):
+            if remove(path):
+                removed.append(path)
+    for path in removed:
+        print(f"Removed {path}")
+    if not removed:
+        print("Nothing to remove.")
+    print("Restart Moonraker and Klipper to unload pushraker.")
+    return 0
+
+
+def cmd_status(a: argparse.Namespace) -> int:
+    p = places(a)
+    print(f"pushraker {__version__}")
+    for what, path in (("shim", p["shim"]),
+                       ("Moonraker section", p["moonraker_include"]
+                        or p["moonraker_conf"]),
+                       ("Klipper macros", p["klipper_include"]),
+                       ("settings", p["store"].settings_path),
+                       ("secrets", p["store"].secrets_path)):
+        print(f"  {what}: {path} "
+              f"({'present' if os.path.exists(path) else 'missing'})")
+    if p["store"].exists():
+        print("  " + cfgmod.summary(p["store"].load()))
+    return 0
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    a = parse(sys.argv[1:] if argv is None else argv)
+    return {"install": cmd_install, "uninstall": cmd_uninstall,
+            "status": cmd_status}[a.command](a)
+
+
+if __name__ == "__main__":
+    sys.exit(main())