rig-cli 1.0.0__py3-none-any.whl

rig/commands/ps.py

@@ -0,0 +1,149 @@
+"""Process status inspection across all machine checkouts."""
+
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import compose_record_alive
+from rig.core.constants import EXIT_OK, LOCK_FILE_NAME, STATE_FILE_NAME
+from rig.core.errors import print_json_envelope
+from rig.core.identity import get_instances_dir, is_locked
+from rig.core.state import read_state
+from rig.core.terminal import contract_path, format_table, get_theme, middle_truncate, visible_width
+from rig.net.health import wait_for_http
+from rig.proc.process import identity_matches, pid_alive
+
+SUMMARY_MAX_LENGTH = 24
+
+
+def _is_record_running(srec: dict[str, Any], root: Path | None, stype: str) -> bool:
+    if stype == "compose":
+        return compose_record_alive(srec, root or Path("."))
+    pid = srec.get("pid")
+    return isinstance(pid, int) and pid_alive(pid) and identity_matches(srec)
+
+
+def _check_service_health(srec: dict[str, Any], port: Any, pid: Any) -> str:
+    hp = srec.get("healthcheck_path") or srec.get("health") or "/"
+    return "healthy" if wait_for_http(int(port), hp, (1.0, pid, srec.get("pgid"))) else "unhealthy"
+
+
+def _inspect_instance_service(
+    srec: dict[str, Any], root: Path | None, health: bool
+) -> tuple[dict[str, Any], bool]:
+    stype, port, pid = srec.get("type", "unknown"), srec.get("port"), srec.get("pid")
+    alive = _is_record_running(srec, root, stype)
+    h_status = _check_service_health(srec, port, pid) if health and alive and port else None
+    return {
+        "type": stype,
+        "status": "running" if alive else "stopped",
+        "port": port,
+        "url": srec.get("url"),
+        "pid": pid,
+        "health": h_status,
+    }, alive
+
+
+def _summarize_instance(inst_dir: Path, health: bool) -> dict[str, Any] | None:
+    if not (state_file := inst_dir / STATE_FILE_NAME).is_file():
+        return None
+    state = read_state(state_file)
+    inst_id, root_str = state.get("instance") or inst_dir.name, state.get("root")
+    root_path = Path(root_str).resolve() if root_str else None
+    root_exists = root_path.is_dir() if root_path else False
+    svcs = state.get("services", {})
+    inspected = {n: _inspect_instance_service(r, root_path, health) for n, r in svcs.items()}
+    running = sum(bool(alive) for _, alive in inspected.values())
+    if not root_exists:
+        status = "orphaned"
+    elif svcs and running == len(svcs):
+        status = "running"
+    else:
+        status = "partial" if running > 0 else "stopped"
+    return {
+        "instance": inst_id,
+        "project": state.get("project") or inst_id.rsplit("-", 1)[0],
+        "mode": state.get("mode") or "default",
+        "status": status,
+        "locked": is_locked(inst_dir / LOCK_FILE_NAME),
+        "root": root_str,
+        "root_exists": root_exists,
+        "services_running": running,
+        "services_total": len(svcs),
+        "services": {n: info for n, (info, _) in inspected.items()},
+    }
+
+
+def _ps_badge(st: str, th: Any) -> str:
+    badges = {"running": (th.green, "●"), "partial": (th.yellow, "▲"), "stopped": (th.red, "○")}
+    col, gly = badges.get(st, (th.magenta, "✖"))
+    return f"{col}{gly} {st}{th.r}"
+
+
+def _format_ps_prefix(it: dict[str, Any], th: Any, wide: bool) -> list[str]:
+    summary = ", ".join(f"{s}:{info['status']}" for s, info in it["services"].items()) or "none"
+    if len(summary) > SUMMARY_MAX_LENGTH:
+        summary = f"{it['services_running']}/{it['services_total']} up"
+    inst, proj = it["instance"], it["project"]
+    short_id = inst if wide or not inst.startswith(f"{proj}-") else inst[len(proj) + 1 :]
+    return [
+        f"{th.b}{proj}{th.r}",
+        f"{th.d}{short_id}{th.r}",
+        f"{th.cyan}{it['mode']}{th.r}",
+        _ps_badge(it["status"], th),
+        summary,
+    ]
+
+
+def _format_ps_root(it: dict[str, Any], avail: int | None) -> str:
+    r_str = contract_path(it["root"] or "n/a")
+    suffix = "" if it["root_exists"] else " [deleted]"
+    if avail is None:
+        return r_str + suffix
+    budget = max(8, avail - len(suffix)) if suffix else avail
+    return middle_truncate(r_str, budget) + suffix
+
+
+def _build_ps_rows(instances: list[dict[str, Any]], wide: bool) -> list[list[str]]:
+    th = get_theme()
+    pre = [_format_ps_prefix(it, th, wide) for it in instances]
+    avail = None
+    if not wide and sys.stdout.isatty():
+        all_p = [["PROJECT", "ID", "MODE", "STATUS", "SERVICES"], *pre]
+        p_w = 2 + sum(max(visible_width(r[i]) for r in all_p) for i in range(5)) + 10
+        avail = max(15, shutil.get_terminal_size((80, 24)).columns - p_w)
+    return [
+        [*p, f"{th.d}{_format_ps_root(it, avail)}{th.r}"]
+        for it, p in zip(instances, pre, strict=True)
+    ]
+
+
+def _print_table(instances: list[dict[str, Any]], wide: bool = False) -> None:
+    headers = ["PROJECT", "INSTANCE" if wide else "ID", "MODE", "STATUS", "SERVICES", "ROOT"]
+    for line in format_table(headers, _build_ps_rows(instances, wide), gutter=4 if wide else 2):
+        print(f"  {line}")
+    print()
+
+
+def _collect_instances(instances_dir: Path, health: bool) -> list[dict[str, Any]]:
+    if not instances_dir.is_dir():
+        return []
+    return [
+        i
+        for d in sorted(instances_dir.iterdir())
+        if d.is_dir() and (i := _summarize_instance(d, health))
+    ]
+
+
+def cmd_ps(health: bool = False, as_json: bool = False, wide: bool = False) -> int:
+    instances_data = _collect_instances(get_instances_dir(), health)
+    if as_json:
+        print_json_envelope("ps", {"instances": instances_data})
+    elif not instances_data:
+        print("No active or recorded rig instances found.")
+    else:
+        _print_table(instances_data, wide=wide)
+    return EXIT_OK

