#!/usr/bin/env python3 """routine-server: the relay that keeps the desktop and R1 routine apps in step, on a machine of your own that both can reach (a home server, a VPN address). Standard library only, and model.py beside it (scripts/deploy-server.sh copies both). Every request but /health needs "Authorization: Bearer " (made on first start in /token, mode 600). It speaks plain HTTP: bind it to an address only your devices reach (a private network or VPN), not the open internet. GET /health -> {"ok": true} POST /sync {"since": , "days": [, ...], "schedule_rev": n, "schedule": {...}?, "streaks": {...}?, "streaks_t": t?} -> {"seq": , "days": [], "schedule": {...}?, "streaks": {...}?, "streaks_t": t?} The routine itself rides along: a client may send its schedule (the desktop does after an edit); the server keeps the highest rev and hands it to any client whose schedule_rev is lower. The streak base rides the same way (model.streak_base plus "t" and the desktop's streak settings): the desktop sends it, the server keeps the one with the highest "t" and answers every sync with that t as "streaks_t" (the desktop's receipt); a client that sends "streaks_t" (the R1) gets the base back whenever the server's is newer. Clients that send neither (older apps) never see it, and older servers ignore both: the R1 then counts from its own days. A pushed day is merged into the stored copy with model.merge (last writer wins per item and for the note), and gets a new seq only if the merge changed it. A client keeps the returned seq and sends it as since next time; since > the server's seq (a fresh server) means "all". The server is a relay, not the record: days older than KEEP_DAYS are dropped; the desktop keeps everything. python3 routine_server.py --host ADDRESS --port 8070 --data DIR """ import argparse import datetime as dt import json import os import secrets import sqlite3 import sys import threading from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import model # noqa: E402 (deployed beside this file) KEEP_DAYS = 60 MAX_BODY = 4 * 1024 * 1024 LOCK = threading.Lock() class Store: def __init__(self, path): self.db = sqlite3.connect(path, check_same_thread=False) self.db.execute("CREATE TABLE IF NOT EXISTS days (date TEXT PRIMARY KEY, doc TEXT NOT NULL, seq INTEGER NOT NULL)") self.db.execute("CREATE TABLE IF NOT EXISTS meta (k TEXT PRIMARY KEY, v TEXT NOT NULL)") self.db.commit() def seq(self): return self.db.execute("SELECT COALESCE(MAX(seq), 0) FROM days").fetchone()[0] def sync(self, since, pushed, schedule=None, schedule_rev=0, streaks=None, streaks_t=None): with LOCK: row = self.db.execute("SELECT v FROM meta WHERE k = 'streaks'").fetchone() base = json.loads(row[0]) if row else None if valid_streaks(streaks) and (base is None or streaks["t"] > base.get("t", 0)): base = streaks self.db.execute("INSERT OR REPLACE INTO meta (k, v) VALUES ('streaks', ?)", (json.dumps(base),)) row = self.db.execute("SELECT v FROM meta WHERE k = 'schedule'").fetchone() stored = json.loads(row[0]) if row else None if isinstance(schedule, dict) and isinstance(schedule.get("blocks"), list) and \ (stored is None or schedule.get("rev", 0) > stored.get("rev", 0)): stored = schedule self.db.execute("INSERT OR REPLACE INTO meta (k, v) VALUES ('schedule', ?)", (json.dumps(stored),)) cutoff = (dt.date.today() - dt.timedelta(days=KEEP_DAYS)).isoformat() self.db.execute("DELETE FROM days WHERE date < ?", (cutoff,)) seq = self.seq() for day in pushed: date = day.get("date", "") try: dt.date.fromisoformat(date) except (TypeError, ValueError): continue if date < cutoff: continue row = self.db.execute("SELECT doc FROM days WHERE date = ?", (date,)).fetchone() old = json.loads(row[0]) if row else None merged = model.merge(old, day) if merged != old: seq += 1 self.db.execute("INSERT OR REPLACE INTO days (date, doc, seq) VALUES (?, ?, ?)", (date, json.dumps(merged, separators=(",", ":")), seq)) self.db.commit() if since > seq: since = 0 rows = self.db.execute("SELECT doc FROM days WHERE seq > ? ORDER BY date", (since,)).fetchall() out = {"seq": seq, "days": [json.loads(r[0]) for r in rows]} if stored is not None and stored.get("rev", 0) > schedule_rev: out["schedule"] = stored if base is not None: out["streaks_t"] = base.get("t", 0) if streaks_t is not None and base.get("t", 0) > streaks_t: out["streaks"] = base return out def valid_streaks(s): """A streak base worth keeping: {"t": int, "asof": "YYYY-MM-DD", "items": {...}, ...}.""" if not isinstance(s, dict) or not isinstance(s.get("items"), dict) or type(s.get("t")) is not int: return False try: dt.date.fromisoformat(s.get("asof")) except (TypeError, ValueError): return False return True class Handler(BaseHTTPRequestHandler): server_version = "routine-server" def _send(self, code, obj): body = json.dumps(obj, separators=(",", ":")).encode() self.send_response(code) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body) def _authed(self): got = self.headers.get("Authorization", "") return secrets.compare_digest(got.encode(), ("Bearer " + self.server.token).encode()) def do_GET(self): if self.path == "/health": return self._send(200, {"ok": True}) self._send(404, {"error": "not found"}) def do_POST(self): if self.path != "/sync": return self._send(404, {"error": "not found"}) if not self._authed(): return self._send(401, {"error": "unauthorized"}) n = int(self.headers.get("Content-Length") or 0) if n > MAX_BODY: return self._send(413, {"error": "too large"}) try: req = json.loads(self.rfile.read(n) or b"{}") since = int(req.get("since", 0)) days = req.get("days", []) if not isinstance(days, list): raise ValueError("days") sched, srev = req.get("schedule"), int(req.get("schedule_rev", 0)) st = int(req["streaks_t"]) if req.get("streaks_t") is not None else None except (ValueError, TypeError) as e: return self._send(400, {"error": "bad request: %s" % e}) self._send(200, self.server.store.sync(since, days, sched, srev, req.get("streaks"), st)) def log_message(self, fmt, *args): sys.stderr.write("%s %s\n" % (self.log_date_time_string(), fmt % args)) def main(): ap = argparse.ArgumentParser() ap.add_argument("--host", default="127.0.0.1") ap.add_argument("--port", type=int, default=8070) ap.add_argument("--data", required=True) a = ap.parse_args() os.makedirs(a.data, exist_ok=True) tok_path = os.path.join(a.data, "token") if not os.path.exists(tok_path): fd = os.open(tok_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) with os.fdopen(fd, "w") as f: f.write(secrets.token_urlsafe(32)) srv = ThreadingHTTPServer((a.host, a.port), Handler) srv.token = open(tok_path).read().strip() srv.store = Store(os.path.join(a.data, "routine.db")) print("routine-server on %s:%d" % (a.host, a.port), flush=True) srv.serve_forever() if __name__ == "__main__": main()