wirenote 0.1.0__py3-none-any.whl

wirenote/tools/install.py

@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""`wirenote setup install` / `uninstall`: systemd user units, the app-menu entry
+and its icon, so nobody copies files by hand.
+
+Nothing here needs root: everything goes to the user's own config and data folders.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+
+from ..config.settings import config_dir, data_dir, load_settings, state_dir
+
+UNITS = ("wirenote.service", "wirenote-ui.service")
+OLD_UNITS = ("meetnote.service", "meetnote-ui.service")
+
+
+@dataclass(frozen=True)
+class Action:
+    kind: str          # "write" | "run" | "remove"
+    target: str        # a path, or a description of the command
+    payload: object    # file text, or argv
+
+
+def _units_dir() -> Path:
+    return config_dir().parent / "systemd" / "user"
+
+
+def _xdg_data() -> Path:
+    return data_dir().parent
+
+
+def _desktop_path() -> Path:
+    return _xdg_data() / "applications" / "wirenote.desktop"
+
+
+def _icon_path() -> Path:
+    return _xdg_data() / "icons" / "hicolor" / "scalable" / "apps" / "wirenote.svg"
+
+
+def _exe() -> str:
+    found = shutil.which("wirenote")
+    return found or str(Path(sys.argv[0]).resolve())
+
+
+def _run(argv: list[str]) -> int:
+    return subprocess.run(argv, check=False).returncode
+
+
+def _template(name: str, exe: str) -> str:
+    quoted = f'"{exe}"' if " " in exe else exe
+    return (files("wirenote") / "data" / name).read_text().replace("@EXEC@", quoted)
+
+
+def _systemctl(*args: str) -> Action:
+    argv = ["systemctl", "--user", *args]
+    return Action("run", " ".join(argv), argv)
+
+
+def plan_install(exe: str) -> list[Action]:
+    units = _units_dir()
+    actions = [Action("write", str(units / u), _template(u, exe)) for u in UNITS]
+    actions.append(Action("write", str(_desktop_path()), _template("wirenote.desktop", exe)))
+    actions.append(Action("write", str(_icon_path()),
+                          (files("wirenote") / "ui" / "static" / "icon.svg").read_text()))
+    actions.append(_systemctl("daemon-reload"))
+    if any((units / u).exists() for u in OLD_UNITS):
+        # Before enabling ours: the old UI holds the same port.
+        actions.append(_systemctl("disable", "--now", *OLD_UNITS))
+        actions += [Action("remove", str(units / u), None) for u in OLD_UNITS]
+        actions.append(_systemctl("daemon-reload"))
+    actions.append(_systemctl("enable", *UNITS))
+    # Restart rather than start, so an update runs the new code.
+    actions.append(_systemctl("restart", *UNITS))
+    return actions
+
+
+def _apply(actions: list[Action], dry_run: bool) -> int:
+    failed = 0
+    for a in actions:
+        if a.kind == "write":
+            print(f"write {a.target}")
+            if dry_run:
+                print("".join(f"    {line}\n" for line in str(a.payload).splitlines()), end="")
+                continue
+            path = Path(a.target)
+            path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+            path.write_text(str(a.payload))
+        elif a.kind == "remove":
+            print(f"remove {a.target}")
+            if not dry_run:
+                Path(a.target).unlink(missing_ok=True)
+        else:
+            print(f"run {a.target}")
+            if not dry_run and _run(list(a.payload)) != 0:
+                print(f"  ✗ {a.target} failed")
+                failed += 1
+    return 1 if failed else 0
+
+
+def install(dry_run: bool = False) -> int:
+    rc = _apply(plan_install(_exe()), dry_run)
+    if not dry_run and rc == 0:
+        print("\n✓ Wirenote runs in the background and starts with your session.")
+        print("  Open it from the app menu, or run: wirenote open. Check the setup: wirenote doctor")
+    return rc
+
+
+def uninstall(purge: bool = False, dry_run: bool = False,
+              confirm: Callable[[str], str] = input) -> int:
+    actions = [_systemctl("disable", "--now", *UNITS)]
+    actions += [Action("remove", str(_units_dir() / u), None) for u in UNITS]
+    actions += [Action("remove", str(_desktop_path()), None),
+                Action("remove", str(_icon_path()), None), _systemctl("daemon-reload")]
+    folders: list[Path] = []
+    if purge:
+        settings = load_settings(config_dir() / "config.toml")
+        folders = [config_dir(), state_dir(), data_dir()]
+        if not settings.recordings_path().is_relative_to(data_dir()):
+            folders.append(settings.recordings_path())
+        print("This deletes all recordings, transcripts, settings and voice prints:")
+        for f in folders:
+            print(f"  {f}")
+        print(f"Your Markdown notes in {settings.notes_path()} are kept.")
+        if not dry_run and confirm("Type DELETE to remove them: ").strip() != "DELETE":
+            print("nothing removed")
+            return 1
+    rc = _apply(actions, dry_run)
+    for f in folders:
+        print(f"remove {f}")
+        if not dry_run:
+            shutil.rmtree(f, ignore_errors=True)
+    return rc

