twin-update 0.2.0__py3-none-any.whl

twin_update/__init__.py

@@ -0,0 +1,3 @@
+"""Twin Update: update the same desktop apps on two Linux machines in one run."""
+
+__version__ = "0.2.0"

twin_update/__main__.py

@@ -0,0 +1,3 @@
+from twin_update.cli import main
+
+raise SystemExit(main())

twin_update/cli.py

@@ -0,0 +1,255 @@
+"""Command line: twin-update status|run|rollback|holds|unhold|doctor|local."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import json
+import os
+import shutil
+import signal
+import sys
+
+from twin_update import __version__, orchestrator
+from twin_update.config import ConfigError, load
+from twin_update.engine import Engine
+from twin_update.peer import LocalPeer, PeerError, SshPeer, serve
+from twin_update.system import System
+
+
+class ConsoleUI:
+    def say(self, msg: str) -> None:
+        try:
+            print(msg, flush=True)
+        except OSError:  # terminal went away (e.g. the app hosting it was closed)
+            pass
+
+    def getpass(self, prompt: str) -> str:
+        return getpass.getpass(prompt)
+
+    def confirm(self, prompt: str) -> bool:
+        if not sys.stdin.isatty():
+            return False
+        try:
+            return input(prompt + " [y/N] ").strip().lower() in ("y", "yes")
+        except (EOFError, OSError):
+            return False
+
+
+def _detach_if_needed(args) -> None:
+    """Re-exec in its own systemd user scope so closing the app that hosts our
+    terminal (e.g. Grok Bot) does not kill the run. The scope ends with us."""
+    if args.no_detach or os.environ.get("TWIN_UPDATE_SCOPE") == "1":
+        signal.signal(signal.SIGHUP, signal.SIG_IGN)
+        return
+    if not shutil.which("systemd-run"):
+        signal.signal(signal.SIGHUP, signal.SIG_IGN)
+        return
+    argv = ["systemd-run", "--user", "--scope", "--quiet", "--collect", "--",
+            "env", "TWIN_UPDATE_SCOPE=1", sys.executable, *sys.argv]
+    os.execvp(argv[0], argv)
+
+
+def _build(args, ui, system=None, peer_factory=SshPeer):
+    system = system or System()
+    cfg = load(args.config)
+    me = cfg.self_label(system.whoami(), system.machine_id())
+    peer = cfg.peer_label(me)
+    peers = {me: LocalPeer(Engine(cfg, system, me, log=lambda m: None))}
+    unreachable = {}
+    if not getattr(args, "local_only", False):
+        mach = cfg.machines[peer]
+        sp = None
+        try:
+            sp = peer_factory(peer, mach.ssh_target, mach.remote_command)
+            sp.call("identity")
+            peers[peer] = sp
+        except (PeerError, OSError, ValueError) as exc:
+            unreachable[peer] = str(exc)
+            if sp is not None:
+                try:
+                    sp.proc.terminate()
+                except Exception:
+                    pass
+    else:
+        unreachable[peer] = "skipped (--local-only)"
+    return cfg, orchestrator.Session(cfg, peers, [me, peer], ui), unreachable, me, peer
+
+
+def _print(ui, data, as_json: bool) -> None:
+    if as_json:
+        ui.say(json.dumps(data, indent=2, sort_keys=True))
+        return
+    kind = data.get("kind")
+    if kind == "status":
+        ui.say(f"{'machine':8} {'app':9} {'installed':22} {'candidate':22} run  rollback      hold")
+        for l, st in data["machines"].items():
+            for a, r in st["apps"].items():
+                ui.say(f"{l:8} {a:9} {str(r['installed']):22} {str(r['candidate']):22} "
+                       f"{'yes' if r['running'] else 'no ':4} {','.join(r['rollback']) or '-':13} "
+                       f"{r['hold'] or '-'}")
+            if st.get("other_holds"):
+                ui.say(f"{l:8} other held packages (not touched): {', '.join(st['other_holds'])}")
+        for l, why in data.get("unreachable", {}).items():
+            ui.say(f"{l:8} unreachable: {why}")
+        return
+    if kind == "doctor":
+        for l, checks in data.get("machines", {}).items():
+            if "error" in checks:
+                ui.say(f"{l:8} error: {checks['error']}")
+                continue
+            bad = []
+            for k in sorted(checks):
+                v = checks[k]
+                if k == "locks":
+                    for path, state in v.items():
+                        ui.say(f"{l:8} lock {path}: {state}")
+                    continue
+                if k == "notify_tool":
+                    ui.say(f"{l:8} notify: {v or 'none (notifications skipped)'}")
+                    continue
+                ok = bool(v)
+                ui.say(f"{l:8} {k:18} {'ok' if ok else 'NO'}")
+                if not ok:
+                    bad.append(k)
+            ui.say(f"{l:8} {'all checks ok' if not bad else 'problems: ' + ', '.join(bad)}")
+        for l, why in data.get("unreachable", {}).items():
+            ui.say(f"{l:8} unreachable: {why}")
+        return
+    if kind == "holds":
+        for l, h in data.get("machines", {}).items():
+            managed = h.get("managed", {})
+            ui.say(f"{l:8} app holds: " + (", ".join(f"{a} ({o})" for a, o in sorted(managed.items()))
+                                           or "none"))
+            if h.get("other"):
+                ui.say(f"{l:8} other held packages (not touched): {', '.join(h['other'])}")
+        return
+    if kind == "unhold":
+        for l, r in data.get("machines", {}).items():
+            ui.say(f"{l:8} {r.get('action', r.get('error', '?'))}")
+        return
+    printed = False
+    for line in data.get("summary", []):
+        ui.say(line)
+        printed = True
+    for b in data.get("blockers", []):
+        ui.say(f"blocker: {b}")
+    if data.get("result"):
+        ui.say(f"result: {data['result']}")
+    if data.get("error") and data.get("result") != "aborted":
+        ui.say(f"error: {data['error']}")
+    if not (printed or data.get("blockers") or data.get("result") or data.get("error")):
+        # Never stay silent: fall back to the JSON report.
+        ui.say(json.dumps(data, indent=2, sort_keys=True))
+
+
+def main(argv=None, ui=None, system=None, peer_factory=SshPeer) -> int:
+    ui = ui or ConsoleUI()
+    ap = argparse.ArgumentParser(prog="twin-update", description=__doc__)
+    ap.add_argument("--version", action="version", version=f"twin-update {__version__}")
+    ap.add_argument("--config", default=None, help="config path (default ~/.config/twin-update/config.toml)")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    def common(p, local=True):
+        p.add_argument("--json", action="store_true", help="print the full JSON report")
+        if local:
+            p.add_argument("--local-only", action="store_true",
+                           help="this machine only (no ssh); run/rollback allow it with --dry-run only")
+
+    p = sub.add_parser("status"); common(p)
+    p = sub.add_parser("run"); common(p)
+    p.add_argument("--apps", default=None, help="comma list (default: all enabled)")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--no-smoke", action="store_true", help="skip the launch smoke test")
+    p.add_argument("--no-detach", action="store_true")
+    p = sub.add_parser("rollback"); common(p)
+    p.add_argument("app")
+    p.add_argument("--machine", default="both")
+    p.add_argument("--dry-run", action="store_true")
+    p.add_argument("--no-hold", action="store_true")
+    p.add_argument("--no-smoke", action="store_true")
+    p.add_argument("--no-detach", action="store_true")
+    p = sub.add_parser("holds"); common(p)
+    p = sub.add_parser("unhold"); common(p)
+    p.add_argument("app")
+    p.add_argument("--machine", default="both")
+    p.add_argument("--dry-run", action="store_true")
+    p = sub.add_parser("doctor"); common(p)
+    p = sub.add_parser("local", help="per-machine engine (used by the peer over ssh)")
+    p.add_argument("--serve", action="store_true")
+    p.add_argument("--as", dest="as_label", default=None)
+
+    args = ap.parse_args(argv)
+    system = system or System()
+
+    try:
+        if args.cmd == "local":
+            cfg = load(args.config)
+            me = cfg.self_label(system.whoami(), system.machine_id())
+            if args.as_label and args.as_label != me:
+                ui.say(json.dumps({"id": None, "ok": False,
+                                   "error": f"identity mismatch: this machine is {me}"}))
+                return 2
+            if not args.serve:
+                ui.say("use --serve")
+                return 2
+            return serve(Engine(cfg, system, me), sys.stdin.buffer, sys.stdout.buffer)
+
+        if args.cmd in ("run", "rollback") and not args.dry_run:
+            if getattr(args, "local_only", False):
+                ui.say("--local-only is allowed only with --dry-run")
+                return 2
+            _detach_if_needed(args)
+
+        cfg, sess, unreachable, me, peer = _build(args, ui, system, peer_factory)
+        try:
+            if args.cmd == "status":
+                data = orchestrator.status(sess)
+                data["unreachable"] = unreachable
+            elif args.cmd == "run":
+                apps = args.apps.split(",") if args.apps else list(cfg.enabled)
+                for a in apps:
+                    if a not in cfg.enabled:
+                        ui.say(f"app not enabled in config: {a}")
+                        return 2
+                data = orchestrator.run(sess, apps, args.dry_run, smoke=not args.no_smoke,
+                                        unreachable=unreachable)
+            elif args.cmd == "rollback":
+                labels = _labels(args.machine, me, peer, sess)
+                data = orchestrator.rollback(sess, args.app, labels, args.dry_run,
+                                             smoke=not args.no_smoke, hold=not args.no_hold)
+            elif args.cmd == "holds":
+                data = orchestrator.holds(sess)
+            elif args.cmd == "unhold":
+                data = orchestrator.unhold(sess, args.app, _labels(args.machine, me, peer, sess),
+                                           args.dry_run)
+            else:
+                data = orchestrator.doctor(sess, unreachable)
+        finally:
+            sess.close()
+    except ConfigError as exc:
+        ui.say(f"config error: {exc}")
+        return 2
+    except PeerError as exc:
+        ui.say(f"error: {exc}")
+        return 1
+    _print(ui, data, args.json)
+    res = data.get("result")
+    return 0 if res in (None, "ok", "dry-run") else (3 if res == "aborted" else 1)
+
+
+def _labels(choice: str, me: str, peer: str, sess) -> list[str]:
+    if choice == "both":
+        labels = [me, peer]
+    elif choice in (me, peer):
+        labels = [choice]
+    else:
+        raise ConfigError(f"--machine must be both, {me} or {peer}")
+    missing = [l for l in labels if l not in sess.peers]
+    if missing:
+        raise PeerError(f"unreachable: {', '.join(missing)}")
+    return labels
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

twin_update/config.py

@@ -0,0 +1,162 @@
+"""Configuration (~/.config/twin-update/config.toml). No personal defaults here."""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, field
+
+DEFAULT_PATH = "~/.config/twin-update/config.toml"
+
+# Generic package facts only. Paths are where the vendor .debs install.
+BUILTIN_APPS = {
+    "cursor": {
+        "package": "cursor",
+        "roots": ["/usr/share/cursor"],
+        "launch": ["/usr/share/cursor/cursor"],
+        "display": "Cursor",
+    },
+    "chatgpt": {
+        "package": "chatgpt",
+        "roots": ["/usr/lib/chatgpt"],
+        "launch": ["/usr/bin/chatgpt"],
+        "display": "ChatGPT",
+    },
+    "grok-bot": {
+        "package": "grok-bot",
+        "roots": ["/opt/Grok Bot"],
+        "launch": ["/usr/bin/grok-bot"],
+        "display": "Grok Bot",
+    },
+}
+
+
+class ConfigError(Exception):
+    pass
+
+
+@dataclass
+class Machine:
+    label: str
+    user: str
+    ssh_target: str = ""
+    remote_command: str = "~/.local/bin/twin-update"
+    machine_id_sha256: str = ""
+    lock_paths: list[str] = field(default_factory=list)
+
+
+@dataclass
+class App:
+    name: str
+    package: str
+    roots: list[str]
+    launch: list[str]
+    display: str
+
+
+@dataclass
+class Config:
+    machines: dict[str, Machine]
+    apps: dict[str, App]
+    enabled: list[str]
+    keep_holds: list[str]
+    fallback_rollback: list[str]
+    close_timeout_s: float = 90.0
+    smoke_s: float = 20.0
+    apt_lock_timeout_s: int = 300
+    lock_wait_s: float = 600.0
+    store: str = "~/.local/share/twin-update/rollback"
+    state_dir: str = "~/.local/state/twin-update"
+    search_dirs: list[str] = field(default_factory=lambda: ["~/Downloads"])
+    grace_days: float = 7.0
+    grace_launches: int = 2
+
+    def self_label(self, whoami: str, machine_id_sha256: str = "") -> str:
+        """Find this machine's label: by user, then by machine-id when the
+        same user name exists on both machines."""
+        hits = [m for m in self.machines.values() if m.user == whoami]
+        if len(hits) > 1:
+            hits = [m for m in hits if m.machine_id_sha256 and m.machine_id_sha256 == machine_id_sha256]
+            if len(hits) != 1:
+                raise ConfigError(
+                    "both machines use the same user name: set machine_id_sha256 on each "
+                    "[machines.*] table (value: tr -d '\\n' < /etc/machine-id | sha256sum)")
+        if len(hits) != 1:
+            raise ConfigError(
+                f"whoami does not match exactly one [machines.*].user (matches: {len(hits)})")
+        return hits[0].label
+
+    def peer_label(self, me: str) -> str:
+        others = [k for k in self.machines if k != me]
+        if len(others) != 1:
+            raise ConfigError("config must list exactly two machines")
+        return others[0]
+
+
+def _expand(p: str, home: str) -> str:
+    if p == "~" or p.startswith("~/"):
+        return home + p[1:]
+    return p
+
+
+def load(path: str | None = None, home: str | None = None, text: str | None = None) -> Config:
+    home = home or os.path.expanduser("~")
+    if text is None:
+        real = _expand(path or DEFAULT_PATH, home)
+        try:
+            with open(real, "rb") as fh:
+                data = tomllib.load(fh)
+        except FileNotFoundError:
+            raise ConfigError(f"config not found: {path or DEFAULT_PATH}") from None
+    else:
+        data = tomllib.loads(text)
+
+    msec = data.get("machines") or {}
+    if len(msec) != 2:
+        raise ConfigError("config must define exactly two [machines.<label>] tables")
+    machines = {}
+    for label, m in msec.items():
+        if not isinstance(m, dict) or not m.get("user"):
+            raise ConfigError(f"[machines.{label}] needs user")
+        machines[label] = Machine(
+            label=label, user=m["user"], ssh_target=m.get("ssh_target", ""),
+            remote_command=m.get("remote_command", "~/.local/bin/twin-update"),
+            machine_id_sha256=m.get("machine_id_sha256", ""),
+            lock_paths=[_expand(p, home) for p in m.get("lock_paths", [])],
+        )
+
+    asec = data.get("apps") or {}
+    apps: dict[str, App] = {}
+    for name, base in BUILTIN_APPS.items():
+        over = asec.get(name, {}) if isinstance(asec.get(name), dict) else {}
+        merged = {**base, **over}
+        apps[name] = App(name, merged["package"], list(merged["roots"]),
+                         list(merged["launch"]), merged["display"])
+    for name, over in asec.items():
+        if isinstance(over, dict) and name not in apps:
+            for k in ("package", "roots", "launch"):
+                if k not in over:
+                    raise ConfigError(f"[apps.{name}] needs {k}")
+            apps[name] = App(name, over["package"], list(over["roots"]),
+                             list(over["launch"]), over.get("display", name))
+    enabled = list(asec.get("enabled", list(BUILTIN_APPS)))
+    for n in enabled:
+        if n not in apps:
+            raise ConfigError(f"unknown app in enabled: {n}")
+
+    t = data.get("timeouts") or {}
+    r = data.get("rollback") or {}
+    return Config(
+        machines=machines, apps=apps, enabled=enabled,
+        keep_holds=list(asec.get("keep_holds", [])),
+        fallback_rollback=list(r.get("fallback", [])),
+        close_timeout_s=float(t.get("close_s", 90)),
+        smoke_s=float(t.get("smoke_s", 20)),
+        apt_lock_timeout_s=int(t.get("apt_lock_s", 300)),
+        lock_wait_s=float(t.get("lock_wait_s", 600)),
+        store=_expand(r.get("store", "~/.local/share/twin-update/rollback"), home),
+        state_dir=_expand(data.get("state_dir", "~/.local/state/twin-update"), home),
+        search_dirs=[_expand(p, home) for p in r.get("search_dirs", ["~/Downloads"])],
+        grace_days=float(r.get("grace_days", 7)),
+        grace_launches=int(r.get("grace_launches", 2)),
+    )