aisc-cli 0.1.0__py3-none-any.whl

aisc/cli/commands/serve_fs.py

@@ -0,0 +1,369 @@
+"""serve fs.* ops — the remote-authoritative file plane (2.1.10 R3, D-9).
+
+Every path is interpreted ON THE MACHINE THE SERVE PROCESS RUNS ON. The
+Workbench never keeps a local copy: browsing, preview and writes all ride
+these ops over the serve channel; watch events ride the reserved ``event``
+frame.
+
+Containment: paths are normalized (``..`` resolved) and rejected unless
+inside the op's own root — the F1 browse-pinning lesson, server-side now.
+watchdog is imported lazily; without it ``fs.watch`` degrades to a clean
+"unsupported" error and the Workbench falls back to list polling (D-9).
+"""
+
+from __future__ import annotations
+
+import os
+import posixpath
+import threading
+import time
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from aisc.domain.models import CliError
+
+#: Page size aligned with the Workbench's Explorer cursor protocol (Rust
+#: LIST_PAGE = 200).
+LIST_PAGE = 200
+
+#: Read budget aligned with the Workbench preview budget (512 KiB).
+READ_BUDGET = 512 * 1024
+
+#: Server-side ignore set — the equivalent of the Rust DEFAULT_IGNORE +
+#: temp-file filter, so remote trees look exactly like local ones.
+IGNORE_NAMES = {
+    ".git", ".aisc", ".claude", ".codex", ".cc-switch", ".local",
+    ".mcp.json", "node_modules", "target", "build", "dist", "tmp", "temp",
+    "__pycache__", ".venv", "venv",
+}
+
+
+def _is_temp_name(name: str) -> bool:
+    lower = name.lower()
+    return (
+        ".tmp." in lower
+        or lower.endswith((".tmp", ".temp", "~", ".swp", ".swo", ".aisc-tmp"))
+        or lower.startswith((".#", "~$"))
+    )
+
+
+def _ignored(name: str) -> bool:
+    return name in IGNORE_NAMES or _is_temp_name(name)
+
+
+def _resolve(root: str, rel: str) -> str:
+    """Resolve a ROOT-RELATIVE path (the Explorer's relativePath concept)
+    to a normalized absolute path inside *root*. Absolute-looking input and
+    `..` escapes are rejected — containment is server-side."""
+    root = posixpath.normpath(root)
+    rel = rel or ""
+    if rel.startswith("/") or rel.startswith("~"):
+        # Absolute/home paths are NOT rooted — reject before stripping so
+        # "/etc/passwd" can never silently become "<root>/etc/passwd".
+        raise CliError(message=f"path must be relative to the workspace root: {rel!r}",
+                       exit_code=2, error_code="AISC_ERR_FS_PATH")
+    rel = rel.strip("/")
+    if not rel:
+        return root
+    joined = posixpath.normpath(posixpath.join(root, rel))
+    if joined != root and not joined.startswith(root.rstrip("/") + "/"):
+        raise CliError(message=f"path escapes the workspace root: {rel!r}",
+                       exit_code=2, error_code="AISC_ERR_FS_CONTAINMENT")
+    return joined
+
+
+def _rel(root: str, abs_path: str) -> str:
+    root = posixpath.normpath(root).rstrip("/")
+    rel = abs_path[len(root):].lstrip("/")
+    return rel
+
+
+# ---------------------------------------------------------------------------
+# ops (uniform serve signature: (ns, payload, runtime) -> (data, exit, errs))
+
+
+def op_fs_list(_ns, payload: Dict[str, Any], _runtime) -> Tuple[Any, int, list]:
+    root = str(payload.get("root") or "/")
+    target = _resolve(root, str(payload.get("path") or ""))
+    if not os.path.isdir(target):
+        raise CliError(message=f"not a directory: {payload.get('path') or '/'}",
+                       exit_code=1, error_code="AISC_ERR_FS_NOT_DIR")
+    try:
+        names = sorted(os.listdir(target))
+    except OSError as exc:
+        raise CliError(message=f"listdir failed: {exc}", exit_code=1,
+                       error_code="AISC_ERR_FS_IO") from exc
+    offset = int(payload.get("offset") or 0)
+    page = names[offset:offset + LIST_PAGE]
+    entries = []
+    for name in page:
+        if _ignored(name):
+            continue
+        full = os.path.join(target, name)
+        try:
+            st = os.stat(full, follow_symlinks=False)
+            kind = "dir" if os.path.isdir(full) else "file"
+            entries.append({"name": name, "kind": kind, "size": st.st_size,
+                            "modified": int(st.st_mtime)})
+        except OSError:
+            entries.append({"name": name, "kind": "file", "size": 0, "modified": 0})
+    data: Dict[str, Any] = {"entries": entries}
+    if offset + LIST_PAGE < len(names):
+        data["nextOffset"] = offset + LIST_PAGE
+    return data, 0, []
+
+
+def op_fs_read(_ns, payload: Dict[str, Any], _runtime) -> Tuple[Any, int, list]:
+    import base64
+
+    root = str(payload.get("root") or "/")
+    target = _resolve(root, str(payload.get("path") or ""))
+    budget = int(payload.get("maxBytes") or READ_BUDGET)
+    try:
+        st = os.stat(target)
+    except OSError as exc:
+        raise CliError(message=f"stat failed: {exc}", exit_code=1,
+                       error_code="AISC_ERR_FS_IO") from exc
+    if os.path.isdir(target):
+        raise CliError(message="path is a directory", exit_code=1,
+                       error_code="AISC_ERR_FS_IS_DIR")
+    truncated = st.st_size > budget
+    with open(target, "rb") as f:
+        blob = f.read(budget)
+    return {
+        "base64": base64.b64encode(blob).decode("ascii"),
+        "size": st.st_size,
+        "truncated": truncated,
+        "modified": int(st.st_mtime),
+    }, 0, []
+
+
+def op_fs_write(_ns, payload: Dict[str, Any], _runtime) -> Tuple[Any, int, list]:
+    import base64
+
+    root = str(payload.get("root") or "/")
+    target = _resolve(root, str(payload.get("path") or ""))
+    blob = base64.b64decode(str(payload.get("base64") or ""))
+    atomic = _atomic_writer(target, blob)
+    if atomic is not None:
+        raise atomic
+    return {"bytes": len(blob)}, 0, []
+
+
+def _atomic_writer(target: str, blob: bytes) -> Optional[CliError]:
+    try:
+        tmp = target + ".aisc-tmp"
+        with open(tmp, "wb") as f:
+            f.write(blob)
+        os.replace(tmp, target)
+        return None
+    except OSError as exc:
+        try:
+            os.unlink(target + ".aisc-tmp")
+        except OSError:
+            pass
+        return CliError(message=f"write failed: {exc}", exit_code=1,
+                        error_code="AISC_ERR_FS_IO")
+
+
+def op_fs_mkdir(_ns, payload: Dict[str, Any], _runtime) -> Tuple[Any, int, list]:
+    root = str(payload.get("root") or "/")
+    target = _resolve(root, str(payload.get("path") or ""))
+    try:
+        os.makedirs(target, exist_ok=True)
+    except OSError as exc:
+        raise CliError(message=f"mkdir failed: {exc}", exit_code=1,
+                       error_code="AISC_ERR_FS_IO") from exc
+    return {}, 0, []
+
+
+def op_fs_rename(_ns, payload: Dict[str, Any], _runtime) -> Tuple[Any, int, list]:
+    root = str(payload.get("root") or "/")
+    src = _resolve(root, str(payload.get("from") or ""))
+    dst = _resolve(root, str(payload.get("to") or ""))
+    try:
+        os.replace(src, dst)
+    except OSError as exc:
+        raise CliError(message=f"rename failed: {exc}", exit_code=1,
+                       error_code="AISC_ERR_FS_IO") from exc
+    return {}, 0, []
+
+
+def op_fs_delete(_ns, payload: Dict[str, Any], _runtime) -> Tuple[Any, int, list]:
+    root = str(payload.get("root") or "/")
+    target = _resolve(root, str(payload.get("path") or ""))
+    if target == posixpath.normpath(root):
+        raise CliError(message="refusing to delete the workspace root",
+                       exit_code=2, error_code="AISC_ERR_FS_CONTAINMENT")
+    try:
+        if os.path.isdir(target):
+            import shutil
+
+            shutil.rmtree(target)
+        else:
+            os.unlink(target)
+    except OSError as exc:
+        raise CliError(message=f"delete failed: {exc}", exit_code=1,
+                       error_code="AISC_ERR_FS_IO") from exc
+    return {}, 0, []
+
+
+# ---------------------------------------------------------------------------
+# watch (watchdog, lazy) — events ride the reserved `event` frame
+
+
+class WatchRegistry:
+    """One watchdog observer per serve process; per-root handlers batch
+    events (100ms debounce) into a single fs.change frame per burst."""
+
+    def __init__(self, emit: Callable[[Dict[str, Any]], None]) -> None:
+        self._emit_cb = emit
+        self._lock = threading.Lock()
+        self._observer: Any = None
+        self._roots: Dict[str, Any] = {}
+        self._pending: Dict[str, Dict[str, Tuple[str, str]]] = {}  # root -> {abspath: (change, kind)}
+        self._flush_timer: Optional[threading.Timer] = None
+
+    def _emit(self, frame: Dict[str, Any]) -> None:
+        try:
+            self._emit_cb(frame)
+        except Exception:  # noqa: BLE001 — emit must never kill the watcher
+            pass
+
+    def available(self) -> bool:
+        try:
+            import watchdog  # noqa: F401
+
+            return True
+        except ImportError:
+            return False
+
+    def watch(self, root: str) -> None:
+        try:
+            from watchdog.events import FileSystemEventHandler
+            from watchdog.observers import Observer
+        except ImportError as exc:
+            raise CliError(message="fs.watch unsupported: watchdog unavailable",
+                           exit_code=3, error_code="AISC_ERR_FS_WATCH_UNSUPPORTED") from exc
+        root = posixpath.normpath(root)
+        if not os.path.isdir(root):
+            raise CliError(message=f"not a directory: {root}",
+                           exit_code=1, error_code="AISC_ERR_FS_NOT_DIR")
+        with self._lock:
+            if root in self._roots:
+                return
+            if self._observer is None:
+                self._observer = Observer()
+                self._observer.start()
+
+            reg = self
+
+            # watchdog event_type -> the Workbench change vocabulary
+            # (notify's classification). moved: from-half reports deleted,
+            # to-half reports created — the same semantics as the local
+            # watcher's rename handling (Stage 11).
+            def _change_type(event: Any) -> str:
+                et = getattr(event, "event_type", "")
+                return {
+                    "created": "created",
+                    "deleted": "deleted",
+                    "modified": "modified",
+                    "moved": "created",
+                    "closed": "modified",
+                }.get(et, "modified")
+
+            class Handler(FileSystemEventHandler):
+                def on_any_event(self, event: Any) -> None:
+                    path = getattr(event, "dest_path", None) or event.src_path
+                    if not path:
+                        return
+                    name = os.path.basename(str(path))
+                    if _ignored(name):
+                        return
+                    kind = "dir" if event.is_directory else "file"
+                    reg._record(root, str(path), kind, _change_type(event))
+
+            watch = self._observer.schedule(Handler(), root, recursive=True)
+            self._roots[root] = watch
+
+    def unwatch(self, root: str) -> None:
+        root = posixpath.normpath(root)
+        with self._lock:
+            watch = self._roots.pop(root, None)
+            if watch is not None and self._observer is not None:
+                self._observer.unschedule(watch)
+            if not self._roots and self._observer is not None:
+                self._observer.stop()
+                self._observer = None
+
+    def _record(self, root: str, abs_path: str, kind: str, change: str) -> None:
+        with self._lock:
+            # last-write-wins on the change type; created is sticky so a
+            # create+write burst surfaces as "created" (batcher parity)
+            prev = self._pending.get(root, {}).get(abs_path)
+            if prev == ("created", kind):
+                change = "created"
+            self._pending.setdefault(root, {})[abs_path] = (change, kind)
+            if self._flush_timer is None:
+                self._flush_timer = threading.Timer(0.1, self._flush)
+                self._flush_timer.daemon = True
+                self._flush_timer.start()
+
+    def _flush(self) -> None:
+        with self._lock:
+            self._flush_timer = None
+            batches = self._pending
+            self._pending = {}
+        for root, paths in batches.items():
+            self._emit({
+                "type": "event",
+                "event": "fs.change",
+                "data": {
+                    "root": root,
+                    "paths": [
+                        {"path": p, "change": c, "kind": k}
+                        for p, (c, k) in sorted(paths.items())
+                    ],
+                },
+            })
+
+    def shutdown(self) -> None:
+        # Grace for in-flight inotify callbacks (events land a few ms after
+        # the op result frame), then flush any debounced batch BEFORE
+        # stopping — the serve loop's EOF teardown would drop the last burst
+        # otherwise.
+        time.sleep(0.15)
+        if self._flush_timer is not None:
+            self._flush_timer.cancel()
+        self._flush()
+        with self._lock:
+            obs, self._observer = self._observer, None
+            self._roots.clear()
+        if obs is not None:
+            obs.stop()
+
+
+def op_fs_watch(_ns, payload: Dict[str, Any], runtime) -> Tuple[Any, int, list]:
+    root = str(payload.get("root") or "")
+    if not root.startswith("/"):
+        raise CliError(message="fs.watch requires an absolute root",
+                       exit_code=2, error_code="AISC_ERR_FS_PATH")
+    runtime.fs_watches.watch(root)
+    return {"root": posixpath.normpath(root)}, 0, []
+
+
+def op_fs_unwatch(_ns, payload: Dict[str, Any], runtime) -> Tuple[Any, int, list]:
+    root = posixpath.normpath(str(payload.get("root") or "/"))
+    runtime.fs_watches.unwatch(root)
+    return {}, 0, []
+
+
+OPS: Dict[str, Callable[..., Tuple[Any, int, list]]] = {
+    "fs.list": op_fs_list,
+    "fs.read": op_fs_read,
+    "fs.write": op_fs_write,
+    "fs.mkdir": op_fs_mkdir,
+    "fs.rename": op_fs_rename,
+    "fs.delete": op_fs_delete,
+    "fs.watch": op_fs_watch,
+    "fs.unwatch": op_fs_unwatch,
+}

