wirenote 0.1.0__py3-none-any.whl

wirenote/cli.py

@@ -0,0 +1,262 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""wirenote command line: run | status | stop | record | jobs | reprocess | setup | calendar | doctor | ui | open."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import socket
+import sys
+
+from .config.apps import AppsError, load_apps
+from .config.settings import config_dir, load_settings, state_dir
+
+
+def _settings():
+    try:
+        return load_settings(config_dir() / "config.toml")
+    except ValueError as e:
+        raise SystemExit(f"wirenote: {e}")
+
+
+def cmd_run(_args) -> int:
+    from .detector.daemon import Daemon
+
+    try:
+        settings = load_settings(config_dir() / "config.toml")
+        rules = load_apps(config_dir() / "apps.toml")
+    except (AppsError, ValueError) as e:
+        print(f"wirenote: {e}", file=sys.stderr)
+        return 2
+    asyncio.run(Daemon(settings, rules, state_dir()).run())
+    return 0
+
+
+def cmd_status(_args) -> int:
+    path = state_dir() / "status.json"
+    try:
+        status = json.loads(path.read_text())
+    except (OSError, ValueError):
+        print(f"no status yet ({path}); is `wirenote run` running?")
+        return 1
+    print(f"updated {status['updated']}  pid {status['pid']}  "
+          f"{'running' if status.get('running') else 'stopped'}"
+          f"{'' if status.get('notifications') else '  NO NOTIFICATIONS'}")
+    if status.get("recording"):
+        print(f"recording: {status['recording']}  ({status.get('recording_id')})")
+    jobs = status.get("jobs") or {}
+    if any(jobs.get(s) for s in ("queued", "transcribing", "summarizing", "failed")):
+        print("jobs: " + "  ".join(f"{k}={v}" for k, v in sorted(jobs.items())))
+    apps = status.get("apps") or {}
+    if not apps:
+        print("no app on the mic")
+    for key, a in apps.items():
+        extra = "  ".join(f"{k}={v}" for k, v in a.items() if k not in ("state", "name"))
+        print(f"  {a['name']:<12} {a['state']:<13} {extra}")
+    return 0
+
+
+def _control(command: str) -> int:
+    from .detector.daemon import control_socket_path
+
+    path = control_socket_path()
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+            s.settimeout(5)
+            s.connect(str(path))
+            s.sendall(f"{command}\n".encode())
+            reply = json.loads(s.makefile().readline())
+    except (OSError, ValueError) as e:
+        print(f"wirenote: cannot reach the daemon at {path} ({e}); is it running?")
+        return 1
+    if reply.get("ok"):
+        print(f"{command}: {reply.get('app')}")
+        return 0
+    print(f"{command}: {reply.get('error')}")
+    return 1
+
+
+def cmd_stop(_args) -> int:
+    return _control("stop")
+
+
+def cmd_record(args) -> int:
+    return _control("record-now" if args.now else "record")
+
+
+def cmd_jobs(args) -> int:
+    from .process.jobs import Jobs
+
+    jobs = Jobs(state_dir() / "jobs.db")
+    rows = jobs.recent(args.n)
+    if not rows:
+        print("no jobs yet")
+    for j in rows:
+        print(f"{j.id:>4}  {j.state:<12} {j.recording.name:<34} {j.updated}")
+        if j.note:
+            print(f"      note: {j.note}")
+        if j.error and j.state != "done":
+            print(f"      error (attempt {j.attempts}): {j.error.strip().splitlines()[-1]}")
+    return 0
+
+
+def cmd_reprocess(args) -> int:
+    from .process.jobs import Jobs
+
+    rec = _settings().recordings_path() / args.recording
+    if not (rec / "manifest.json").is_file():
+        print(f"wirenote: no recording {args.recording} in {rec.parent}")
+        return 1
+    if not args.summary and not any(rec.glob("*.wav")):
+        print("wirenote: the audio was deleted; only --summary can be redone")
+        return 1
+    job_id = Jobs(state_dir() / "jobs.db").add(rec, summary_only=args.summary)
+    print(f"queued job {job_id}; the daemon picks it up within 30 s (`wirenote jobs`)")
+    return 0
+
+
+def cmd_process(args) -> int:
+    """Run one job in this process. The daemon starts this; it exits 0 once the
+    job's outcome is recorded, even a failed attempt."""
+    from .process.jobs import Jobs
+    from .process.worker import run_job
+
+    job = run_job(args.job, _settings(), Jobs(state_dir() / "jobs.db"))
+    print(f"job {job.id}: {job.state}", file=sys.stderr)
+    return 0
+
+
+def cmd_setup(args) -> int:
+    from .tools import install, setup
+
+    if args.what == "install":
+        return install.install(dry_run=args.dry_run)
+    if args.what == "uninstall":
+        return install.uninstall(purge=args.purge, dry_run=args.dry_run)
+    if args.what == "claude":
+        return setup.setup_claude()
+    if args.what == "ollama":
+        return setup.setup_ollama()
+    return setup.setup_consent(args.text)
+
+
+def cmd_calendar(args) -> int:
+    from .tools import setup
+
+    return {"list": setup.calendar_list, "add": setup.calendar_add,
+            "clear": setup.calendar_clear}[args.action]()
+
+
+def cmd_ui(args) -> int:
+    from .ui.server import serve
+
+    s = _settings()
+    serve(s, state_dir(), args.port or s.ui_port, open_browser=args.open)
+    return 0
+
+
+def cmd_open(args) -> int:
+    """Open the web UI through a one-time login link, starting it if needed."""
+    import subprocess
+    import time
+
+    from .ui import launch
+
+    port = _settings().ui_port
+    if launch.listener_uid(port) is None:
+        subprocess.Popen([sys.executable, "-m", "wirenote.cli", "ui"], start_new_session=True,
+                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+                         stderr=subprocess.DEVNULL)
+        for _ in range(50):
+            if launch.listener_uid(port) is not None:
+                break
+            time.sleep(0.1)
+    if launch.listener_uid(port) != os.getuid():
+        print(f"wirenote: port {port} belongs to another user or nothing answers there; "
+              "not opening it. Set ui_port in config.toml to a free port.", file=sys.stderr)
+        return 1
+    launch.open_ui(port, f"#/call/{args.call}" if args.call else "#/")
+    return 0
+
+
+def cmd_doctor(args) -> int:
+    from .tools import setup
+
+    return setup.doctor(fix=args.fix)
+
+
+def cmd_dump_streams(args) -> int:
+    from .tools.dump_streams import main as dump_main
+    return dump_main(args.rest)
+
+
+def main(argv: list[str] | None = None) -> int:
+    if not sys.platform.startswith("linux"):
+        print("wirenote: runs on Linux only; it needs PipeWire, systemd and D-Bus.",
+              file=sys.stderr)
+        return 2
+    os.umask(0o077)   # recordings, transcripts and notes are private
+    from .config.migrate import MigrationError, migrate_if_needed
+    try:
+        moved = migrate_if_needed()
+    except MigrationError as e:
+        print(f"wirenote: {e}", file=sys.stderr)
+        return 2
+    if moved:
+        print(moved, file=sys.stderr)
+    ap = argparse.ArgumentParser(prog="wirenote", description=__doc__)
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("run", help="run the daemon").set_defaults(fn=cmd_run)
+    sub.add_parser("status", help="show what the daemon sees").set_defaults(fn=cmd_status)
+    sub.add_parser("stop", help="stop the current recording").set_defaults(fn=cmd_stop)
+    rec = sub.add_parser("record", help="answer the open prompt with Record")
+    rec.add_argument("--now", action="store_true",
+                     help="record a meeting without a call app (in person, phone on speaker)")
+    rec.set_defaults(fn=cmd_record)
+    jobs = sub.add_parser("jobs", help="list recent processing jobs")
+    jobs.add_argument("-n", type=int, default=10)
+    jobs.set_defaults(fn=cmd_jobs)
+    rep = sub.add_parser("reprocess", help="queue a recording again")
+    rep.add_argument("recording", help="recording id, e.g. 20261027-100000-chrome")
+    rep.add_argument("--summary", action="store_true",
+                     help="keep the transcript, redo only the summary and the note")
+    rep.set_defaults(fn=cmd_reprocess)
+    st = sub.add_parser("setup", help="install the services, choose the summary backend, "
+                                      "or set the consent line")
+    st.add_argument("what", choices=["install", "uninstall", "ollama", "claude", "consent"])
+    st.add_argument("text", nargs="?", help="consent line (for `setup consent`)")
+    st.add_argument("--dry-run", action="store_true",
+                    help="install/uninstall: show the files and commands, change nothing")
+    st.add_argument("--purge", action="store_true",
+                    help="uninstall: also delete recordings, transcripts and settings")
+    st.set_defaults(fn=cmd_setup)
+    cal = sub.add_parser("calendar", help="list upcoming events, add or remove ICS links")
+    cal.add_argument("action", nargs="?", default="list", choices=["list", "add", "clear"])
+    cal.set_defaults(fn=cmd_calendar)
+    doc = sub.add_parser("doctor", help="check that everything is set up")
+    doc.add_argument("--fix", action="store_true",
+                     help="make recordings, notes and settings private to you (chmod)")
+    doc.set_defaults(fn=cmd_doctor)
+    ui = sub.add_parser("ui", help="serve the meetings web app on 127.0.0.1")
+    ui.add_argument("--open", action="store_true", help="open it in the browser")
+    ui.add_argument("--port", type=int, default=0)
+    ui.set_defaults(fn=cmd_ui)
+    op = sub.add_parser("open", help="open the meetings web app in the browser")
+    op.add_argument("call", nargs="?", help="recording id to open")
+    op.set_defaults(fn=cmd_open)
+    proc = sub.add_parser("process", help=argparse.SUPPRESS)
+    proc.add_argument("job", type=int)
+    proc.set_defaults(fn=cmd_process)
+    dump = sub.add_parser("dump-streams", help="probe PipeWire capture streams (test fixtures)",
+                          add_help=False)
+    dump.add_argument("rest", nargs=argparse.REMAINDER)
+    dump.set_defaults(fn=cmd_dump_streams)
+    args = ap.parse_args(argv)
+    return args.fn(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wirenote/config/__init__.py

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

wirenote/config/apps.py

@@ -0,0 +1,158 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""App rules from apps.toml: exact matches only, never substrings.
+
+Each rule has a key, a display name, a kind (meeting, browser or ignore) and
+lists of exact values for flatpak, snap, exe, binary and app_name. Browser
+rules may carry title patterns: regexes on the stream's media.name that turn
+the stream into a known meeting (Firefox puts the page title there; see
+docs/dev/m0-findings.md › Firefox details).
+"""
+
+from __future__ import annotations
+
+import re
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+KINDS = ("meeting", "browser", "ignore")
+MATCH_FIELDS = ("flatpak", "snap", "exe", "binary", "app_name")
+
+DEFAULT_APPS_TOML = r'''# wirenote app rules. Exact matches only; see docs/dev/PLAN.md › Matching rules.
+# Fields: key, name, kind (meeting | browser | ignore), and any of
+# flatpak, snap, exe, binary, app_name (lists of exact values).
+# [[app.title]] entries match the stream's media.name with a regex; a match
+# makes the stream a meeting. A named group "room" is shown in the prompt.
+
+[[app]]
+key = "chrome"
+name = "Chrome"
+kind = "browser"
+exe = ["chrome"]        # verified: jitsi-chrome (audio service process)
+
+[[app]]
+key = "brave"
+name = "Brave"
+kind = "browser"
+exe = ["brave"]         # verified: live log 2026-10-26 (audio service process, pid ok)
+
+[[app]]
+key = "firefox"
+name = "Firefox"
+kind = "browser"
+exe = ["firefox-bin"]   # verified: jitsi-firefox (main process)
+
+  [[app.title]]
+  service = "Jitsi"
+  pattern = '^(?:(?P<room>.+) \| )?Jitsi Meet$'
+
+[[app]]
+key = "discord"
+name = "Discord"
+kind = "meeting"
+flatpak = ["com.discordapp.Discord"]   # unverified: confirm from detector log
+
+[[app]]
+key = "rocketchat"
+name = "Rocket.Chat"
+kind = "meeting"
+flatpak = ["chat.rocket.RocketChat"]   # unverified: confirm from detector log
+'''
+
+
+class AppsError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class TitleRule:
+    service: str
+    pattern: re.Pattern
+
+
+@dataclass(frozen=True)
+class AppRule:
+    key: str
+    name: str
+    kind: str
+    match: dict[str, frozenset[str]] = field(default_factory=dict)
+    titles: tuple[TitleRule, ...] = ()
+
+    def title_match(self, media_name: str | None) -> tuple[str, str | None] | None:
+        """(service, room) when media_name matches one of the title rules."""
+        if not media_name:
+            return None
+        for t in self.titles:
+            m = t.pattern.search(media_name)
+            if m:
+                room = m.groupdict().get("room")
+                return t.service, room
+        return None
+
+
+class AppRules:
+    def __init__(self, rules: list[AppRule]) -> None:
+        self.rules = rules
+        self._index: dict[tuple[str, str], AppRule] = {}
+        for rule in rules:
+            for fld, values in rule.match.items():
+                for v in values:
+                    other = self._index.setdefault((fld, v), rule)
+                    if other is not rule:
+                        raise AppsError(f"{fld}={v!r} is claimed by both "
+                                        f"{other.key!r} and {rule.key!r}")
+
+    def lookup(self, fld: str, value: str | None) -> AppRule | None:
+        if not value:
+            return None
+        return self._index.get((fld, value))
+
+    def get(self, key: str) -> AppRule | None:
+        return next((r for r in self.rules if r.key == key), None)
+
+
+def parse_apps(text: str) -> AppRules:
+    try:
+        data = tomllib.loads(text)
+    except tomllib.TOMLDecodeError as e:
+        raise AppsError(f"apps.toml: {e}") from e
+    rules = []
+    seen = set()
+    for i, raw in enumerate(data.get("app", [])):
+        where = f"apps.toml [[app]] #{i + 1}"
+        unknown = set(raw) - {"key", "name", "kind", "title", *MATCH_FIELDS}
+        if unknown:
+            raise AppsError(f"{where}: unknown field(s) {sorted(unknown)}")
+        key = raw.get("key")
+        if not key or key in seen:
+            raise AppsError(f"{where}: missing or duplicate key {key!r}")
+        seen.add(key)
+        kind = raw.get("kind")
+        if kind not in KINDS:
+            raise AppsError(f"{where} ({key}): kind must be one of {KINDS}, got {kind!r}")
+        match = {}
+        for fld in MATCH_FIELDS:
+            values = raw.get(fld, [])
+            if isinstance(values, str):
+                values = [values]
+            if values:
+                match[fld] = frozenset(values)
+        if not match:
+            raise AppsError(f"{where} ({key}): needs at least one of {MATCH_FIELDS}")
+        titles = []
+        for t in raw.get("title", []):
+            try:
+                titles.append(TitleRule(t["service"], re.compile(t["pattern"])))
+            except (KeyError, re.error) as e:
+                raise AppsError(f"{where} ({key}): bad title rule: {e}") from e
+        rules.append(AppRule(key, raw.get("name", key), kind, match, tuple(titles)))
+    return AppRules(rules)
+
+
+def load_apps(path: Path) -> AppRules:
+    """Read apps.toml, writing the default file first if it does not exist."""
+    if not path.exists():
+        path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        path.write_text(DEFAULT_APPS_TOML)
+    return parse_apps(path.read_text())

wirenote/config/migrate.py

@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""One-time move from meetnote's folders to Wirenote's.
+
+Copies first and deletes the old folders only after everything worked, so a
+failure leaves meetnote's data exactly as it was.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import socket
+import sqlite3
+import tomllib
+from pathlib import Path
+
+from .perms import fix_modes
+from .settings import config_dir, data_dir, state_dir
+
+OLD = "meetnote"
+LINK = re.compile(r"^(https?|webcal)://", re.IGNORECASE)
+
+
+class MigrationError(Exception):
+    pass
+
+
+def _pairs() -> list[tuple[Path, Path]]:
+    """(old, new) for the config, state and data folders."""
+    return [(new.parent / OLD, new) for new in (config_dir(), state_dir(), data_dir())]
+
+
+def _old_daemon_running() -> bool:
+    runtime = Path(os.environ.get("XDG_RUNTIME_DIR", f"/run/user/{os.getuid()}"))
+    path = runtime / f"{OLD}.sock"
+    if not path.exists():
+        return False
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+            s.settimeout(1)
+            s.connect(str(path))
+        return True
+    except OSError:
+        return False
+
+
+def _replace_all(value, swaps: list[tuple[str, str]]):
+    if isinstance(value, str):
+        for old, new in swaps:
+            if value == old or value.startswith(old + "/"):
+                return new + value[len(old):]
+        return value
+    if isinstance(value, list):
+        return [_replace_all(v, swaps) for v in value]
+    if isinstance(value, dict):
+        return {k: _replace_all(v, swaps) for k, v in value.items()}
+    return value
+
+
+def _rewrite_paths(new_data: Path, new_state: Path, swaps: list[tuple[str, str]]) -> None:
+    """Absolute paths in manifests and the jobs database point at the new folders."""
+    for manifest in (new_data / "recordings").glob("*/manifest.json"):
+        data = json.loads(manifest.read_text())
+        manifest.write_text(json.dumps(_replace_all(data, swaps), indent=2, ensure_ascii=False))
+    db_path = new_state / "jobs.db"
+    if db_path.exists():
+        db = sqlite3.connect(db_path)
+        try:
+            for old, new in swaps:
+                for col in ("recording", "note"):
+                    db.execute(f"UPDATE jobs SET {col} = ? || substr({col}, ?) "
+                               f"WHERE {col} = ? OR {col} LIKE ?",
+                               (new, len(old) + 1, old, old + "/%"))
+            db.commit()
+        finally:
+            db.close()
+
+
+def _move_calendar_links(cfg_dir: Path) -> None:
+    """Calendar links are secrets: they go from config.toml to secrets.toml (mode 600)."""
+    from .secrets import load_secrets, save_secrets, set_config_value
+
+    path = cfg_dir / "config.toml"
+    if not path.exists():
+        return
+    urls = tomllib.loads(path.read_text()).get("calendar_urls", [])
+    links = [u for u in urls if LINK.match(str(u))]
+    if not links:
+        return
+    secrets = load_secrets()
+    secrets["calendar_urls"] = list(dict.fromkeys([*secrets.get("calendar_urls", []), *links]))
+    save_secrets(secrets)
+    files = [u for u in urls if u not in links]
+    set_config_value(path, "calendar_urls", json.dumps(files, ensure_ascii=False))
+    tomllib.loads(path.read_text())   # a broken result rolls the migration back
+
+
+def migrate_if_needed() -> str | None:
+    """Move meetnote's data once; None when there is nothing to move."""
+    pairs = _pairs()
+    if not any(old.is_dir() for old, _ in pairs) or any(new.exists() for _, new in pairs):
+        return None
+    if _old_daemon_running():
+        raise MigrationError("meetnote is still running; stop the old service first: "
+                             "systemctl --user disable --now meetnote meetnote-ui")
+    created: list[Path] = []
+    try:
+        for old, new in pairs:
+            if not old.is_dir():
+                continue
+            tmp = new.with_name(f".{new.name}.migrating")
+            shutil.rmtree(tmp, ignore_errors=True)
+            shutil.copytree(old, tmp, symlinks=True)
+            created.append(tmp)
+            tmp.rename(new)
+            created[-1] = new
+        swaps = [(str(old), str(new)) for old, new in pairs]
+        _rewrite_paths(data_dir(), state_dir(), swaps)
+        _move_calendar_links(config_dir())
+        fix_modes([new for _, new in pairs])
+    except Exception as e:  # noqa: BLE001 - undo the copies, keep the originals
+        for path in created:
+            shutil.rmtree(path, ignore_errors=True)
+        raise MigrationError(f"could not move meetnote's data ({e}); nothing was changed") from e
+    for old, _ in pairs:
+        shutil.rmtree(old, ignore_errors=True)
+    return "Wirenote: migrated your meetnote data (settings, recordings, jobs)."

wirenote/config/perms.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Private files: recordings, transcripts, notes and logs are for their
+owner only. New files are private through umask 077; these find and fix older ones."""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from collections.abc import Iterator
+from pathlib import Path
+
+from .settings import Settings, config_dir, data_dir, state_dir
+
+def _walk(roots: list[Path]) -> Iterator[Path]:
+    for root in roots:
+        if not root.is_dir():
+            continue
+        yield root
+        for dirpath, dirnames, filenames in os.walk(root):
+            for name in dirnames + filenames:
+                yield Path(dirpath) / name
+
+
+def _loose(p: Path) -> bool:
+    st = p.lstat()
+    return not stat.S_ISLNK(st.st_mode) and bool(st.st_mode & 0o077)
+
+
+def loose_files(roots: list[Path], files: list[Path] = ()) -> list[Path]:
+    """Folders and files under roots, plus files, that group or others can access."""
+    extra = [f for f in files if f.exists() and _loose(f)]
+    return [p for p in _walk(roots) if _loose(p)] + extra
+
+
+def fix_modes(roots: list[Path], files: list[Path] = ()) -> int:
+    """Take group and other access away; returns how many changed. The owner's bits
+    (an executable script stays executable) and symlinks are left alone."""
+    changed = 0
+    for p in loose_files(roots, files):
+        os.chmod(p, stat.S_IMODE(p.lstat().st_mode) & 0o700)
+        changed += 1
+    return changed
+
+
+def private_paths(settings: Settings) -> tuple[list[Path], list[Path]]:
+    """(folders Wirenote owns, to check whole; the notes it wrote). The notes folder
+    may be a vault or ~/Documents, so only the notes recordings point to are ours."""
+    from ..process.note import own_note
+
+    rec_root = settings.recordings_path()
+    notes = []
+    for manifest in sorted(rec_root.glob("*/manifest.json")) if rec_root.is_dir() else []:
+        try:
+            note = own_note(json.loads(manifest.read_text()), settings.notes_path())
+        except (OSError, ValueError):
+            continue
+        if note:
+            notes.append(note)
+    return [config_dir(), state_dir(), data_dir(), rec_root], notes