voxa-code 0.1.0__py3-none-any.whl

server/transcript_monitor.py

@@ -0,0 +1,134 @@
+"""Screen-independent Claude status detection from its own transcript JSONL.
+
+For terminals whose screen we cannot capture (GPU terminals behind the ax
+backend), the transcript under ~/.claude/projects/<encoded-cwd>/ is the source
+of truth: growing file means working; quiet file ending in an assistant text
+message means done; quiet file ending mid tool-call means Claude is likely
+waiting on something (permission prompts never reach the transcript, so this
+is a heuristic).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import os
+import time
+from typing import Optional
+
+from .transcripts import PROJECTS_DIR, latest_transcript, _text_of
+from .tmux_controller import FinalCallback
+
+
+def _last_entry(path: str) -> Optional[dict]:
+    last = None
+    try:
+        with open(path) as f:
+            for line in f:
+                try:
+                    o = json.loads(line)
+                except ValueError:
+                    continue
+                if o.get("type") in ("user", "assistant"):
+                    last = o
+    except OSError:
+        return None
+    return last
+
+
+def transcript_state(path: str, quiet_secs: float = 5.0,
+                     now: float | None = None) -> tuple[str, str]:
+    """Classify a transcript: ("working"|"done"|"needs_input"|"none", text)."""
+    try:
+        mtime = os.path.getmtime(path)
+    except OSError:
+        return "none", ""
+    if (now or time.time()) - mtime < quiet_secs:
+        return "working", ""
+    o = _last_entry(path)
+    if o is None:
+        return "none", ""
+    m = o.get("message") or {}
+    if o.get("type") == "assistant":
+        content = m.get("content")
+        blocks = content if isinstance(content, list) else []
+        has_text = isinstance(content, str) or any(
+            isinstance(b, dict) and b.get("type") == "text" and b.get("text")
+            for b in blocks)
+        if has_text:
+            return "done", _text_of(content).strip()
+        return "needs_input", "Claude stopped mid tool call"
+    return "needs_input", _text_of(m.get("content")).strip()[:200]
+
+
+class TranscriptMonitor:
+    """Same emit contract as the screen monitors: after the session has WORKED
+    (mtime advanced since attach) and then gone quiet, fire on_final once."""
+
+    def __init__(self, cwd: str, on_final: Optional[FinalCallback] = None, *,
+                 poll_interval: float = 2.0, quiet_secs: float = 5.0,
+                 projects_dir: str = PROJECTS_DIR):
+        self._cwd = cwd
+        self._final_cb = on_final
+        self._poll = poll_interval
+        self._quiet = quiet_secs
+        self._projects = projects_dir
+        self.status = "idle"
+        self.working_dir: Optional[str] = cwd
+        self._started = False
+        self._task: Optional[asyncio.Task] = None
+
+    def on_final(self, cb: FinalCallback) -> None:
+        self._final_cb = cb
+
+    async def _emit(self, text: str) -> None:
+        if text.strip() and self._final_cb is not None:
+            result = self._final_cb(text)
+            if inspect.isawaitable(result):
+                await result
+
+    async def run(self) -> None:
+        self._started = True
+        path = latest_transcript(self._cwd, self._projects)
+        baseline = 0.0
+        if path:
+            try:
+                baseline = os.path.getmtime(path)
+            except OSError:
+                baseline = 0.0
+        saw_work = False
+        while self._started:
+            await asyncio.sleep(self._poll)
+            path = latest_transcript(self._cwd, self._projects)
+            if not path:
+                continue
+            kind, text = transcript_state(path, self._quiet)
+            try:
+                mtime = os.path.getmtime(path)
+            except OSError:
+                continue
+            if mtime > baseline:
+                baseline = mtime
+                saw_work = True
+                self.status = "working"
+                continue
+            if saw_work and kind in ("done", "needs_input"):
+                saw_work = False
+                self.status = "idle"
+                prefix = "needs input: " if kind == "needs_input" else ""
+                await self._emit(prefix + text if text else prefix.strip())
+
+    async def start(self, working_dir: Optional[str] = None) -> None:
+        if working_dir:
+            self.working_dir = working_dir
+            self._cwd = working_dir
+        if self._task and not self._task.done():
+            self._task.cancel()
+        self._task = asyncio.ensure_future(self.run())
+
+    async def stop(self, *, detach_only: bool = False) -> None:
+        self._started = False
+        if self._task and not self._task.done():
+            self._task.cancel()
+        self.status = "idle"

server/transcripts.py

@@ -0,0 +1,143 @@
+"""Recap what a terminal was working on by reading Claude Code's own transcript.
+
+Claude Code logs each session to ``~/.claude/projects/<encoded-cwd>/<session>.jsonl``
+where the cwd has ``/`` and ``.`` replaced by ``-``. Discovery already knows each
+open terminal's cwd, so on attach we read the newest transcript for that cwd and
+build a short recap of the recent conversation, instead of scraping the screen.
+"""
+
+from __future__ import annotations
+
+import glob
+import json
+import os
+import re
+
+PROJECTS_DIR = os.path.expanduser("~/.claude/projects")
+
+
+def _encode(cwd: str) -> str:
+    return re.sub(r"[/.]", "-", cwd)
+
+
+def latest_transcript(cwd: str, projects_dir: str = PROJECTS_DIR) -> str | None:
+    if not cwd:
+        return None
+    d = os.path.join(projects_dir, _encode(cwd))
+    files = glob.glob(os.path.join(d, "*.jsonl")) if os.path.isdir(d) else []
+    if not files:
+        return None
+    return max(files, key=os.path.getmtime)
+
+
+def _text_of(content) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for b in content:
+            if isinstance(b, dict):
+                if b.get("type") == "text" and b.get("text"):
+                    parts.append(b["text"])
+                elif b.get("type") == "tool_use" and b.get("name"):
+                    parts.append(f"[used {b['name']}]")
+        return " ".join(parts)
+    return ""
+
+
+def recap(cwd: str, max_msgs: int = 25, max_chars: int = 500,
+          projects_dir: str = PROJECTS_DIR) -> str:
+    """Return a short text recap of the most recent conversation in ``cwd``'s
+    Claude session, or "" if there is no transcript."""
+    path = latest_transcript(cwd, projects_dir)
+    if not path:
+        return ""
+    msgs: list[tuple[str, str]] = []
+    try:
+        with open(path) as f:
+            for line in f:
+                try:
+                    o = json.loads(line)
+                except ValueError:
+                    continue
+                if o.get("type") not in ("user", "assistant"):
+                    continue
+                m = o.get("message") or {}
+                role = m.get("role") or o.get("type")
+                text = _text_of(m.get("content")).strip()
+                if text:
+                    msgs.append((role, text))
+    except OSError:
+        return ""
+    if not msgs:
+        return ""
+    lines = []
+    for role, text in msgs[-max_msgs:]:
+        if len(text) > max_chars:
+            text = text[:max_chars] + "…"
+        who = "You" if role == "user" else "Claude"
+        lines.append(f"{who}: {text}")
+    opener = next((t for r, t in msgs if r == "user"), "")
+    if opener:
+        if len(opener) > max_chars:
+            opener = opener[:max_chars] + "…"
+        lines.insert(0, f"This session started with: {opener}")
+    return "\n".join(lines)
+
+
+def _collect_messages(path: str) -> list[dict]:
+    msgs: list[dict] = []
+    try:
+        with open(path) as f:
+            for line in f:
+                try:
+                    o = json.loads(line)
+                except ValueError:
+                    continue
+                if o.get("type") not in ("user", "assistant"):
+                    continue
+                m = o.get("message") or {}
+                text = _text_of(m.get("content")).strip()
+                if text:
+                    msgs.append({"role": m.get("role") or o.get("type"),
+                                 "text": text})
+    except OSError:
+        return []
+    return msgs
+
+
+def read_session(cwd: str, last: int | None = None, search: str | None = None,
+                 projects_dir: str = PROJECTS_DIR,
+                 max_bytes: int = 6000) -> dict:
+    """On-demand deep read of the newest transcript for ``cwd``: the voice
+    agent's read_session tool. Returns {"messages": [{"role","text"}...]}."""
+    path = latest_transcript(cwd, projects_dir)
+    if not path:
+        return {"error": f"no Claude transcript found for {cwd or '(no cwd)'}"}
+    msgs = _collect_messages(path)
+    if search:
+        picked: list[int] = []
+        hits = 0
+        for i, m in enumerate(msgs):
+            if search.lower() in m["text"].lower():
+                hits += 1
+                for j in (i - 1, i, i + 1):          # hit plus one neighbour each side
+                    if 0 <= j < len(msgs) and j not in picked:
+                        picked.append(j)
+                if hits >= 10:
+                    break
+        out = [msgs[i] for i in sorted(picked)]
+    else:
+        n = min(int(last or 10), 40)
+        out = msgs[-n:]
+    # Cap the payload: trim message texts evenly until the JSON fits, accounting
+    # for the per-entry JSON overhead (keys, quotes, commas), not just the text.
+    if not out:
+        return {"messages": []}
+    overhead = len(json.dumps({"role": "assistant", "text": ""}).encode()) + 2
+    per = max(50, (max_bytes - overhead * len(out)) // len(out))
+    result = [{"role": m["role"], "text": m["text"][:per]} for m in out]
+    # Safety net for any remaining overshoot (e.g. multi-byte unicode text).
+    while result and len(json.dumps({"messages": result}).encode()) > max_bytes:
+        result.pop()
+    return {"messages": result}

server/users.py

@@ -0,0 +1,90 @@
+"""Voxa user accounts + session tokens (Sign in with Apple).
+
+JSON-backed (like Billing/DeviceRegistry). A user is keyed by Apple's stable
+per-user id (`apple_sub`) and assigned a stable Voxa `user_id` (uuid4 hex) that
+becomes the billing account. Session tokens are signed JWTs the app stores and
+sends as a Bearer header.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+import uuid
+
+import jwt  # PyJWT
+
+TOKEN_TTL_SECONDS = 365 * 24 * 3600  # 1 year; no refresh tokens in v1.
+
+
+class UserStore:
+    def __init__(self, path: str = "users.json"):
+        self._path = path
+        self._lock = threading.Lock()
+        self._data: dict = self._load()
+
+    def _load(self) -> dict:
+        try:
+            with open(self._path) as f:
+                return json.load(f)
+        except (OSError, ValueError):
+            return {}
+
+    def _save(self) -> None:
+        tmp = f"{self._path}.tmp"
+        with open(tmp, "w") as f:
+            json.dump(self._data, f)
+        os.replace(tmp, self._path)
+
+    def find_or_create_apple_user(self, apple_sub: str, email: str | None = None) -> str:
+        """Return the stable user_id for an Apple sub, creating it on first sign-in.
+        Stores email only when provided (Apple returns it on the first authorization
+        only) and never overwrites a stored email with None."""
+        with self._lock:
+            users = self._data.setdefault("users", {})
+            by_apple = self._data.setdefault("by_apple", {})
+            uid = by_apple.get(apple_sub)
+            if uid is None:
+                uid = uuid.uuid4().hex
+                by_apple[apple_sub] = uid
+                users[uid] = {"apple_sub": apple_sub, "email": email,
+                              "created_at": int(time.time())}
+            elif email and not users[uid].get("email"):
+                users[uid]["email"] = email
+            self._save()
+            return uid
+
+    def get_user(self, user_id: str) -> dict | None:
+        with self._lock:
+            u = self._data.get("users", {}).get(user_id)
+            return dict(u) if u else None
+
+    def delete_user(self, user_id: str) -> bool:
+        """Permanently remove a user and its Apple-sub mapping (account deletion,
+        App Review Guideline 5.1.1(v)). Returns True if a user was removed."""
+        with self._lock:
+            users = self._data.setdefault("users", {})
+            u = users.pop(user_id, None)
+            if u is None:
+                return False
+            by_apple = self._data.setdefault("by_apple", {})
+            for sub, uid in list(by_apple.items()):
+                if uid == user_id:
+                    del by_apple[sub]
+            self._save()
+            return True
+
+
+def issue_token(user_id: str, secret: str, now: int | None = None) -> str:
+    now = int(time.time()) if now is None else now
+    return jwt.encode({"sub": user_id, "iat": now, "exp": now + TOKEN_TTL_SECONDS},
+                      secret, algorithm="HS256")
+
+
+def verify_token(token: str, secret: str) -> str | None:
+    try:
+        return jwt.decode(token, secret, algorithms=["HS256"]).get("sub")
+    except Exception:
+        return None

server/voxa_cloud.py

@@ -0,0 +1,132 @@
+"""Voxa Cloud — the single service YOU host.
+
+Combines everything central into one deployable app:
+  - relay        (/agent, /ws)            : pairs phone <-> laptop, no Tailscale
+  - billing      (/billing/balance, /purchase) + metered V2V proxy (/live)
+  - push/CallKit (/register, /unregister, /call/decline)
+
+Run it:
+    uvicorn server.voxa_cloud:create_app --factory --host 0.0.0.0 --port 8080
+
+Your keys (GEMINI_API_KEY, APNS_*) live here, never on customers' laptops.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from fastapi import FastAPI, Request
+
+from server.appstore import verify_transaction
+from server.cloud_app import add_billing_routes
+from server.device_registry import DeviceRegistry
+from server.call_manager import CallManager
+from server.push_routes import add_push_routes
+from server.relay import add_relay_routes
+
+
+def create_app(billing=None, verifier=verify_transaction, operator_factory=None,
+               registry=None, call_manager=None, users=None,
+               apple_verifier=None) -> FastAPI:
+    import os
+
+    from dotenv import load_dotenv
+    from server.config import load_config
+
+    load_dotenv()
+    config = load_config()  # needs GEMINI_API_KEY (yours) + VOXA_AUTH_TOKEN
+
+    app = FastAPI(title="Voxa Cloud")
+
+    # Reject oversized request bodies early (memory-DoS guard). Generous cap: every
+    # real request here (auth, purchase JWS, waitlist, hook) is a few KB; the
+    # metered /live is a WebSocket and is unaffected.
+    from starlette.middleware.base import BaseHTTPMiddleware
+    from starlette.responses import JSONResponse as _JSONResponse
+    _MAX_BODY = 1_000_000  # 1 MB
+
+    class _BodyLimit(BaseHTTPMiddleware):
+        async def dispatch(self, request, call_next):
+            cl = request.headers.get("content-length")
+            if cl and cl.isdigit() and int(cl) > _MAX_BODY:
+                return _JSONResponse({"error": "payload too large"}, status_code=413)
+            return await call_next(request)
+
+    app.add_middleware(_BodyLimit)
+
+    # Browsers on the marketing site call /waitlist cross-origin; allow only
+    # voxa.space. Other routes are hit by the iOS app (no Origin), so this is a
+    # no-op for them.
+    from fastapi.middleware.cors import CORSMiddleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["https://voxa.space", "https://www.voxa.space"],
+        allow_methods=["GET", "POST", "OPTIONS"],
+        allow_headers=["Content-Type"],
+    )
+
+    @app.get("/healthz")
+    async def healthz():
+        return {"ok": True}
+
+    auth_secret = os.environ.get("VOXA_AUTH_SECRET", "").strip()
+    if not auth_secret:
+        raise ValueError("VOXA_AUTH_SECRET is required (HS256 session-token secret)")
+    # A weak session-signing secret lets anyone forge account tokens. Refuse to
+    # start on an obviously-weak secret; warn on a merely-short one. Use >= 32 random
+    # chars (e.g. `python -c "import secrets;print(secrets.token_hex(32))"`).
+    if len(auth_secret) < 16:
+        raise ValueError("VOXA_AUTH_SECRET is too weak; use at least 32 random characters")
+    if len(auth_secret) < 32:
+        logging.warning("VOXA_AUTH_SECRET is short (<32 chars); use a longer random secret")
+    apple_bundle = (os.environ.get("VOXA_APPLE_BUNDLE_ID")
+                    or os.environ.get("APNS_BUNDLE_ID") or "space.voxa.app")
+
+    # Billing + metered V2V proxy (uses your GEMINI_API_KEY).
+    add_billing_routes(app, billing=billing, verifier=verifier,
+                       operator_factory=operator_factory, auth_secret=auth_secret)
+
+    # Sign in with Apple: user accounts + session tokens.
+    from server.auth import add_auth_routes, verify_apple_identity_token
+    from server.users import UserStore
+    users = users or UserStore(os.environ.get("VOXA_USERS_FILE", "users.json"))
+    add_auth_routes(app, users, secret=auth_secret, bundle_id=apple_bundle,
+                    apple_verifier=apple_verifier or verify_apple_identity_token,
+                    billing=billing)
+    app.state.users = users
+
+    # Relay: phone <-> laptop by pairing code.
+    add_relay_routes(app)
+
+    # Push / CallKit (your APNs key stays here).
+    registry = registry or DeviceRegistry(os.environ.get("VOXA_DEVICES_FILE", "devices.json"))
+    if call_manager is None:
+        if config.push_enabled:
+            from server.apns import ApnsClient
+            pusher = ApnsClient(config)
+        else:
+            class _NoPush:
+                async def send_voip(self, *a, **k):
+                    logging.warning("push disabled; dropping call %r", a)
+                    return False
+            pusher = _NoPush()
+        call_manager = CallManager(pusher, registry)
+    app.state.registry = registry
+    app.state.call_manager = call_manager
+
+    def auth_check(request: Request):
+        return request.query_params.get("token") == config.auth_token
+
+    add_push_routes(app, registry, call_manager, auth_check)
+
+    # Marketing-site waitlist: append signups to a durable JSONL; GET is gated
+    # by the same VOXA_AUTH_TOKEN admin secret. If RESEND_API_KEY +
+    # WAITLIST_NOTIFY_EMAIL are set, each new signup also emails a heads-up.
+    from server.waitlist import WaitlistStore, ResendNotifier, add_waitlist_routes
+    waitlist = WaitlistStore(os.environ.get("VOXA_WAITLIST_FILE", "waitlist.jsonl"))
+    notifier = ResendNotifier(
+        api_key=os.environ.get("RESEND_API_KEY", ""),
+        to_email=os.environ.get("WAITLIST_NOTIFY_EMAIL", ""),
+    )
+    add_waitlist_routes(app, waitlist, admin_token=config.auth_token, notifier=notifier)
+    return app