aisc/cli/commands/session.py

@@ -0,0 +1,167 @@
+"""Session commands implementation.
+
+Implements ``aisc session`` subcommands: open, list, terminate.
+Per docs/gui-planning/05-cli-gui-contract.md §6.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from aisc.adapters.docker_ import DockerExecutor, RealDockerExecutor
+from aisc.application.session import (
+    list_sessions,
+    open_session,
+    terminate_session,
+    validate_agent,
+    validate_session_id,
+)
+from aisc.domain.models import (
+    CliError,
+    RuntimeErrorCode,
+    RuntimeExitCode,
+    SessionAgent,
+)
+
+
+def _resolve_workspace_and_registry(workspace: Optional[str]) -> Tuple[str, Path]:
+    """Return (canonical_workspace_str, registry_root_path).
+
+    Stage 7: the registry root is the data-root state dir
+    (``workspaces/<hash>/runtime``), never a workspace path (DATA-01);
+    legacy ``<workspace>/.aisc`` state is adopted on first use.
+    """
+    from aisc.application.data_root import workspace_state_dir
+
+    ws_path = Path(workspace).resolve() if workspace else Path.cwd()
+    return str(ws_path), workspace_state_dir(ws_path)
+
+
+# ---------------------------------------------------------------------------
+# session open
+# ---------------------------------------------------------------------------
+
+def cmd_session_open(
+    runtime_id: str,
+    session_id: str,
+    agent: str,
+    workspace: Optional[str] = None,
+    executor: Optional[DockerExecutor] = None,
+    resume_conversation_id: Optional[str] = None,
+) -> Tuple[Dict[str, Any], int]:
+    """Execute ``aisc session open`` per contract §6.1.
+
+    This is a text-only interactive command. It validates inputs, resolves
+    the running container, then runs ``docker exec -it`` with inherited
+    stdio. The agent's exit code becomes the process exit code.
+
+    v2.1.8 T4: ``resume_conversation_id`` forwards to the wrapper
+    (``--resume-id``) for provider-native conversation resume.
+
+    Returns (data_dict, exit_code). The caller is expected to ``sys.exit()``
+    with the exit code; the interactive streams are already inherited.
+    """
+    exec_ = executor or RealDockerExecutor()
+    _ws, reg_root = _resolve_workspace_and_registry(workspace)
+
+    proc = open_session(
+        runtime_id=runtime_id,
+        session_id=session_id,
+        agent=agent,
+        executor=exec_,
+        registry_root=reg_root,
+        resume_conversation_id=resume_conversation_id,
+    )
+
+    exit_code = proc.exit_code if proc.exit_code >= 0 else 1
+
+    data: Dict[str, Any] = {
+        "runtime_id": runtime_id,
+        "session_id": session_id,
+        "agent": agent,
+        "exit_code": exit_code,
+    }
+    if proc.command_not_found:
+        # 2.1.9 hotfix (#61): open_interactive packs the real failure text
+        # (daemon unreachable / exec create / exec start / transport) into
+        # stderr — surface it so print_session_text shows the true cause in
+        # the terminal instead of a misleading "docker command not found".
+        data["error"] = (proc.stderr or "").strip()[:200] or "docker command not found"
+    elif proc.timed_out:
+        data["error"] = "session timed out"
+
+    return data, exit_code
+
+
+# ---------------------------------------------------------------------------
+# session list
+# ---------------------------------------------------------------------------
+
+def cmd_session_list(
+    runtime_id: str,
+    workspace: Optional[str] = None,
+    executor: Optional[DockerExecutor] = None,
+) -> Dict[str, Any]:
+    """Execute ``aisc session list`` per contract §6.2."""
+    exec_ = executor or RealDockerExecutor()
+    _ws, reg_root = _resolve_workspace_and_registry(workspace)
+
+    sessions = list_sessions(
+        runtime_id=runtime_id,
+        executor=exec_,
+        registry_root=reg_root,
+    )
+    return {"sessions": sessions, "count": len(sessions)}
+
+
+# ---------------------------------------------------------------------------
+# session terminate
+# ---------------------------------------------------------------------------
+
+def cmd_session_terminate(
+    runtime_id: str,
+    session_id: str,
+    workspace: Optional[str] = None,
+    executor: Optional[DockerExecutor] = None,
+    grace_seconds: float = 5.0,
+) -> Dict[str, Any]:
+    """Execute ``aisc session terminate`` per contract §6.2."""
+    exec_ = executor or RealDockerExecutor()
+    _ws, reg_root = _resolve_workspace_and_registry(workspace)
+
+    result = terminate_session(
+        runtime_id=runtime_id,
+        session_id=session_id,
+        executor=exec_,
+        registry_root=reg_root,
+        grace_seconds=grace_seconds,
+    )
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Text output
+# ---------------------------------------------------------------------------
+
+def print_session_text(subcommand: str, data: Any, errors: list) -> None:
+    """Minimal human-readable output for ``aisc session`` text mode."""
+    if errors:
+        for e in errors:
+            print(f"Error: {e.get('message', '')}")
+        return
+    if not isinstance(data, dict):
+        return
+    if subcommand == "open":
+        print(f"session {data.get('session_id', '')} agent={data.get('agent', '')} "
+              f"exit_code={data.get('exit_code', '')}")
+    elif subcommand == "list":
+        sessions = data.get("sessions", [])
+        if not sessions:
+            print("(no sessions)")
+        for s in sessions:
+            print(f"{s.get('session_id', '')}  agent={s.get('agent', '')}  "
+                  f"state={s.get('state', '')}  pid={s.get('pid', '')}")
+    elif subcommand == "terminate":
+        print(f"session {data.get('session_id', '')} state={data.get('state', '')} "
+              f"exit_code={data.get('exit_code', '')}")

aisc/cli/commands/update.py

@@ -0,0 +1,145 @@
+"""``aisc update`` command surface (0.1.0 A4, D-7).
+
+``--check`` prints the plan; the bare form performs the frozen-exe update.
+Envelope-compatible JSON in ``--format json``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import aisc
+from aisc.application.bundle_fetch import BundleFetchError, BundleFetcher
+from aisc.application.update import (
+    UPDATE_ERROR_STATE,
+    UPDATE_ERROR_USAGE,
+    UpdateError,
+    build_check_report,
+    detect_install_form,
+    perform_update,
+)
+from aisc.domain.models import CliError
+
+
+def _root_for_tools() -> Path:
+    from aisc.application.resources import locate_aisc_root
+
+    root = locate_aisc_root()
+    if root is None:
+        raise CliError(
+            message="tool pins need an AISC root (repo or bundle) to layer "
+                    "against — run `aisc bundle fetch` first or use --aisc-root",
+            exit_code=1, error_code="AISC_ERR_GENERAL")
+    return root
+
+
+def _data_root() -> Path:
+    from aisc.application.data_root import shared_root
+
+    return shared_root()
+
+
+def _to_cli_error(exc: Exception) -> CliError:
+    if isinstance(exc, (UpdateError, BundleFetchError)):
+        return CliError(message=exc.message, exit_code=1, error_code="AISC_ERR_GENERAL")
+    raise exc
+
+
+def cmd_update_check(version: Optional[str] = None) -> Dict[str, Any]:
+    from aisc.application.tool_versions import tools_check_section
+
+    form = detect_install_form()
+    try:
+        fetcher = BundleFetcher()
+        report = build_check_report(
+            cli_version=aisc.__version__,
+            form=form,
+            fetcher=fetcher,
+            requested_version=version,
+        )
+    except (UpdateError, BundleFetchError) as exc:
+        raise _to_cli_error(exc) from exc
+    # A5: the tools block is network-tolerant (latest=null on registry
+    # failure) — a check must never fail because the network did.
+    report["tools"] = tools_check_section(_root_for_tools())
+    return report
+
+
+def cmd_update(
+    *,
+    version: Optional[str] = None,
+    from_file: Optional[str] = None,
+    sha256: Optional[str] = None,
+    rebuild: bool = False,
+    pin_tool: Optional[list] = None,
+) -> Dict[str, Any]:
+    if pin_tool:
+        from aisc.application.tool_versions import write_user_pins
+
+        pins: Dict[str, str] = {}
+        for spec in pin_tool:
+            if "=" not in spec:
+                raise CliError(
+                    message=f"--pin-tool expects KEY=VALUE, got {spec!r} "
+                            f"(pinnable: CLAUDE_CODE_VERSION, CODEX_VERSION, CC_SWITCH_VERSION)",
+                    exit_code=2, error_code="AISC_ERR_USAGE")
+            k, v = spec.split("=", 1)
+            pins[k.strip()] = v.strip()
+        _root_for_tools()  # fail fast when there is no root to layer against
+        try:
+            path = write_user_pins(_data_root(), pins)
+        except ValueError as exc:
+            raise CliError(message=str(exc), exit_code=2,
+                           error_code="AISC_ERR_USAGE") from exc
+        return {
+            "status": "pinned",
+            "path": str(path),
+            "pins": pins,
+            "note": "pins apply at the next image build (aisc build / docker-rebuild); "
+                    "they survive CLI updates, installer upgrades and bundle fetches",
+        }
+    form = detect_install_form()
+    try:
+        return perform_update(
+            cli_version=aisc.__version__,
+            form=form,
+            fetcher=BundleFetcher(),
+            version=version,
+            from_file=Path(from_file) if from_file else None,
+            sha256=sha256,
+            rebuild=rebuild,
+        )
+    except (UpdateError, BundleFetchError) as exc:
+        raise _to_cli_error(exc) from exc
+
+
+def print_update_text(sub: str, data: Any) -> None:
+    if not isinstance(data, dict):
+        return
+    if sub == "check":
+        print(f"form     : {data.get('form')}")
+        print(f"current  : {data.get('cli_version')}")
+        print(f"latest   : {data.get('latest_final') or '(none)'}")
+        print(f"action   : {data.get('action')}")
+        if data.get("update_available") is not None:
+            print(f"available: {data.get('update_available')}")
+        for t in data.get("tools") or []:
+            latest = t.get("latest") or "unknown"
+            mark = "*" if t.get("source") == "user" else " "
+            print(f" tool {mark} {t.get('tool')}: current {t.get('current')} "
+                  f"({t.get('source')}) | latest {latest}")
+    else:
+        if data.get("status") == "pinned":
+            print(f"status : pinned -> {data.get('path')}")
+            for k, v in (data.get("pins") or {}).items():
+                print(f"  {k}={v}")
+            print(f"note   : {data.get('note')}")
+            return
+        print(f"status: {data.get('status')}")
+        if data.get("to_version"):
+            print(f"version: {data.get('from_version')} -> {data.get('to_version')}")
+        if data.get("preserved_old_exe"):
+            print(f"old exe kept at: {data['preserved_old_exe']} (rollback copy)")
+        if data.get("rebuild_exit") is not None:
+            print(f"rebuild exit: {data['rebuild_exit']}")