@agentikos/omega-os 0.1.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/auto_update.py

@@ -0,0 +1,339 @@
+"""Auto-update layer.
+
+What this module does
+---------------------
+
+Three jobs, distinct on purpose so each is testable:
+
+  1. **Cached check** — ``check_cached(home)`` returns the latest known
+     version from a small JSON file under ``Agentik_Extra/var/``. If the
+     cache is fresh (< check_interval_s), no network is hit. Default
+     interval: 24 h. Every CLI invocation can call this for ~0 ms.
+
+  2. **Banner emission** — ``maybe_emit_banner(home)`` prints a one-line
+     stderr notice if a new version is known to be available. Silent
+     when up-to-date or when the cache is empty (first run). Opt-out via
+     ``OMEGA_NO_UPDATE_BANNER=1``.
+
+  3. **Apply** — ``apply_update(home)`` performs the actual upgrade:
+
+         (a) ``omega doctor --json`` baseline
+         (b) ``omega backup create --encrypt`` snapshot
+         (c) ``npm install -g @agentikos/omega-os@latest``
+         (d) ``omega upgrade --non-interactive``
+         (e) run ``migrations`` from current → latest
+         (f) ``omega doctor --json`` + ``omega smoke``
+         (g) on failure: ``omega backup restore <bundle>``
+
+     Atomic-ish: every step is recorded to a journal, and any non-zero
+     exit before step (g) triggers rollback. The operator sees a clear
+     "✗ update aborted — restored from <bundle>" or "✓ updated to vX.Y.Z".
+
+Why all this care
+-----------------
+
+Updates that break the daily workflow are worse than no updates. Claude
+Code's pattern (silent banner + manual apply) is the right default. The
+``omega update auto`` cadence opts the operator into background apply,
+but ALWAYS through this same backup + verify + rollback pipeline.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import subprocess
+import sys
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+_DEFAULT_INTERVAL_S = 24 * 3600  # one day
+_CACHE_FILE = "last-update-check.json"
+_JOURNAL_FILE = "update-journal.jsonl"
+
+
+# ---------------------------------------------------------------------------
+# Cached check
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class CachedCheck:
+    current: str
+    latest: str
+    is_outdated: bool
+    checked_at: float
+    error: str = ""
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2)
+
+    @staticmethod
+    def from_json(text: str) -> "CachedCheck":
+        return CachedCheck(**json.loads(text))
+
+
+def _cache_path(home: Path) -> Path:
+    return home / "Agentik_Extra" / "var" / _CACHE_FILE
+
+
+def _journal_path(home: Path) -> Path:
+    return home / "Agentik_Extra" / "var" / _JOURNAL_FILE
+
+
+def _journal(home: Path, event: dict[str, Any]) -> None:
+    """Append a JSONL line to the update journal. Best-effort."""
+    p = _journal_path(home)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    line = json.dumps({"ts": time.time(), **event}) + "\n"
+    try:
+        with p.open("a") as fh:
+            fh.write(line)
+    except OSError:
+        pass
+
+
+def check_cached(
+    home: str | Path,
+    *,
+    interval_s: int = _DEFAULT_INTERVAL_S,
+    force: bool = False,
+) -> CachedCheck:
+    """Return the latest cached check; refresh from npm if stale.
+
+    Side-effect: writes the refreshed cache. Network access only when the
+    cache is stale or ``force=True``. Network errors set ``error`` but
+    don't raise — auto-update must never break a CLI invocation.
+    """
+    home = Path(home)
+    p = _cache_path(home)
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+    if p.exists() and not force:
+        try:
+            cached = CachedCheck.from_json(p.read_text())
+            if time.time() - cached.checked_at < interval_s:
+                return cached
+        except (OSError, ValueError, KeyError):
+            pass
+
+    # Refresh.
+    from omega_engine import __version__
+    from omega_engine.updater import check_for_updates
+    info = check_for_updates(__version__, timeout=8)
+    fresh = CachedCheck(
+        current=info.current,
+        latest=info.latest,
+        is_outdated=info.is_outdated,
+        checked_at=time.time(),
+        error=info.error,
+    )
+    try:
+        # Atomic write — same pattern as done_signal.
+        tmp = p.with_suffix(p.suffix + f".tmp.{os.getpid()}")
+        tmp.write_text(fresh.to_json())
+        os.replace(tmp, p)
+    except OSError:
+        pass
+    return fresh
+
+
+def maybe_emit_banner(home: str | Path, *, stream=sys.stderr) -> bool:
+    """Print a one-line update banner when a new version is known.
+
+    Returns True iff a banner was emitted. Opt-out via
+    ``OMEGA_NO_UPDATE_BANNER=1``. Never raises.
+    """
+    if os.environ.get("OMEGA_NO_UPDATE_BANNER") == "1":
+        return False
+    try:
+        check = check_cached(home)
+    except Exception:  # noqa: BLE001
+        return False
+    if not check.is_outdated or check.error:
+        return False
+    msg = (
+        f"[omega] update available: {check.current} → {check.latest}  "
+        f"run `omega update apply` to install"
+    )
+    try:
+        print(msg, file=stream)
+    except (OSError, ValueError):
+        return False
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Apply
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class ApplyResult:
+    ok: bool
+    from_version: str
+    to_version: str
+    bundle: str = ""            # path to the pre-update backup
+    rolled_back: bool = False
+    duration_s: float = 0.0
+    steps: list[dict[str, Any]] = field(default_factory=list)
+    error: str = ""
+
+
+def _which(bin_: str) -> str | None:
+    import shutil as _sh
+    return _sh.which(bin_)
+
+
+def _run_step(
+    home: Path, label: str, cmd: list[str], *, timeout: int = 600,
+) -> tuple[int, str]:
+    """Run a step, journal it, return (returncode, tail-of-output)."""
+    started = time.time()
+    try:
+        proc = subprocess.run(
+            cmd, check=False, capture_output=True, text=True, timeout=timeout,
+        )
+        rc = proc.returncode
+        tail = (proc.stdout + "\n" + proc.stderr).strip()[-500:]
+    except subprocess.TimeoutExpired:
+        rc = 124
+        tail = f"timeout after {timeout}s"
+    except OSError as exc:
+        rc = 127
+        tail = f"exec error: {exc}"
+    _journal(home, {
+        "step": label, "rc": rc, "duration_s": round(time.time() - started, 2),
+        "tail": tail[:400],
+    })
+    return rc, tail
+
+
+def apply_update(
+    home: str | Path,
+    *,
+    skip_backup: bool = False,
+    skip_verify: bool = False,
+    npm_global: bool = True,
+) -> ApplyResult:
+    """Apply the available update with full backup + migrate + verify + rollback.
+
+    Strict sequence:
+
+      1. baseline doctor JSON
+      2. backup create (skippable for tests)
+      3. npm install -g @agentikos/omega-os@latest  (or skipped when not on PATH)
+      4. run migrations from <current> → <latest>
+      5. omega upgrade --non-interactive (re-run install steps)
+      6. doctor + smoke (skippable for tests)
+
+    Any failure between 2 and 6 triggers ``backup restore`` from the bundle.
+    """
+    home = Path(home)
+    start = time.time()
+    from omega_engine import __version__
+    info = check_cached(home, force=True)
+    if info.error:
+        return ApplyResult(
+            ok=False, from_version=__version__, to_version="?",
+            error=f"check failed: {info.error}",
+            duration_s=round(time.time() - start, 2),
+        )
+    if not info.is_outdated:
+        return ApplyResult(
+            ok=True, from_version=__version__, to_version=info.latest,
+            error="already up-to-date",
+            duration_s=round(time.time() - start, 2),
+        )
+
+    _journal(home, {"phase": "begin", "from": info.current, "to": info.latest})
+    steps: list[dict[str, Any]] = []
+    bundle = ""
+    omega_bin = _which("omega") or "omega"
+
+    # 1. baseline doctor (informational)
+    rc, _ = _run_step(home, "doctor-baseline",
+                      [omega_bin, "doctor", "--json"],
+                      timeout=60)
+    steps.append({"label": "doctor-baseline", "rc": rc})
+
+    # 2. backup
+    if not skip_backup:
+        from omega_engine.backup import backup as _bk
+        try:
+            res = _bk(home, out_dir=home / "Agentik_Extra" / "var" / "backups")
+            bundle = str(res.path)
+            steps.append({"label": "backup", "rc": 0, "bundle": bundle})
+            _journal(home, {"step": "backup", "bundle": bundle})
+        except Exception as exc:  # noqa: BLE001
+            return ApplyResult(
+                ok=False, from_version=info.current, to_version=info.latest,
+                error=f"backup failed: {exc}",
+                duration_s=round(time.time() - start, 2), steps=steps,
+            )
+
+    def _rollback(reason: str) -> ApplyResult:
+        _journal(home, {"phase": "rollback", "reason": reason, "bundle": bundle})
+        if bundle and not skip_backup:
+            from omega_engine.backup import restore as _rs
+            try:
+                _rs(bundle, target=home)
+            except Exception as exc:  # noqa: BLE001
+                _journal(home, {"phase": "rollback-failed", "reason": str(exc)})
+        return ApplyResult(
+            ok=False, from_version=info.current, to_version=info.latest,
+            bundle=bundle, rolled_back=bool(bundle),
+            error=reason,
+            duration_s=round(time.time() - start, 2), steps=steps,
+        )
+
+    # 3. npm install
+    if npm_global and _which("npm"):
+        rc, tail = _run_step(
+            home, "npm-install",
+            ["npm", "install", "-g", "@agentikos/omega-os@latest"],
+            timeout=600,
+        )
+        steps.append({"label": "npm-install", "rc": rc})
+        if rc != 0:
+            return _rollback(f"npm install failed: {tail[:200]}")
+
+    # 4. migrations
+    from omega_engine.migrations import run_migrations
+    try:
+        migrated = run_migrations(home, info.current, info.latest)
+        steps.append({
+            "label": "migrations", "rc": 0,
+            "applied": [m["name"] for m in migrated],
+        })
+    except Exception as exc:  # noqa: BLE001
+        return _rollback(f"migrations failed: {exc}")
+
+    # 5. omega upgrade (re-run install steps, idempotent)
+    rc, tail = _run_step(
+        home, "omega-upgrade",
+        [omega_bin, "upgrade", "--non-interactive"],
+        timeout=900,
+    )
+    steps.append({"label": "omega-upgrade", "rc": rc})
+    if rc != 0:
+        return _rollback(f"omega upgrade failed: {tail[:200]}")
+
+    # 6. verify
+    if not skip_verify:
+        rc_doc, _ = _run_step(home, "doctor-verify",
+                              [omega_bin, "doctor", "--json"], timeout=60)
+        rc_smk, _ = _run_step(home, "smoke", [omega_bin, "smoke"], timeout=120)
+        steps.append({"label": "doctor-verify", "rc": rc_doc})
+        steps.append({"label": "smoke", "rc": rc_smk})
+        if rc_smk != 0:
+            return _rollback(f"post-update smoke failed (rc={rc_smk})")
+
+    _journal(home, {"phase": "success", "to": info.latest})
+    return ApplyResult(
+        ok=True, from_version=info.current, to_version=info.latest,
+        bundle=bundle, duration_s=round(time.time() - start, 2), steps=steps,
+    )