server/waitlist.py

@@ -0,0 +1,130 @@
+"""Waitlist signups for the marketing site (voxa.space).
+
+The static site POSTs an email here; we append it to a JSONL file in the
+service's working dir (durable on the Oracle box, alongside users.json /
+devices.json). A token-gated GET dumps the list so you can read who joined.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+from pathlib import Path
+
+import httpx
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+_EMAIL_RE = re.compile(r"^[^\s@]+@[^\s@]+\.[^\s@]+$")
+
+
+def valid_email(email: str) -> bool:
+    email = (email or "").strip()
+    return 0 < len(email) <= 320 and bool(_EMAIL_RE.match(email))
+
+
+class WaitlistStore:
+    """Append-only JSONL of signups, deduped by lowercased email."""
+
+    def __init__(self, path: str):
+        self._path = Path(path)
+
+    def emails(self) -> list[str]:
+        if not self._path.exists():
+            return []
+        out: list[str] = []
+        for line in self._path.read_text().splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                out.append(json.loads(line)["email"])
+            except (json.JSONDecodeError, KeyError):
+                continue
+        return out
+
+    def add(self, email: str, *, source: str = "", now: float | None = None) -> bool:
+        """Record an email. Returns True if newly added, False if a duplicate."""
+        email = email.strip().lower()
+        if email in set(self.emails()):
+            return False
+        rec = {
+            "email": email,
+            "ts": time.time() if now is None else now,
+            "source": source,
+        }
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        with self._path.open("a") as f:
+            f.write(json.dumps(rec) + "\n")
+        return True
+
+
+def build_signup_email(email: str, to_email: str,
+                       from_email: str = "Voxa <onboarding@resend.dev>",
+                       count: int | None = None) -> dict:
+    lines = [f"{email} just joined the Voxa waitlist."]
+    if count is not None:
+        lines.append(f"\nTotal signups so far: {count}.")
+    return {
+        "from": from_email,
+        "to": [to_email],
+        "subject": f"New Voxa waitlist signup: {email}",
+        "text": "\n".join(lines),
+    }
+
+
+class ResendNotifier:
+    """Best-effort 'new signup' email via Resend's HTTP API. A no-op unless
+    both api_key and to_email are set, so it's safe to wire in before configured."""
+
+    def __init__(self, api_key: str = "", to_email: str = "",
+                 from_email: str = "Voxa <onboarding@resend.dev>"):
+        self.api_key = (api_key or "").strip()
+        self.to_email = (to_email or "").strip()
+        self.from_email = from_email
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.api_key and self.to_email)
+
+    async def notify(self, email: str, count: int | None = None) -> bool:
+        if not self.enabled:
+            return False
+        payload = build_signup_email(email, self.to_email, self.from_email, count)
+        async with httpx.AsyncClient(timeout=10) as client:
+            resp = await client.post(
+                "https://api.resend.com/emails",
+                headers={"Authorization": f"Bearer {self.api_key}",
+                         "Content-Type": "application/json"},
+                content=json.dumps(payload),
+            )
+        return resp.status_code < 300
+
+
+def add_waitlist_routes(app, store: WaitlistStore, admin_token: str = "",
+                        notifier=None) -> None:
+    @app.post("/waitlist")
+    async def join_waitlist(request: Request):
+        body = await request.json() or {}
+        email = body.get("email", "")
+        if not valid_email(email):
+            return JSONResponse({"ok": False, "reason": "invalid"}, status_code=400)
+        # Bound the client-supplied source so a caller can't write huge values into
+        # the durable JSONL (disk-fill vector); it is untrusted free text.
+        source = str(body.get("source") or "marketing-site")[:64]
+        added = store.add(email, source=source)
+        if added and notifier is not None:
+            try:
+                await notifier.notify(email.strip().lower(), count=len(store.emails()))
+            except Exception:
+                logging.warning("waitlist notify failed", exc_info=True)
+        return {"ok": True}
+
+    @app.get("/waitlist")
+    async def list_waitlist(request: Request):
+        if not admin_token or request.query_params.get("token") != admin_token:
+            return JSONResponse({"ok": False, "reason": "forbidden"}, status_code=403)
+        emails = store.emails()
+        return {"ok": True, "count": len(emails), "emails": emails}