rig/commands/status.py

@@ -0,0 +1,149 @@
+"""Status inspection and formatting command."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import (
+    _resolve_manifest_context,
+    is_service_verifiable_alive,
+    prune_state,
+    record_status,
+)
+from rig.core.constants import EXIT_OK
+from rig.core.errors import print_json_envelope
+from rig.core.identity import get_instances_dir
+from rig.core.locks import exclusive_lock
+from rig.core.state import read_state, write_state
+from rig.core.terminal import Theme, format_table, get_theme
+from rig.manifest.models import Manifest
+from rig.net.health import wait_for_http
+
+
+def _format_service_health(record: Mapping[str, Any], service: Any) -> str:
+    if not (service.healthcheck_path and record.get("port")):
+        return "-"
+    ctx = (1.0, record.get("pid"), record.get("pgid"))
+    ready = wait_for_http(int(record["port"]), service.healthcheck_path, ctx)
+    return "healthy" if ready else "unhealthy"
+
+
+def _process_ident(record: Mapping[str, Any] | None) -> str:
+    if pid := (record or {}).get("pid"):
+        return f"pid:{pid}"
+    return f"container:{str(c)[:12]}" if (c := (record or {}).get("container")) else "-"
+
+
+def _status_badge(st: str, h: str, th: Theme) -> str:
+    if st == "running":
+        return f"{th.yellow}▲ degraded{th.r}" if h == "unhealthy" else f"{th.green}● running{th.r}"
+    return f"{th.red}{'✖ error' if st == 'error' else '○ stopped'}{th.r}"
+
+
+def _health_badge(raw_h: str, th: Theme) -> str:
+    tags = {"healthy": f"{th.green}✓ healthy{th.r}", "unhealthy": f"{th.red}✖ failing{th.r}"}
+    return tags.get(raw_h, f"{th.d}-{th.r}")
+
+
+def _build_service_row(
+    name: str, ctx: tuple[Mapping[str, Any] | None, Any, Path]
+) -> tuple[str, str, list[str]]:
+    record, service, root = ctx
+    th = get_theme()
+    if record is None:
+        d = f"{th.d}-{th.r}"
+        return "stopped", "-", [f"{th.red}○ stopped{th.r}", f"{th.b}{name}{th.r}", d, d, d]
+    raw_st = record_status(record, root)
+    raw_h = _format_service_health(record, service) if raw_st == "running" else "-"
+    ep = f"{th.cyan}{u}{th.r}" if (u := record.get("url")) else f"{th.d}-{th.r}"
+    row = [
+        _status_badge(raw_st, raw_h, th),
+        f"{th.b}{name}{th.r}",
+        ep,
+        _health_badge(raw_h, th),
+        f"{th.d}{_process_ident(record)}{th.r}",
+    ]
+    return raw_st, raw_h, row
+
+
+def _collect_status_rows(
+    manifest: Manifest, state: Mapping[str, Any], root: Path
+) -> tuple[list[list[str]], list[str], int]:
+    rows, degraded, running = [], [], 0
+    for name in sorted(manifest.services):
+        rec = state.get("services", {}).get(name)
+        st_val, hlth_val, row = _build_service_row(name, (rec, manifest.services[name], root))
+        running += int(st_val == "running")
+        if hlth_val == "unhealthy" or st_val == "error":
+            degraded.append(name)
+        rows.append(row)
+    return rows, degraded, running
+
+
+def _print_degraded(degraded: list[str], inst_id: str | None, th: Theme) -> None:
+    if not (degraded and inst_id):
+        return
+    inst_dir = get_instances_dir() / inst_id
+    count = len(degraded)
+    label = "service degraded" if count == 1 else "services degraded"
+    print(f"  {th.yellow}▲ {count} {label}. View logs:{th.r}")
+    for sname in degraded:
+        print(f"    {th.d}{sname} ➜{th.r} {inst_dir / 'logs' / f'{sname}.log'}")
+    print()
+
+
+def _print_status(manifest: Manifest, state: Mapping[str, Any], root: Path) -> None:
+    th, headers = get_theme(), ["STATUS", "SERVICE", "ENDPOINT", "HEALTH", "PROCESS"]
+    rows, degraded, running = _collect_status_rows(manifest, state, root)
+    total = len(manifest.services)
+    mode_str = f" {th.cyan}[{manifest.active_mode}]{th.r}" if manifest.active_mode else ""
+    stopped_str = f" {th.red}({total - running} stopped){th.r}" if running != total else ""
+    col = th.green if running == total and total > 0 else th.yellow
+    badge = f"{col}{running}/{total} running{th.r}{stopped_str}"
+    print(f"\n  {th.b}{manifest.project}{th.r}{mode_str}  {th.d}·{th.r}  {badge}\n")
+    for line in format_table(headers, rows, gutter=4):
+        print(f"  {line}")
+    print()
+    _print_degraded(degraded, state.get("instance"), th)
+
+
+def _print_status_json(
+    manifest: Manifest, state: Mapping[str, Any], ctx: tuple[Path, str, str | None]
+) -> None:
+    root, instance, mode = ctx
+    info = {
+        s: {
+            "running": bool(r and is_service_verifiable_alive(r, root)),
+            "type": manifest.services[s].type,
+            "port": (r or {}).get("port"),
+            "url": (r or {}).get("url"),
+            "pid": (r or {}).get("pid"),
+        }
+        for s in sorted(manifest.services)
+        for r in [state.get("services", {}).get(s)]
+    }
+    payload = {
+        "project": manifest.project,
+        "instance": instance,
+        "mode": mode or "default",
+        "generation": state.get("generation", 0),
+        "services": info,
+    }
+    print_json_envelope("status", payload)
+
+
+def cmd_status(root: Path, manifest_path: Path, as_json: bool = False) -> int:
+    raw_m, root_p, inst, s_path, l_path = _resolve_manifest_context(root, manifest_path)
+    with exclusive_lock(l_path):
+        state = read_state(s_path)
+        if prune_state(state, root_p):
+            write_state(s_path, state)
+        active_mode = state.get("mode")
+        manifest = raw_m.for_mode(active_mode) if raw_m.modes else raw_m
+        if as_json:
+            _print_status_json(manifest, state, (root_p, inst, active_mode))
+        else:
+            _print_status(manifest, state, root_p)
+    return EXIT_OK

rig/commands/up/__init__.py

@@ -0,0 +1,111 @@
+"""Orchestrator for rig up command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import _resolve_manifest_context, prune_state
+from rig.commands.status import _print_status
+from rig.commands.up.loop import _start_loop, _switch_mode
+from rig.commands.up.relink import _relink_affected
+from rig.commands.up.runner import _rollback, _start_with_retry
+from rig.commands.up.service import (
+    _await_ready,
+    _check_port_listener,
+    _start_service,
+)
+from rig.core.constants import EXIT_OK
+from rig.core.errors import print_json_envelope
+from rig.core.identity import get_boot_id
+from rig.core.locks import ensure_runtime_dir, exclusive_lock
+from rig.core.state import read_state, write_state
+from rig.manifest.models import Manifest
+
+
+def _run_up_transaction(
+    order: list[str],
+    manifest: Manifest,
+    ctx: tuple[tuple[Path, Path, str, Path], tuple[str, bool, bool]],
+) -> int:
+    paths, cfgs = ctx
+    root_path, runtime, instance, state_path = paths
+    selected_mode, switch, as_json = cfgs
+    state = read_state(state_path)
+    state.update(
+        {
+            "instance": instance,
+            "project": manifest.project,
+            "root": str(root_path),
+            "boot_id": get_boot_id(),
+        }
+    )
+    _switch_mode(state, (root_path, state_path), (selected_mode, switch))
+    prune_state(state, root_path)
+    write_state(state_path, state)
+
+    relink = _relink_affected(order, manifest, (state, root_path, state_path, as_json))
+    if isinstance(relink, int):
+        return relink
+    res = _start_loop(relink, manifest, (state, root_path, runtime, instance, state_path, as_json))
+    if isinstance(res, int):
+        return res
+    state["generation"] = int(state.get("generation", 0)) + 1
+    write_state(state_path, state)
+    return EXIT_OK
+
+
+def _finish_up_output(ctx: tuple[str, str, Path, Path], manifest: Manifest, as_json: bool) -> None:
+    instance, selected_mode, state_path, root_path = ctx
+    if as_json:
+        payload = {
+            "instance": instance,
+            "project": manifest.project,
+            "mode": selected_mode,
+            "generation": read_state(state_path).get("generation", 0),
+            "services": read_state(state_path).get("services", {}),
+        }
+        print_json_envelope("up", payload)
+    else:
+        _print_status(manifest, read_state(state_path), root_path)
+
+
+def cmd_up(root: Path, manifest_path: Path, *args: Any, **kwargs: Any) -> int:
+    argv = list(args)
+    scope = kwargs.get("scope") or (argv.pop(0) if argv else "full")
+    mode = kwargs.get("mode") if "mode" in kwargs else (argv.pop(0) if argv else None)
+    switch = kwargs.get("switch") if "switch" in kwargs else (argv.pop(0) if argv else False)
+    as_json = kwargs.get("as_json") if "as_json" in kwargs else (argv.pop(0) if argv else False)
+
+    raw_m, root_path, instance, state_path, lock_path = _resolve_manifest_context(
+        root, manifest_path
+    )
+    manifest = raw_m.for_mode(mode) if mode or raw_m.modes else raw_m
+    selected_mode = manifest.active_mode or "default"
+    order = manifest.resolve_scope(scope)
+    runtime = ensure_runtime_dir(root_path)
+
+    with exclusive_lock(lock_path):
+        res = _run_up_transaction(
+            order,
+            manifest,
+            ((root_path, runtime, instance, state_path), (selected_mode, switch, as_json)),
+        )
+        if res != EXIT_OK:
+            return res
+
+    _finish_up_output((instance, selected_mode, state_path, root_path), manifest, as_json)
+    return EXIT_OK
+
+
+__all__ = [
+    "_await_ready",
+    "_check_port_listener",
+    "_relink_affected",
+    "_rollback",
+    "_start_loop",
+    "_start_service",
+    "_start_with_retry",
+    "_switch_mode",
+    "cmd_up",
+]