wirenote/tools/setup.py

@@ -0,0 +1,338 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""`wirenote setup`, `wirenote calendar` and `wirenote doctor`.
+
+Secrets (API key, calendar links) are read from the terminal, never from the
+command line, so they stay out of shell history, and go to secrets.toml.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import getpass
+import json
+import os
+import shutil
+import subprocess
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..config.secrets import (calendar_sources, load_secrets, save_secrets, secrets_path,
+                              set_config_value)
+from ..net.peer import listener_uid, trusted_owner
+from ..config.settings import Settings, config_dir, load_settings, state_dir
+
+OK, BAD, WARN = "✓", "✗", "!"
+
+
+def _settings() -> Settings:
+    return load_settings(config_dir() / "config.toml")
+
+
+def _poke_daemon(command: str) -> None:
+    from ..detector.daemon import control_socket_path
+    import socket
+
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+            s.settimeout(3)
+            s.connect(str(control_socket_path()))
+            s.sendall(f"{command}\n".encode())
+            s.makefile().readline()
+    except OSError:
+        pass
+
+
+# setup -------------------------------------------------------------------------
+
+def setup_claude() -> int:
+    s = _settings()
+    print("Summaries through the Claude API: transcripts are sent to Anthropic.")
+    print("Check your employer's policy before using this for work calls.\n")
+    key = getpass.getpass("Anthropic API key (input hidden, empty to keep the current one): ")
+    secrets = load_secrets()
+    if key.strip():
+        secrets["anthropic_api_key"] = key.strip()
+    if not secrets.get("anthropic_api_key") and not os.environ.get("ANTHROPIC_API_KEY"):
+        print("no key given")
+        return 1
+    import anthropic
+
+    client = anthropic.Anthropic(api_key=secrets.get("anthropic_api_key"))
+    try:
+        client.models.retrieve(s.anthropic_model)      # free; checks key and model
+    except anthropic.AuthenticationError:
+        print(f"{BAD} the key was rejected; nothing changed")
+        return 1
+    except anthropic.NotFoundError:
+        print(f"{BAD} model {s.anthropic_model} not available to this key; nothing changed")
+        return 1
+    except anthropic.APIConnectionError as e:
+        print(f"{BAD} cannot reach the API ({e}); nothing changed")
+        return 1
+    save_secrets(secrets)
+    set_config_value(config_dir() / "config.toml", "summary_backend", '"anthropic"')
+    print(f"{OK} key works with {s.anthropic_model}; saved to {secrets_path()} (mode 600)")
+    print(f"{OK} summary_backend = \"anthropic\"; the next note uses it (no restart needed)")
+    return 0
+
+
+def setup_ollama() -> int:
+    s = _settings()
+    ok, msg = _check_ollama(s)
+    print(f"{OK if ok else BAD} {msg}")
+    if not ok:
+        return 1
+    set_config_value(config_dir() / "config.toml", "summary_backend", '"ollama"')
+    print(f"{OK} summary_backend = \"ollama\"; the next note uses it (no restart needed)")
+    return 0
+
+
+def setup_consent(text: str | None) -> int:
+    if text is None:
+        text = input("Consent line (empty to turn it off): ").strip()
+    set_config_value(config_dir() / "config.toml", "consent_line", json.dumps(text, ensure_ascii=False))
+    print(f"{OK} consent line {'set' if text else 'turned off'}; restart to apply: "
+          "systemctl --user restart wirenote")
+    return 0
+
+
+# calendar ----------------------------------------------------------------------
+
+def calendar_list() -> int:
+    from ..calendar import ics
+
+    s = _settings()
+    sources = calendar_sources(s.calendar_urls)
+    if not sources:
+        print("no calendar yet; add one with: wirenote calendar add")
+        return 1
+    now = dt.datetime.now().astimezone()
+    events, errors = ics.load(sources, now)
+    for err in errors:
+        print(f"{BAD} {err}")
+    window = set(id(e) for e in ics.in_window(events, now, s.calendar_before_s,
+                                               s.calendar_after_start_s))
+    upcoming = sorted((e for e in events if e.end > now), key=lambda e: e.start)
+    print(f"{len(sources)} calendar(s), {len(upcoming)} event(s) in the next 24 h:")
+    for e in upcoming:
+        mark = "→" if id(e) in window else " "
+        call = "  [call link]" if e.service_links(None) else ""
+        print(f" {mark} {e.start.astimezone():%a %H:%M}-{e.end.astimezone():%H:%M}  {e.title}{call}")
+    if window:
+        print("→ in the prompt window now")
+    return 1 if errors and not events else 0
+
+
+def calendar_add() -> int:
+    from ..calendar import ics
+
+    print("Paste the calendar's ICS link (Outlook: Settings > Calendar > Shared calendars >")
+    print("Publish a calendar > ICS; Google: Settings > your calendar > Secret address in iCal).")
+    print("It is stored in secrets.toml, not in config.toml or the logs.\n")
+    url = getpass.getpass("ICS link (input hidden): ").strip()
+    if not url:
+        print("nothing added")
+        return 1
+    now = dt.datetime.now().astimezone()
+    try:
+        events = ics.parse(ics.fetch(url), now)
+    except Exception as e:  # noqa: BLE001
+        print(f"{BAD} could not read that calendar: {ics.describe_error(url, e)}")
+        return 1
+    secrets = load_secrets()
+    urls = list(dict.fromkeys([*secrets.get("calendar_urls", []), url]))
+    secrets["calendar_urls"] = urls
+    save_secrets(secrets)
+    _poke_daemon("refresh-calendar")
+    print(f"{OK} calendar added ({len(events)} timed events in the next 24 h); "
+          "the daemon picks it up now")
+    return 0
+
+
+def calendar_clear() -> int:
+    secrets = load_secrets()
+    n = len(secrets.pop("calendar_urls", []))
+    save_secrets(secrets)
+    _poke_daemon("refresh-calendar")
+    print(f"{OK} removed {n} calendar link(s) from {secrets_path()}")
+    return 0
+
+
+# doctor ------------------------------------------------------------------------
+
+def _check_ollama(s: Settings) -> tuple[bool, str]:
+    from ..process.summarize import pin_local
+
+    url = s.ollama_url.rstrip("/")
+    local = pin_local(url)
+    if local:
+        url, ip, port = local
+        owner = listener_uid(port, ip)
+        if owner is not None and not trusted_owner(owner):
+            return False, (f"port {port} belongs to another user (uid {owner}), so Wirenote "
+                           "will not send transcripts there; start your own Ollama or set "
+                           "ollama_url")
+    try:
+        with urllib.request.urlopen(f"{url}/api/tags", timeout=5) as r:
+            models = [m["name"] for m in json.loads(r.read()).get("models", [])]
+    except OSError as e:
+        return False, (f"Ollama not reachable at {s.ollama_url} ({e}); "
+                       "start it: systemctl --user start ollama")
+    want = s.ollama_model if ":" in s.ollama_model else f"{s.ollama_model}:latest"
+    if want not in models:
+        return False, f"Ollama runs, but {s.ollama_model} is not pulled: ollama pull {s.ollama_model}"
+    return True, f"Ollama runs with {s.ollama_model}"
+
+
+@dataclass(frozen=True)
+class Check:
+    status: str              # "ok" | "warn" | "bad"
+    message: str
+    fix: str | None = None
+
+
+def _ok(cond: bool, ok_msg: str, bad_msg: str, fix: str | None = None,
+        warn: bool = False) -> Check:
+    if cond:
+        return Check("ok", ok_msg)
+    return Check("warn" if warn else "bad", bad_msg, fix)
+
+
+def _daemon_checks() -> list[Check]:
+    try:
+        status = json.loads((state_dir() / "status.json").read_text())
+    except (OSError, ValueError):
+        return [Check("bad", "the background service has never run",
+                      "wirenote setup install")]
+    alive = bool(status.get("running") and Path(f"/proc/{status.get('pid')}").exists())
+    out = [_ok(alive, "background service running", "background service not running",
+               "systemctl --user start wirenote")]
+    out.append(_ok(bool(status.get("notifications")), "desktop notifications work",
+                   "desktop notifications unavailable"))
+    if status.get("notifications") and status.get("notification_buttons") is False:
+        out.append(Check("warn", "notifications here have no buttons: record from the Wirenote "
+                                 "window or with `wirenote record`"))
+    failed = (status.get("jobs") or {}).get("failed", 0)
+    out.append(_ok(not failed, "no failed note jobs", f"{failed} failed note job(s)",
+                   "wirenote jobs", warn=True))
+    return out
+
+
+def _pipewire_checks() -> list[Check]:
+    try:
+        dump = json.loads(subprocess.run(["pw-dump"], capture_output=True, timeout=10,
+                                         check=True).stdout)
+        from ..detector.graph import Graph
+        g = Graph()
+        g.apply(dump)
+        out = [Check("ok", f"PipeWire: mic {g.default_node('default.audio.source')}, "
+                           f"output {g.default_node('default.audio.sink')}")]
+    except (OSError, subprocess.SubprocessError, ValueError) as e:
+        out = [Check("bad", f"PipeWire not readable: {e}")]
+    out.append(_ok(shutil.which("pw-record") is not None, "pw-record installed",
+                   "pw-record missing", "install your distribution's pipewire tools"))
+    out.append(_ok(shutil.which("ffmpeg") is not None, "ffmpeg installed",
+                   "ffmpeg missing: the web app cannot play recordings",
+                   "install ffmpeg", warn=True))
+    return out
+
+
+def _model_checks(s: Settings) -> list[Check]:
+    from ..process.models import EMB_REPO, SEG_FILE, SEG_REPO, hub_file, whisper_path
+
+    out = []
+    try:
+        whisper_path(s.whisper_model, local_only=True)
+        out.append(Check("ok", f"Whisper model {s.whisper_model} is downloaded"))
+    except Exception:  # noqa: BLE001
+        out.append(Check("warn", f"Whisper model {s.whisper_model} downloads on the first note "
+                                 "(about 1.6 GB for large-v3-turbo)"))
+    if s.diarize:
+        try:
+            hub_file(SEG_REPO, SEG_FILE, local_only=True)
+            hub_file(EMB_REPO, s.diarize_model, local_only=True)
+            out.append(Check("ok", "speaker separation models are downloaded"))
+        except Exception:  # noqa: BLE001
+            out.append(Check("warn", "speaker separation models download on the first note "
+                                     "(about 32 MB)"))
+    return out
+
+
+def _summary_checks(s: Settings) -> list[Check]:
+    if s.summary_backend == "ollama":
+        ok, msg = _check_ollama(s)
+        return [Check("ok" if ok else "bad", msg)]
+    if s.summary_backend == "anthropic":
+        has_key = bool(load_secrets().get("anthropic_api_key") or os.environ.get("ANTHROPIC_API_KEY"))
+        return [_ok(has_key, f"Claude API ({s.anthropic_model}): key set; transcripts are "
+                             "sent to Anthropic",
+                    f"Claude API ({s.anthropic_model}): no key", "wirenote setup claude")]
+    return [Check("warn", "summaries are off (summary_backend = \"none\")")]
+
+
+def _calendar_checks(s: Settings) -> list[Check]:
+    sources = calendar_sources(s.calendar_urls)
+    if not sources:
+        return [Check("warn", "no calendar (optional): titles and invitees come from it",
+                      "wirenote calendar add")]
+    from ..calendar import ics
+    events, errors = ics.load(sources, dt.datetime.now().astimezone())
+    return [_ok(not errors, f"{len(sources)} calendar(s), {len(events)} events around now",
+                f"{len(errors)} of {len(sources)} calendar(s) failed: {errors[0] if errors else ''}")]
+
+
+def _desktop_checks(s: Settings) -> list[Check]:
+    from ..notify.clipboard import available_tools
+
+    desktop = os.environ.get("XDG_CURRENT_DESKTOP") or "unknown"
+    out = [Check("ok", f"desktop: {desktop}")]
+    if s.consent_line and "KDE" not in desktop.upper() and not available_tools():
+        out.append(Check("warn", "no clipboard tool for the consent line",
+                         "install wl-clipboard (Wayland) or xclip (X11)"))
+    return out
+
+
+def _file_checks(s: Settings) -> list[Check]:
+    from ..calendar.ics import SCHEME
+    from ..config.perms import loose_files, private_paths
+
+    out = [Check("ok", "consent line set") if s.consent_line else
+           Check("warn", "no consent line (optional)", 'wirenote setup consent "…"')]
+    rec_root = s.recordings_path()
+    rec_root.mkdir(mode=0o700, parents=True, exist_ok=True)
+    free_gb = shutil.disk_usage(rec_root).free / 1e9
+    out.append(_ok(free_gb > 5, f"{free_gb:.0f} GB free for recordings (about 0.23 GB per hour)",
+                   f"only {free_gb:.1f} GB free for recordings"))
+    notes = s.notes_path()
+    notes.mkdir(mode=0o700, parents=True, exist_ok=True)
+    out.append(_ok(os.access(notes, os.W_OK), f"notes go to {notes}", f"cannot write to {notes}"))
+    loose = loose_files(*private_paths(s))
+    out.append(_ok(not loose, "recordings, notes and settings are private to you",
+                   f"{len(loose)} file(s) or folder(s) readable by other users",
+                   "wirenote doctor --fix"))
+    if any(SCHEME.match(str(u)) for u in s.calendar_urls):
+        out.append(Check("warn", "calendar link in config.toml: links are secret, keep them "
+                                 "in secrets.toml",
+                         "wirenote calendar add, then remove it from config.toml"))
+    return out
+
+
+def checks(s: Settings) -> list[Check]:
+    return [*_daemon_checks(), *_pipewire_checks(), *_model_checks(s), *_summary_checks(s),
+            *_calendar_checks(s), *_desktop_checks(s), *_file_checks(s)]
+
+
+def doctor(fix: bool = False) -> int:
+    s = _settings()
+    if fix:
+        from ..config.perms import fix_modes, private_paths
+        print(f"{OK} made {fix_modes(*private_paths(s))} file(s) and folder(s) private")
+    found = checks(s)
+    for c in found:
+        mark = {"ok": OK, "warn": WARN, "bad": BAD}[c.status]
+        print(f"{mark} {c.message}" + (f": {c.fix}" if c.fix else ""))
+    problems = sum(c.status == "bad" for c in found)
+    print("\nall good" if not problems else f"\n{problems} problem(s)")
+    return 1 if problems else 0

wirenote/ui/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav