edith-pc 0.3.0__py3-none-any.whl

edith/__init__.py

@@ -0,0 +1,13 @@
+"""EDITH — a real-time desktop voice assistant built on the OpenAI Realtime API."""
+
+import sys as _sys
+
+# EDITH prints emoji/box-drawing status lines. On Windows those crash with
+# UnicodeEncodeError when stdout is a non-UTF-8 pipe; force UTF-8 with replacement.
+for _stream in (_sys.stdout, _sys.stderr):
+    try:
+        _stream.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+__version__ = "0.3.0"

edith/audio_io.py

@@ -0,0 +1,130 @@
+"""Microphone capture and speaker playback for the Realtime stream.
+
+Design notes:
+- The Realtime API speaks PCM16 / 24 kHz / mono. We capture and play in exactly
+  that format so there is no resampling.
+- Capture runs in a sounddevice callback (a separate thread); we hand frames to the
+  asyncio loop via ``call_soon_threadsafe`` so the event loop is never blocked.
+- Playback uses a callback that drains an internal byte buffer. ``flush_playback()``
+  clears that buffer instantly — this is how barge-in works: when the user starts
+  talking, we drop whatever EDITH was about to say.
+- ``input_level`` / ``output_level`` (0..1 RMS) drive the GUI orb.
+"""
+from __future__ import annotations
+
+import asyncio
+import threading
+
+import numpy as np
+import sounddevice as sd
+
+from .config import BLOCK_FRAMES, CHANNELS, SAMPLE_RATE, SAMPLE_WIDTH
+
+
+def _rms(pcm: bytes) -> float:
+    samples = np.frombuffer(pcm, dtype=np.int16)
+    if samples.size == 0:
+        return 0.0
+    return float(np.sqrt(np.mean((samples.astype(np.float32) / 32768.0) ** 2)))
+
+
+def _rms_arr(samples: np.ndarray) -> float:
+    if samples.size == 0:
+        return 0.0
+    return float(np.sqrt(np.mean((samples.astype(np.float32) / 32768.0) ** 2)))
+
+
+class AudioIO:
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self.mic_queue: asyncio.Queue[bytes] = asyncio.Queue()
+        self._in_stream: sd.RawInputStream | None = None
+        self._out_stream: sd.RawOutputStream | None = None
+        self._play_buf = bytearray()
+        self._play_lock = threading.Lock()
+        self.muted = False
+        self.input_level = 0.0
+        self.output_level = 0.0
+        # latest int16 frames, kept for the GUI's live spectrum (read-only from GUI thread)
+        self._last_in: np.ndarray | None = None
+        self._last_out: np.ndarray | None = None
+
+    # --- microphone (input) ---------------------------------------------------
+    def _on_mic(self, indata, frames, time_info, status) -> None:  # noqa: ANN001
+        data = bytes(indata)
+        samples = np.frombuffer(data, dtype=np.int16)
+        self._last_in = samples
+        self.input_level = _rms_arr(samples)
+        if self.muted:
+            return
+        try:
+            self._loop.call_soon_threadsafe(self.mic_queue.put_nowait, data)
+        except RuntimeError:
+            pass  # event loop already closed
+
+    # --- speaker (output) -----------------------------------------------------
+    def _on_play(self, outdata, frames, time_info, status) -> None:  # noqa: ANN001
+        needed = frames * CHANNELS * SAMPLE_WIDTH
+        with self._play_lock:
+            chunk = bytes(self._play_buf[:needed])
+            del self._play_buf[:needed]
+        if len(chunk) < needed:  # underrun -> pad with silence
+            chunk += b"\x00" * (needed - len(chunk))
+        samples = np.frombuffer(chunk, dtype=np.int16)
+        self._last_out = samples
+        self.output_level = _rms_arr(samples)
+        outdata[:] = chunk
+
+    # --- live spectrum (for the GUI HUD) --------------------------------------
+    def latest_spectrum(self, bands: int = 24) -> np.ndarray:
+        """Peak-normalized voice-band FFT magnitudes (0..1) of the most active stream."""
+        src = self._last_out if self.output_level >= self.input_level else self._last_in
+        if src is None or src.size == 0:
+            return np.zeros(bands, dtype=np.float32)
+        x = src.astype(np.float32) / 32768.0
+        windowed = x * np.hanning(x.size)
+        mag = np.abs(np.fft.rfft(windowed))
+        usable = mag[: max(1, mag.size // 2)]  # lower half ~ voice energy
+        if usable.size < bands:
+            usable = np.pad(usable, (0, bands - usable.size))
+        grouped = np.array([float(g.mean()) for g in np.array_split(usable, bands)], dtype=np.float32)
+        peak = grouped.max()
+        return grouped / peak if peak > 0 else grouped
+
+    def play(self, pcm: bytes) -> None:
+        """Queue assistant audio for playback."""
+        with self._play_lock:
+            self._play_buf.extend(pcm)
+
+    def flush_playback(self) -> None:
+        """Drop all pending playback — called on barge-in to interrupt EDITH."""
+        with self._play_lock:
+            self._play_buf.clear()
+        self.output_level = 0.0
+
+    def is_speaking(self) -> bool:
+        with self._play_lock:
+            return len(self._play_buf) > 0
+
+    # --- lifecycle ------------------------------------------------------------
+    def start(self) -> None:
+        self._out_stream = sd.RawOutputStream(
+            samplerate=SAMPLE_RATE, channels=CHANNELS, dtype="int16",
+            blocksize=BLOCK_FRAMES, callback=self._on_play,
+        )
+        self._in_stream = sd.RawInputStream(
+            samplerate=SAMPLE_RATE, channels=CHANNELS, dtype="int16",
+            blocksize=BLOCK_FRAMES, callback=self._on_mic,
+        )
+        self._out_stream.start()
+        self._in_stream.start()
+
+    def stop(self) -> None:
+        for stream in (self._in_stream, self._out_stream):
+            if stream is not None:
+                try:
+                    stream.stop()
+                    stream.close()
+                except Exception:
+                    pass
+        self._in_stream = self._out_stream = None

edith/backup.py

@@ -0,0 +1,260 @@
+"""Backups of EDITH's own state: memory, notes, reminders, sign-in, spend, Google tokens.
+
+    python -m edith.backup                  # make one now (the service also does it nightly)
+    python -m edith.backup list
+    python -m edith.backup restore FILE     # stop the service first; a safety copy is made
+
+A backup is one .tar.gz in EDITH_BACKUP_DIR (default ~/.edith_backups, private to the user).
+The newest copy of each of the last 14 days, 8 weeks and 12 months is kept. The service makes
+one every night and right after a start when the newest is over a day old; a PC linked to a
+server brain fetches the newest one every day (GET /backup/latest), so a copy also lives off
+the server. Logs and ~/.edith (the wake-word model, release keys) are not included.
+"""
+from __future__ import annotations
+
+import datetime as dt
+import io
+import json
+import logging
+import os
+import socket
+import sqlite3
+import sys
+import tarfile
+import tempfile
+import threading
+import time
+from pathlib import Path, PurePosixPath
+
+_log = logging.getLogger("edith.backup")
+
+FILES = (
+    ".edith_memory.json", ".edith_reminders.sqlite", ".edith_briefing.json",
+    ".edith_google_credentials.json", ".edith_google_token.json", ".edith_totp.json",
+    ".edith_web_sessions.json", ".edith_spend.json", ".edith_audit.jsonl", ".edith_service_token",
+    ".edith_devices.json",
+)
+DIRS = ("edith_notes",)
+KEEP_DAILY, KEEP_WEEKLY, KEEP_MONTHLY = 14, 8, 12
+PREFIX, SUFFIX = "edith-backup-", ".tar.gz"
+_STAMP = "%Y-%m-%dT%H%M%SZ"
+
+
+def backup_dir() -> Path:
+    configured = (os.getenv("EDITH_BACKUP_DIR") or "").strip()
+    return Path(configured).expanduser() if configured else Path.home() / ".edith_backups"
+
+
+def _private_dir(path: Path) -> Path:
+    path.mkdir(parents=True, exist_ok=True)
+    try:
+        os.chmod(path, 0o700)
+    except OSError:
+        pass
+    return path
+
+
+def _sqlite_copy(path: Path) -> bytes:
+    """A consistent copy of a database that may be in use (SQLite's own backup API)."""
+    fd, tmp = tempfile.mkstemp(suffix=".sqlite")
+    os.close(fd)
+    try:
+        src = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
+        dst = sqlite3.connect(tmp)
+        with dst:
+            src.backup(dst)
+        src.close()
+        dst.close()
+        return Path(tmp).read_bytes()
+    finally:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+
+
+def _add_bytes(tar: tarfile.TarFile, name: str, data: bytes, mtime: float) -> None:
+    info = tarfile.TarInfo(name)
+    info.size, info.mtime, info.mode = len(data), int(mtime), 0o600
+    tar.addfile(info, io.BytesIO(data))
+
+
+def make_backup(home: Path | None = None, dest: Path | None = None,
+                now: dt.datetime | None = None) -> Path:
+    """Write one backup of EDITH's state under ``home`` into ``dest``; returns its path."""
+    home = home or Path.home()
+    dest = _private_dir(dest or backup_dir())
+    now = now or dt.datetime.now(dt.timezone.utc)
+    name = f"{PREFIX}{now.strftime(_STAMP)}{SUFFIX}"
+    part = dest / (name + ".part")
+    included = []
+    with tarfile.open(part, "w:gz") as tar:
+        for f in FILES:
+            p = home / f
+            if not p.is_file():
+                continue
+            try:
+                if p.suffix == ".sqlite":
+                    _add_bytes(tar, f, _sqlite_copy(p), p.stat().st_mtime)
+                else:
+                    tar.add(str(p), arcname=f, recursive=False)
+                included.append(f)
+            except (OSError, sqlite3.Error) as exc:
+                _log.warning("backup: skipped %s: %s", f, exc)
+        for d in DIRS:
+            root = home / d
+            if not root.is_dir():
+                continue
+            for q in sorted(root.rglob("*")):
+                if q.is_file() and not q.is_symlink():
+                    arc = str(PurePosixPath(d, *q.relative_to(root).parts))
+                    tar.add(str(q), arcname=arc, recursive=False)
+                    included.append(arc)
+        manifest = {"made": now.isoformat(), "host": socket.gethostname(), "files": included}
+        _add_bytes(tar, "MANIFEST.json", json.dumps(manifest, indent=1).encode(), now.timestamp())
+    try:
+        os.chmod(part, 0o600)
+    except OSError:
+        pass
+    final = dest / name
+    part.replace(final)
+    prune(dest)
+    _log.info("backup: %s (%d items, %d bytes)", final.name, len(included), final.stat().st_size)
+    return final
+
+
+def backups(dest: Path | None = None) -> list[tuple[dt.datetime, Path]]:
+    """Every backup in ``dest``, newest first."""
+    dest = dest or backup_dir()
+    out = []
+    if dest.is_dir():
+        for p in dest.glob(f"{PREFIX}*{SUFFIX}"):
+            try:
+                t = dt.datetime.strptime(p.name[len(PREFIX):-len(SUFFIX)], _STAMP).replace(tzinfo=dt.timezone.utc)
+            except ValueError:
+                continue
+            out.append((t, p))
+    return sorted(out, key=lambda x: x[0], reverse=True)
+
+
+def latest(dest: Path | None = None) -> Path | None:
+    found = backups(dest)
+    return found[0][1] if found else None
+
+
+def prune(dest: Path | None = None) -> list[Path]:
+    """Keep the newest backup of each of the last 14 days, 8 weeks and 12 months."""
+    items = backups(dest)
+    keep: set[Path] = set()
+
+    def pick(key, n):
+        seen = []
+        for t, p in items:
+            k = key(t)
+            if k in seen:
+                continue
+            seen.append(k)
+            keep.add(p)
+            if len(seen) >= n:
+                break
+
+    pick(lambda t: t.date(), KEEP_DAILY)
+    pick(lambda t: tuple(t.isocalendar())[:2], KEEP_WEEKLY)
+    pick(lambda t: (t.year, t.month), KEEP_MONTHLY)
+    removed = []
+    for _, p in items:
+        if p not in keep:
+            try:
+                p.unlink()
+                removed.append(p)
+            except OSError:
+                pass
+    return removed
+
+
+def _allowed(name: str) -> bool:
+    parts = PurePosixPath(name).parts
+    if not parts or name.startswith("/") or ".." in parts or "\\" in name:
+        return False
+    return (len(parts) == 1 and parts[0] in FILES) or (len(parts) > 1 and parts[0] in DIRS)
+
+
+def restore(archive: Path, home: Path | None = None, dest: Path | None = None) -> list[str]:
+    """Put a backup's files back into ``home``. A backup of the current state is made first.
+    Only EDITH's own files are written; anything else in the archive is ignored."""
+    home = home or Path.home()
+    make_backup(home, dest)   # the state being replaced, in case this was the wrong file
+    written = []
+    with tarfile.open(archive, "r:gz") as tar:
+        for m in tar.getmembers():
+            if not m.isfile() or not _allowed(m.name):
+                continue
+            target = home.joinpath(*PurePosixPath(m.name).parts)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            src = tar.extractfile(m)
+            if src is None:
+                continue
+            tmp = target.with_name(target.name + ".restore")
+            tmp.write_bytes(src.read())
+            tmp.replace(target)
+            written.append(m.name)
+    return written
+
+
+def start_nightly(hour: int | None = None, extra=()) -> threading.Thread:
+    """A daemon thread that backs up every night at ``hour`` (local time, default 21:00 or
+    EDITH_BACKUP_HOUR), and once soon after start when the newest backup is over a day old."""
+    if hour is None:
+        try:
+            hour = int(os.getenv("EDITH_BACKUP_HOUR", "21"))
+        except ValueError:
+            hour = 21
+
+    def run_once() -> None:
+        try:
+            make_backup()
+        except Exception as exc:   # a failed backup must never take the service down
+            _log.warning("backup failed: %s", exc)
+        for job in extra:   # e.g. the vault's sweep
+            try:
+                job()
+            except Exception as exc:
+                _log.warning("nightly job failed: %s", exc)
+
+    def loop() -> None:
+        time.sleep(600)   # let a fresh start settle first
+        newest = backups()
+        if not newest or (dt.datetime.now(dt.timezone.utc) - newest[0][0]).total_seconds() > 86400:
+            run_once()
+        while True:
+            now = dt.datetime.now()
+            nxt = now.replace(hour=hour % 24, minute=0, second=0, microsecond=0)
+            if nxt <= now:
+                nxt += dt.timedelta(days=1)
+            time.sleep(max(60.0, (nxt - now).total_seconds()))
+            run_once()
+
+    t = threading.Thread(target=loop, name="edith-backup", daemon=True)
+    t.start()
+    return t
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    cmd = args[0] if args else "now"
+    if cmd == "now":
+        print(make_backup())
+    elif cmd == "list":
+        for t, p in backups():
+            print(f"{t:%Y-%m-%d %H:%M} UTC  {p.stat().st_size:>9} bytes  {p}")
+    elif cmd == "restore" and len(args) == 2:
+        for name in restore(Path(args[1])):
+            print("restored", name)
+    else:
+        print(__doc__)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

edith/body/__init__.py

@@ -0,0 +1,17 @@
+"""edith.body — this PC as a body of the server brain.
+
+    python -m edith.body
+
+Connects out to the EDITH server (EDITH_SERVER_URL) with the pairing token, announces the
+PC's tools, and runs the ones the brain asks for: apps, windows, files, the screen, the
+keyboard, the shell, the computer agent. The brain, the memory and the budget live on the
+server; the phone and the browser HUD reach this PC through it from anywhere.
+
+No OpenAI key is needed here. Tools that call a model (see_screen, read_document,
+delegate_task, the computer agent) do so through the server: the OpenAI client is pointed at
+``EDITH_SERVER_URL/v1`` with the pairing token as its key, and the server forwards the call
+with its own key and meters the spend against the one daily budget.
+
+The PC brain mode (``python -m edith.service`` on the PC, reached over the LAN or the relay)
+still exists for a PC that should work without the server.
+"""

edith/body/__main__.py

@@ -0,0 +1,116 @@
+"""Run this PC as a body of the server brain:
+
+    python -m edith.body            link and serve
+    python -m edith.body link       link this PC with a code from Google Authenticator
+    python -m edith.body unlink     forget that link (the server drops this PC's key)
+    python -m edith.body status     what this PC is linked to
+
+Two ways to be linked. The PC EDITH was set up on has EDITH_SERVER_URL and the pairing token
+(EDITH_SERVICE_TOKEN, or ~/.edith_service_token) in .env. Any other PC links with a code
+instead (`link`, or the EDITH app from the installer): it gets a key of its own, kept in
+~/.edith_body.json. No OpenAI key is needed on either.
+"""
+from __future__ import annotations
+
+import asyncio
+import getpass
+import logging
+import sys
+from pathlib import Path
+
+from ..config import settings
+from ..legacy_migration import migrate
+from ..logging_setup import ensure_streams, setup_logging
+from . import link as linking
+from .client import Body, pairing_token, pc_tool_names, point_model_calls_at_server
+
+_log = logging.getLogger("edith.body")
+
+
+def credentials() -> tuple[str, str, str]:
+    """(server, key, how): EDITH_SERVER_URL with the pairing token ("token"), else the link
+    this PC made with a code ("code"), else ("", "", "")."""
+    server = (getattr(settings, "server_url", None) or "").strip().rstrip("/")
+    token = pairing_token(settings)
+    if server and token:
+        return server, token, "token"
+    cfg = linking.load()
+    if linking.linked(cfg):
+        return str(cfg["server"]), str(cfg["token"]), "code"
+    return "", "", ""
+
+
+def _cli(command: str) -> int:
+    cfg = linking.load()
+    if command == "status":
+        server, _, how = credentials()
+        if not server:
+            print("This PC is not linked. Link it: python -m edith.body link")
+        elif how == "token":
+            print(f"Linked to {server} with the pairing token (.env).")
+        else:
+            print(f"Linked to {server} as {cfg.get('device_id')} with its own key (~/.edith_body.json).")
+        return 0
+    if command == "unlink":
+        if not linking.linked(cfg):
+            print("This PC has no code-made link to forget.")
+            return 0
+        dropped = linking.unlink()
+        print("Unlinked." + ("" if dropped else " The server couldn't be told: remove this PC in the HUD (Bodies)."))
+        return 0
+    # link
+    default = str(cfg.get("server") or getattr(settings, "server_url", None) or "")
+    try:
+        server = input(f"EDITH server [{default}]: " if default else "EDITH server (e.g. edith.example.com): ").strip() or default
+        code = getpass.getpass("Code from Google Authenticator (6 digits, hidden): ")
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return 1
+    try:
+        made = linking.link(server, code)
+    except linking.LinkError as exc:
+        print(f"❌ {exc}")
+        return 1
+    print(f"✅ Linked to {made['server']} as {made['device_id']}. Start the body: python -m edith.body")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if argv is None else argv
+    ensure_streams(Path.home() / ".edith_body.out.log")
+    migrate()
+    setup_logging()
+    if argv and argv[0] in ("link", "unlink", "status"):
+        return _cli(argv[0])
+    if argv:
+        print(__doc__)
+        return 2
+    server, key, how = credentials()
+    if not server:
+        print("❌ This PC is not linked to an EDITH server. Link it with a code from Google Authenticator:\n"
+              "     python -m edith.body link\n"
+              "   (or, on the PC EDITH was set up on, put EDITH_SERVER_URL and the pairing token in .env)")
+        return 1
+    point_model_calls_at_server(server, key)
+    print(
+        "\n  EDITH body — this PC, linked to the server brain\n"
+        f"  server:   {server} ({'pairing token' if how == 'token' else 'its own key, linked with a code'})\n"
+        f"  offering: {len(pc_tool_names())} PC tools (model calls go through the server)\n"
+        "  Ctrl+C to stop.\n"
+    )
+    _log.info("body starting for %s with %d tools (%s)", server, len(pc_tool_names()), how)
+    # Only the PC on the pairing token keeps a daily copy of the server's own backup (it holds
+    # the sign-in secrets; a PC's key can't fetch it). Every PC backs its folders up into the
+    # vault once the HUD switches them on (Bodies > PCs).
+    copies = Path.home() / "EDITH-backups" / "server" if how == "token" else None
+    body = Body(server, key, backup_dir=copies, pc_backup=True,
+                on_unlinked=(lambda: linking.forget(token=key)) if how == "code" else None)
+    try:
+        asyncio.run(body.run_forever())
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())