rig/commands/up/context.py

@@ -0,0 +1,36 @@
+"""Typed parameter contexts for rig up services, retries, and rollbacks."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from rig.manifest.models import Manifest
+
+
+@dataclass(frozen=True)
+class ServiceContext:
+    root: Path
+    runtime: Path
+    instance: str = ""
+    values: Mapping[str, Any] = field(default_factory=dict)
+    candidate_ports: Sequence[int] | None = None
+
+
+@dataclass
+class RetryContext:
+    root: Path
+    runtime: Path
+    instance: str
+    state: dict[str, Any]
+    state_path: Path
+
+
+@dataclass(frozen=True)
+class RollbackContext:
+    state: dict[str, Any]
+    state_path: Path
+    root: Path = Path(".")
+    manifest: Manifest | None = None

rig/commands/up/loop.py

@@ -0,0 +1,150 @@
+"""Mode switching and service initialization loop for rig up."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import (
+    _stop_record,
+    is_service_active_in_mode,
+    is_service_verifiable_alive,
+    reverse_dependency_order,
+)
+from rig.commands.up.context import RollbackContext
+from rig.commands.up.rollback import rollback_started
+from rig.commands.up.runner import _start_with_retry
+from rig.core.constants import EXIT_MUTEX_CONFLICT, EXIT_OP_FAILED, EXIT_REFUSED
+from rig.core.errors import RigError
+from rig.core.state import write_state
+from rig.manifest.models import Manifest
+
+_ABORT_EXCEPTIONS = (
+    KeyboardInterrupt,
+    SystemExit,
+    RigError,
+    OSError,
+    RuntimeError,
+    ValueError,
+)
+
+
+def _stop_one_service_for_switch(sname: str, rec: dict[str, Any], root: Path) -> None:
+    outcome = _stop_record(rec, root)
+    if outcome not in ("terminated", "killed", "stale"):
+        raise RigError(
+            f"service {sname!r} failed to stop during mode switch ({outcome})",
+            code="E_SWITCH_FAILED",
+            exit_code=EXIT_REFUSED,
+        )
+
+
+def _stop_services_for_switch(state: dict[str, Any], root: Path) -> None:
+    for sname in reverse_dependency_order(state.get("services", {})):
+        rec = state["services"].get(sname)
+        if rec:
+            _stop_one_service_for_switch(sname, rec, root)
+            state["services"].pop(sname, None)
+
+
+def _switch_mode(
+    state: dict[str, Any], paths: tuple[Path, Path], mode_cfg: tuple[str, bool]
+) -> None:
+    root, state_path = paths
+    mode, switch = mode_cfg
+    current_mode = state.get("mode")
+    services = state.get("services", {}).values()
+    active = sum(1 for rec in services if is_service_active_in_mode(rec, root))
+    if current_mode and current_mode != mode and active > 0:
+        if not switch:
+            head = f"Stack is currently running in {current_mode!r} mode"
+            hint = f"Re-run with 'rig up --switch --mode {mode}' to stop {current_mode!r} first"
+            msg = f"stack in {current_mode!r}; cannot start in {mode!r} without --switch"
+            raise RigError(
+                msg,
+                code="E_MODE_CONFLICT",
+                exit_code=EXIT_MUTEX_CONFLICT,
+                headline=head,
+                hint=hint,
+            )
+        _stop_services_for_switch(state, root)
+        write_state(state_path, state)
+    state["mode"] = mode
+
+
+def _reclaim_dead_service(name: str, root: Path, state_ctx: tuple[dict[str, Any], Path]) -> bool:
+    state, state_path = state_ctx
+    if not (existing := state["services"].get(name)):
+        return True
+    if _stop_record(existing, root, remove=True) not in ("terminated", "killed", "stale"):
+        return False
+    state["services"].pop(name, None)
+    write_state(state_path, state)
+    return True
+
+
+def _start_step(
+    name: str,
+    manifest: Manifest,
+    ctx: tuple[Path, Path, str, dict[str, Any], Path],
+) -> tuple[dict[str, Any] | None, Exception | None]:
+    root, runtime, instance, state, state_path = ctx
+    service = manifest.services[name]
+    if not _reclaim_dead_service(name, root, (state, state_path)):
+        err = RigError(
+            f"service {name!r} could not be reclaimed before start",
+            code="E_SERVICE_UNHEALTHY",
+            exit_code=EXIT_OP_FAILED,
+        )
+        return None, err
+    try:
+        rec = _start_with_retry(service, root, runtime, instance, state, state_path)
+    except RigError as exc:
+        return None, exc
+    except _ABORT_EXCEPTIONS:
+        write_state(state_path, state)
+        raise
+    return rec, None
+
+
+def _handle_step_failure(name: str, exc: Exception, as_json: bool) -> int:
+    if as_json:
+        if isinstance(exc, RigError):
+            raise exc
+        raise RigError(
+            f"failed to start {name}: {exc}", code="E_START_FAILED", exit_code=EXIT_OP_FAILED
+        ) from None
+    return exc.exit_code if isinstance(exc, RigError) else EXIT_OP_FAILED
+
+
+def _handle_timeout(name: str, as_json: bool) -> int:
+    timeout_err = RigError(
+        f"service {name!r} failed to reach healthy state",
+        code="E_START_TIMEOUT",
+        exit_code=EXIT_OP_FAILED,
+    )
+    if as_json:
+        raise timeout_err
+    return timeout_err.exit_code
+
+
+def _start_loop(
+    order: list[str],
+    manifest: Manifest,
+    ctx: tuple[dict[str, Any], Path, Path, str, Path, bool],
+) -> int | None:
+    state, root, runtime, instance, state_path, as_json = ctx
+    started: list[str] = []
+    for name in order:
+        existing = state["services"].get(name)
+        if existing and is_service_verifiable_alive(existing, root):
+            continue
+        rec, err = _start_step(name, manifest, (root, runtime, instance, state, state_path))
+        if err is not None:
+            rollback_started(started, RollbackContext(state, state_path, root, manifest))
+            return _handle_step_failure(name, err, as_json)
+        if rec is None:
+            rollback_started(started, RollbackContext(state, state_path, root, manifest))
+            return _handle_timeout(name, as_json)
+        started.append(name)
+    return None

