@agentikos/omega-os 0.2.0 → 0.19.6

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,
+    )

package/omega/Agentik_Engine/omega_engine/backup.py

@@ -0,0 +1,215 @@
+"""`omega backup` + `omega restore` — disaster-recovery for an OmegaOS deployment.
+
+What we back up by default:
+
+  * ``Agentik_Runtime/``       (event log, audits, telegram history, sessions)
+  * ``Agentik_Extra/etc/secrets/``  (encrypted vault — the .age files +
+                                      the .vault-key)
+  * ``Agentik_SSOT/``           (operator-edited skills, audits, charters,
+                                  webhooks — anything modified post-install)
+  * ``Agentik_Coding/projects.json`` (project registry)
+
+What we do NOT back up:
+
+  * The engine venv (regenerated by re-running install.sh)
+  * MCP binaries (installed by step 40, idempotent)
+  * Cache + tmp dirs
+
+The bundle is a tar.gz at ``~/omega-backup-<timestamp>.tar.gz`` by
+default. When the operator passes ``--encrypt``, the tarball is then
+piped through ``age -r <pub>`` so the bundle itself is at-rest
+encrypted. The recipient defaults to the operator's existing
+``.vault-pub`` so they need no extra key management.
+
+``omega backup verify <path>`` extracts the bundle into a temp dir and
+re-runs ``omega doctor`` against it. Pass = the backup actually
+restores; fail = the bundle is corrupt or incomplete.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+
+BACKUP_ROOTS = [
+    "Agentik_Runtime",
+    "Agentik_Extra/etc/secrets",
+    "Agentik_SSOT",
+    "Agentik_Coding/projects.json",
+]
+
+
+@dataclass
+class BackupResult:
+    bundle: Path
+    bytes: int
+    encrypted: bool
+    duration_s: float
+    detail: str = ""
+
+
+@dataclass
+class RestoreResult:
+    bundle: Path
+    target: Path
+    files: int
+    duration_s: float
+    detail: str = ""
+
+
+def _have(binary: str) -> bool:
+    return shutil.which(binary) is not None
+
+
+def backup(
+    omega_home: str | Path,
+    *,
+    out_dir: str | Path | None = None,
+    encrypt: bool = False,
+    recipient_path: str | Path | None = None,
+) -> BackupResult:
+    """Create a tarball of the live tree's recoverable subset."""
+    home = Path(omega_home)
+    if not home.is_dir():
+        raise FileNotFoundError(f"OMEGA_HOME not found: {home}")
+    out_dir = Path(out_dir) if out_dir else Path.home()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    ts = int(time.time())
+    bundle = out_dir / f"omega-backup-{ts}.tar.gz"
+
+    start = time.time()
+    with tarfile.open(bundle, "w:gz") as tar:
+        for relpath in BACKUP_ROOTS:
+            full = home / relpath
+            if not full.exists():
+                continue
+            tar.add(full, arcname=relpath)
+    elapsed = time.time() - start
+
+    if encrypt:
+        if not _have("age"):
+            raise RuntimeError("age not on PATH — install it or drop --encrypt")
+        rec_file = (
+            Path(recipient_path) if recipient_path
+            else home / "Agentik_Extra" / "etc" / "secrets" / ".vault-pub"
+        )
+        if not rec_file.exists():
+            raise RuntimeError(
+                f"no recipient public key at {rec_file} — provide --recipient-path"
+            )
+        recipient = rec_file.read_text().strip()
+        enc_bundle = bundle.with_suffix(bundle.suffix + ".age")
+        with bundle.open("rb") as inp, enc_bundle.open("wb") as out:
+            proc = subprocess.run(
+                ["age", "-r", recipient], stdin=inp, stdout=out,
+                check=False, capture_output=False, timeout=600,
+            )
+        if proc.returncode != 0:
+            raise RuntimeError(f"age encrypt exit {proc.returncode}")
+        bundle.unlink()           # drop the plaintext tarball
+        bundle = enc_bundle
+
+    return BackupResult(
+        bundle=bundle, bytes=bundle.stat().st_size,
+        encrypted=encrypt, duration_s=round(elapsed, 2),
+        detail=f"{len(BACKUP_ROOTS)} root(s) archived",
+    )
+
+
+def restore(
+    bundle: str | Path,
+    *,
+    target: str | Path,
+    age_identity: str | Path | None = None,
+) -> RestoreResult:
+    """Restore a bundle into ``target`` (typically ``$OMEGA_HOME``)."""
+    bundle = Path(bundle)
+    if not bundle.exists():
+        raise FileNotFoundError(f"bundle not found: {bundle}")
+    target = Path(target)
+    target.mkdir(parents=True, exist_ok=True)
+
+    start = time.time()
+    # If encrypted, decrypt to a temp file first.
+    tar_source: Path = bundle
+    cleanup_tmp: Path | None = None
+    if bundle.suffix == ".age":
+        if not _have("age"):
+            raise RuntimeError("age not on PATH — cannot decrypt bundle")
+        identity = (
+            Path(age_identity) if age_identity
+            else target / "Agentik_Extra" / "etc" / "secrets" / ".vault-key"
+        )
+        if not identity.exists():
+            raise RuntimeError(
+                f"no age identity at {identity} — provide --identity"
+            )
+        cleanup_tmp = Path(tempfile.mkstemp(suffix=".tar.gz")[1])
+        with cleanup_tmp.open("wb") as out:
+            proc = subprocess.run(
+                ["age", "-d", "-i", str(identity), str(bundle)],
+                stdout=out, check=False, timeout=600,
+            )
+        if proc.returncode != 0:
+            cleanup_tmp.unlink(missing_ok=True)
+            raise RuntimeError(f"age decrypt exit {proc.returncode}")
+        tar_source = cleanup_tmp
+
+    try:
+        with tarfile.open(tar_source, "r:gz") as tar:
+            members = tar.getmembers()
+            for m in members:
+                # Reject absolute paths + path traversal.
+                if m.name.startswith("/") or ".." in m.name.split("/"):
+                    raise RuntimeError(f"unsafe path in bundle: {m.name}")
+            tar.extractall(path=target)
+            files = sum(1 for m in members if m.isfile())
+    finally:
+        if cleanup_tmp is not None:
+            cleanup_tmp.unlink(missing_ok=True)
+
+    return RestoreResult(
+        bundle=bundle, target=target, files=files,
+        duration_s=round(time.time() - start, 2),
+        detail=f"{files} file(s) extracted",
+    )
+
+
+def verify(
+    bundle: str | Path,
+    *,
+    age_identity: str | Path | None = None,
+) -> dict:
+    """Restore the bundle into a temp dir + run a minimal sanity check.
+
+    Returns ``{ok: bool, files: int, detail: str}``. We do NOT run the
+    full ``omega doctor`` here because that would touch the operator's
+    real environment; we just confirm the bundle extracts cleanly and
+    looks like an OmegaOS tree.
+    """
+    bundle = Path(bundle)
+    with tempfile.TemporaryDirectory() as td:
+        result = restore(bundle, target=td, age_identity=age_identity)
+        # Smoke check: the well-known subset should be in there.
+        target = Path(td)
+        missing = [
+            root for root in BACKUP_ROOTS
+            if not (target / root).exists()
+        ]
+        if missing:
+            return {
+                "ok": False,
+                "files": result.files,
+                "detail": f"missing in bundle: {missing}",
+            }
+        return {
+            "ok": True,
+            "files": result.files,
+            "detail": f"all {len(BACKUP_ROOTS)} root(s) present + extracted",
+        }