rig/commands/up/relink.py

@@ -0,0 +1,88 @@
+"""Affected dependent service resolution and cleanup for rig up."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from rig.commands.common import (
+    _consumers_of,
+    _merged_depends_on,
+    _stop_record,
+    is_service_verifiable_alive,
+    reverse_dependency_order,
+)
+from rig.core.constants import EXIT_OP_FAILED
+from rig.core.errors import RigError
+from rig.core.state import write_state
+from rig.manifest.models import Manifest
+
+
+def _track_consumer(
+    dep: str, svcs: dict[str, Any], tracking: tuple[set[str], list[str], set[str]]
+) -> None:
+    affected, queue, seen = tracking
+    if dep in svcs:
+        affected.add(dep)
+    if dep not in seen:
+        seen.add(dep)
+        queue.append(dep)
+
+
+def _find_affected(
+    order: list[str], manifest: Manifest, state_and_root: tuple[dict[str, Any], Path]
+) -> set[str]:
+    state, root = state_and_root
+    svcs = state["services"]
+    missing = [n for n in order if n not in svcs or not is_service_verifiable_alive(svcs[n], root)]
+    affected, queue, seen = set(), list(missing), set(missing)
+    while queue:
+        curr = queue.pop(0)
+        for dep in _consumers_of(curr, svcs, manifest):
+            _track_consumer(dep, svcs, (affected, queue, seen))
+    return affected
+
+
+def _stop_affected(
+    affected: set[str], manifest: Manifest, ctx: tuple[dict[str, Any], Path, Path]
+) -> set[str]:
+    state, root, state_path = ctx
+    svcs = state["services"]
+    dep_dict = {
+        name: {"depends_on": sorted(_merged_depends_on(name, svcs[name], manifest))}
+        for name in affected
+    }
+    stop_order = reverse_dependency_order(dep_dict)
+    failed_stops: set[str] = set()
+    for dep_name in stop_order:
+        if any(c in failed_stops for c in _consumers_of(dep_name, svcs, manifest)):
+            failed_stops.add(dep_name)
+            continue
+        outcome = _stop_record(svcs[dep_name], root)
+        if outcome not in ("terminated", "killed", "stale"):
+            failed_stops.add(dep_name)
+        else:
+            svcs.pop(dep_name, None)
+            write_state(state_path, state)
+    return failed_stops
+
+
+def _relink_affected(
+    order: list[str], manifest: Manifest, ctx: tuple[dict[str, Any], Path, Path, bool]
+) -> list[str] | int:
+    state, root, state_path, as_json = ctx
+    affected = _find_affected(order, manifest, (state, root))
+    if not affected:
+        return order
+    failed_stops = _stop_affected(affected, manifest, (state, root, state_path))
+    if failed_stops:
+        err = RigError(
+            f"cleanup failed for dependent services: {', '.join(failed_stops)}",
+            code="E_CLEANUP_FAILED",
+            exit_code=EXIT_OP_FAILED,
+        )
+        if as_json:
+            raise err
+        return err.exit_code
+    extra = [name for name in affected if name in manifest.services]
+    return manifest.resolve_services(order + extra)