@senpi/runtime 3.0.9-dev.20260710204324 → 3.0.9-dev.feat-strategy-compos.20260716233548

package/dist/composer/verbs/close.py

@@ -0,0 +1,494 @@
+"""close — safe teardown of a running strategy (slice B1; absorbs senpi-strategy-ops close.py).
+
+THE INVARIANT (non-negotiable): STOP the runtime FIRST, confirm it is gone, and only THEN
+submit the MCP ``strategy_close``. A raw ``strategy_close`` while a runtime is still live
+STRANDS the runtime (it keeps trading a wallet the server is tearing down). So per target:
+
+    1. STOP    — ``openclaw senpi runtime delete <id> --address <wallet>`` (if a runtime is
+                 live for the wallet), then CONFIRM gone by re-listing. If the delete fails
+                 (CMP220) or the runtime is still present after it (CMP221), strategy_close is
+                 WITHHELD — the verb fails loud rather than strand or double-fire.
+    2. TRIGGER — submit MCP ``strategy_close(<strategyId>)`` (flattens ALL positions, closes
+                 the strategy, returns funds). SUBMIT-ONLY, no poll: strategy_close is async.
+
+The verb is IDEMPOTENT and re-running it IS the poll:
+    - runtime already gone            → skip the delete (step 1 confirmed on entry).
+    - strategy already ACTIVE→closing → skip re-submit (only an ACTIVE/unknown status submits).
+    - strategy left the active set    → report ``closed``.
+
+Discovery precedence (report which one resolved the target):
+    (artifact) the composer's own on-box artifacts FIRST — a canonical hash dir's
+        ``install.json`` (wallet + runtime_id + strategy), or a strategy name / runtime id
+        resolved under ``<state>/strategies/``. The strategyId + status come from MCP
+        ``strategy_list`` matched by the bound wallet.
+    (legacy)   strategies the composer did NOT install (ops-deployed) — match MCP
+        ``strategy_list`` by ``strategyId == target`` or attribution ``skillName == target``;
+        sid + wallet are read from the STRATEGY RECORD (not the runtime), so orphans close too.
+    (wallet)   a bare ``0x…`` target (or ``--wallet``) is used as the wallet directly.
+
+Both the ``openclaw`` shell-out and the MCP call are behind injectable seams (see ``_box``),
+so the whole verb is tested with no box and no network.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from composer.validator.errors import Location, TeachingError
+
+from . import _box
+from ._box import (
+    CLOSED_STATUSES,
+    LIVE_STATUSES,
+    DeleteFn,
+    ListFn,
+    McpCredsMissing,
+    McpError,
+    McpFn,
+    wallet_match,
+)
+from .install import INSTALL_JSON
+
+CLOSING = "CLOSING"
+CLOSED = "CLOSED"
+REFUSED = "REFUSED"
+FAILED = "FAILED"
+
+_WALLET_ADDR = re.compile(r"^0x[0-9a-fA-F]{40}$")
+
+
+# --------------------------------------------------------------------------- strategy extractors
+# The MCP strategy_list shape is not strictly pinned; every extractor tries a few key
+# spellings and degrades to None rather than throwing (ported from senpi-strategy-ops _cli).
+
+def _dig(obj, *keys, default=None):
+    if not isinstance(obj, dict):
+        return default
+    lower = {k.lower(): v for k, v in obj.items()}
+    for k in keys:
+        if k in obj:
+            return obj[k]
+        if k.lower() in lower:
+            return lower[k.lower()]
+    return default
+
+
+def _find_list(obj, *wrappers) -> list:
+    if isinstance(obj, list):
+        return obj
+    if isinstance(obj, dict):
+        for k in wrappers + ("data", "result", "items"):
+            v = _dig(obj, k)
+            if isinstance(v, list):
+                return v
+        d = obj.get("data") if isinstance(obj.get("data"), dict) else None
+        if d:
+            return _find_list(d, *wrappers)
+    return []
+
+
+def _strategy_obj(x) -> dict:
+    if not isinstance(x, dict):
+        return {}
+    for path in (("data", "strategy"), ("strategy",), ("data",)):
+        cur = x
+        for k in path:
+            cur = cur.get(k) if isinstance(cur, dict) else None
+        if isinstance(cur, dict) and (_dig(cur, "strategyId", "id", "strategy_id")
+                                      or _dig(cur, "status", "state")):
+            return cur
+    return x
+
+
+def _strat_id(s):
+    return _dig(_strategy_obj(s), "strategyId", "id", "strategy_id")
+
+
+def _strat_status(s):
+    return _dig(_strategy_obj(s), "status", "state")
+
+
+def _strat_wallet(s):
+    return _dig(_strategy_obj(s), "strategyWalletAddress", "walletAddress", "wallet", "address")
+
+
+def _strat_skill(s):
+    o = _strategy_obj(s)
+    meta = _dig(o, "strategyMetadata", "metadata")
+    if isinstance(meta, dict):
+        sk = _dig(meta, "skillName", "skill_name")
+        if sk:
+            return sk
+    return _dig(o, "skillName", "skill_name", "skill") or _dig(o, "tradingStrategyName", "name")
+
+
+# --------------------------------------------------------------------------- resolved targets
+
+@dataclass
+class CloseTarget:
+    """One strategy to close, resolved from the CLI target."""
+
+    wallet: str
+    source: str                         # "artifact" | "legacy" | "wallet"
+    strategy_id: Optional[str] = None
+    status: Optional[str] = None
+    runtime_id: Optional[str] = None    # the id recorded in install.json (artifact source)
+    label: str = ""
+
+
+@dataclass
+class InstanceResult:
+    label: str
+    wallet: str
+    verdict: str
+    source: str
+    strategy_id: Optional[str] = None
+    runtime_id: Optional[str] = None
+    runtime: str = ""                   # "stopped" | "not_found" | "delete_failed" | "still_present"
+    strategy_status: Optional[str] = None
+    error: Optional[TeachingError] = None
+
+    def to_json(self) -> dict:
+        return {
+            "label": self.label,
+            "wallet": self.wallet,
+            "verdict": self.verdict,
+            "source": self.source,
+            "strategy_id": self.strategy_id,
+            "runtime_id": self.runtime_id,
+            "runtime": self.runtime,
+            "strategy_status": self.strategy_status,
+            "error": self.error.to_dict() if self.error else None,
+        }
+
+
+@dataclass
+class CloseResult:
+    target: str
+    verdict: str
+    instances: list[InstanceResult] = field(default_factory=list)
+    errors: list[TeachingError] = field(default_factory=list)
+    message: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.verdict in (CLOSING, CLOSED)
+
+    def to_json(self) -> dict:
+        return {
+            "verb": "close",
+            "target": self.target,
+            "verdict": self.verdict,
+            "instances": [i.to_json() for i in self.instances],
+            "error_count": len(self.errors),
+            "errors": [e.to_dict() for e in self.errors],
+            "message": self.message,
+        }
+
+    def render(self) -> str:
+        lines = [f"{self.verdict}: {self.target}"]
+        if self.message:
+            lines.append(f"  {self.message}")
+        for inst in self.instances:
+            rt = inst.runtime or "-"
+            sid = (inst.strategy_id or "")[:12]
+            lines.append(
+                f"  - {inst.label}: {inst.verdict}  (runtime: {rt}; strategy: {sid or '?'}"
+                f"{'; ' + inst.source if inst.source else ''})"
+            )
+            if inst.error:
+                lines.append("    " + inst.error.render().replace("\n", "\n    "))
+        for e in self.errors:
+            lines.append(e.render())
+        if self.verdict == CLOSING:
+            lines.append(
+                "  strategy_close is async — positions flatten on-chain. Re-run "
+                "`composer close` to poll until CLOSED (re-running is idempotent)."
+            )
+        return "\n".join(lines) + "\n"
+
+
+def _refused(target: str, error: TeachingError) -> CloseResult:
+    return CloseResult(target=target, verdict=REFUSED, errors=[error], message=error.message)
+
+
+# --------------------------------------------------------------------------- target resolution
+
+def _install_jsons_under(strategy_dir: Path) -> list[dict]:
+    """Every ``install.json`` under a ``<state>/strategies/<strategy>/`` dir (one per hash8)."""
+    out: list[dict] = []
+    if not strategy_dir.is_dir():
+        return out
+    for child in sorted(strategy_dir.iterdir()):
+        p = child / INSTALL_JSON
+        if p.is_file():
+            try:
+                out.append(json.loads(p.read_text(encoding="utf-8")))
+            except (OSError, json.JSONDecodeError):
+                continue
+    return out
+
+
+def _artifacts_for_target(target: str, base_state_dir: str) -> list[dict]:
+    """Resolve the CLI target to on-box ``install.json`` records (artifact source), if any.
+
+    Accepts: a canonical hash dir path (has install.json), a strategy dir path (has hash
+    subdirs), a strategy NAME (resolved under ``<state>/strategies/<name>/``), or a runtime id
+    (matched against every install.json's ``runtime_id``)."""
+    p = Path(target)
+    # a canonical hash dir passed directly.
+    if p.is_dir() and (p / INSTALL_JSON).is_file():
+        try:
+            return [json.loads((p / INSTALL_JSON).read_text(encoding="utf-8"))]
+        except (OSError, json.JSONDecodeError):
+            return []
+    # a strategy dir passed directly (contains hash subdirs).
+    if p.is_dir():
+        found = _install_jsons_under(p)
+        if found:
+            return found
+    strategies_root = Path(base_state_dir) / "strategies"
+    # a strategy NAME under the state dir.
+    named = _install_jsons_under(strategies_root / target)
+    if named:
+        return named
+    # a runtime id — scan every strategy's hash dirs for a matching install.json.
+    if strategies_root.is_dir():
+        for strat_dir in sorted(strategies_root.iterdir()):
+            for rec in _install_jsons_under(strat_dir):
+                if rec.get("runtime_id") == target:
+                    return [rec]
+    return []
+
+
+def _resolve_targets(target: str, base_state_dir: str, strategies: list,
+                     wallet_override: Optional[str],
+                     strategy_id_override: Optional[str]) -> list[CloseTarget]:
+    """Turn the CLI target (+ overrides) into the list of strategies to close.
+
+    Precedence: explicit override → on-box artifact → legacy MCP attribution → bare wallet."""
+    # explicit --wallet override: use it directly, resolve sid/status from strategy_list.
+    if wallet_override:
+        s = next((s for s in strategies if wallet_match(_strat_wallet(s), wallet_override)), None)
+        return [CloseTarget(
+            wallet=wallet_override, source="wallet", label=wallet_override[:14] + "…",
+            strategy_id=strategy_id_override or (_strat_id(s) if s else None),
+            status=str(_strat_status(s) or "").upper() if s else None,
+        )]
+
+    # explicit --strategy-id override: pull wallet from its strategy record.
+    if strategy_id_override:
+        s = next((s for s in strategies if _strat_id(s) == strategy_id_override), None)
+        if s is not None:
+            return [CloseTarget(
+                wallet=str(_strat_wallet(s) or ""), source="legacy",
+                strategy_id=strategy_id_override,
+                status=str(_strat_status(s) or "").upper(),
+                label=f"{_strat_skill(s) or 'strategy'}:{strategy_id_override[:8]}",
+            )]
+
+    # (artifact) the composer's own on-box artifacts FIRST.
+    artifacts = _artifacts_for_target(target, base_state_dir)
+    if artifacts:
+        out: list[CloseTarget] = []
+        for rec in artifacts:
+            wallet = str(rec.get("wallet") or "")
+            s = next((s for s in strategies if wallet_match(_strat_wallet(s), wallet)), None)
+            out.append(CloseTarget(
+                wallet=wallet, source="artifact",
+                runtime_id=rec.get("runtime_id"),
+                strategy_id=_strat_id(s) if s else None,
+                status=str(_strat_status(s) or "").upper() if s else None,
+                label=f"{rec.get('strategy') or target}:{(rec.get('hash8') or '')[:8]}",
+            ))
+        return out
+
+    # (legacy) match the strategy record by strategyId or skillName attribution.
+    legacy = [
+        s for s in strategies
+        if _strat_id(s) == target or _strat_skill(s) == target
+    ]
+    if legacy:
+        return [CloseTarget(
+            wallet=str(_strat_wallet(s) or ""), source="legacy",
+            strategy_id=_strat_id(s),
+            status=str(_strat_status(s) or "").upper(),
+            label=f"{_strat_skill(s) or 'strategy'}:{str(_strat_id(s) or '')[:8]}",
+        ) for s in legacy]
+
+    # (wallet) a bare 0x… target.
+    if _WALLET_ADDR.match(target):
+        s = next((s for s in strategies if wallet_match(_strat_wallet(s), target)), None)
+        return [CloseTarget(
+            wallet=target, source="wallet", label=target[:14] + "…",
+            strategy_id=_strat_id(s) if s else None,
+            status=str(_strat_status(s) or "").upper() if s else None,
+        )]
+
+    return []
+
+
+# --------------------------------------------------------------------------- the invariant
+
+def _live_runtime_for(runtimes: list, wallet: str, runtime_id: Optional[str]):
+    """The runtime bound to this wallet (or matching the recorded id), or None."""
+    for r in runtimes:
+        if wallet and wallet_match(r.get("wallet"), wallet):
+            return r
+        if runtime_id and r.get("name") == runtime_id:
+            return r
+    return None
+
+
+def _close_one(t: CloseTarget, list_fn: ListFn, delete_fn: DeleteFn,
+               mcp_fn: McpFn, mcp_ok: bool) -> InstanceResult:
+    """Enforce the invariant for ONE strategy: STOP runtime → CONFIRM gone → TRIGGER close."""
+    rec = InstanceResult(label=t.label or (t.wallet[:14] + "…"), wallet=t.wallet,
+                         verdict=CLOSING, source=t.source, strategy_id=t.strategy_id,
+                         runtime_id=t.runtime_id, strategy_status=t.status)
+
+    # 1. STOP the runtime FIRST (if one is live for this wallet), then CONFIRM it is gone.
+    runtimes = list_fn()
+    rt = _live_runtime_for(runtimes, t.wallet, t.runtime_id)
+    if rt is not None:
+        rname = rt.get("name") or t.runtime_id or ""
+        res = delete_fn(rname, t.wallet)
+        if not res.ok:
+            rec.verdict = FAILED
+            rec.runtime = "delete_failed"
+            rec.error = TeachingError(
+                "CMP220", f"`openclaw senpi runtime delete` failed for runtime {rname!r} "
+                          f"(exit {res.returncode}).",
+                "The runtime could NOT be stopped, so strategy_close was WITHHELD (a raw close "
+                "with a live runtime strands it). Check the box is reachable "
+                "(`openclaw senpi runtime list`) and re-run `composer close`; the delete + close "
+                "are idempotent.",
+                Location(),
+            )
+            return rec
+        # CONFIRM gone — re-list; the invariant forbids strategy_close while the delete is unconfirmed.
+        if _live_runtime_for(list_fn(), t.wallet, t.runtime_id) is not None:
+            rec.verdict = FAILED
+            rec.runtime = "still_present"
+            rec.error = TeachingError(
+                "CMP221", f"runtime {rname!r} is STILL present after delete — teardown unconfirmed.",
+                "strategy_close was WITHHELD to protect the invariant (never close a strategy "
+                "while its runtime is live). Re-run `composer close` to retry the stop; if it "
+                "persists, delete it by hand: `openclaw senpi runtime delete --id "
+                f"{rname} --address {t.wallet}`.",
+                Location(),
+            )
+            return rec
+        rec.runtime = "stopped"
+    else:
+        rec.runtime = "not_found"   # already gone (idempotent re-run) or an orphan strategy
+
+    # No strategyId → nothing (live) to close server-side.
+    if not t.strategy_id:
+        # An orphan runtime we just stopped IS the whole job; and when MCP is reachable, a
+        # wallet with no LIVE strategy means it has already left the active set → CLOSED. This is
+        # exactly the terminal state the idempotent re-run polls to.
+        if rec.runtime == "stopped":
+            rec.verdict = CLOSED
+            rec.strategy_status = "ORPHAN_RUNTIME_STOPPED"
+            return rec
+        if mcp_ok:
+            rec.verdict = CLOSED
+            rec.strategy_status = "CLOSED"
+            return rec
+        # MCP was unreachable, so we could NOT confirm the strategy is gone — fail loud, don't
+        # pretend it closed.
+        rec.verdict = FAILED
+        rec.error = TeachingError(
+            "CMP224", "resolved a wallet but could not resolve a strategyId (MCP unreachable).",
+            "strategy_list did not return, so the strategy could not be confirmed closed. Check "
+            "MCP creds/connectivity and re-run `composer close` (idempotent), or pass the "
+            "strategy explicitly with `--strategy-id <id>`.",
+            Location(),
+        )
+        return rec
+
+    status = str(t.status or "").upper()
+    # 2. TRIGGER close — but only when the strategy is still ACTIVE (or status unknown). Once
+    # triggered it leaves ACTIVE, so a re-run never re-submits (re-running IS the poll).
+    if status in CLOSED_STATUSES:
+        rec.verdict = CLOSED
+        return rec
+    if status in ("ACTIVE", ""):
+        try:
+            mcp_fn("strategy_close", strategyId=t.strategy_id, timeout=_box._SUBMIT_TIMEOUT)
+        except McpError as e:
+            rec.verdict = FAILED
+            rec.error = TeachingError(
+                "CMP222", f"MCP `strategy_close` submit failed: {str(e)[:200]}.",
+                "The runtime is already stopped, so re-running `composer close` will retry the "
+                "close only (idempotent). If it keeps failing, verify the strategy is still open "
+                "in `strategy_list` and that MCP creds are valid.",
+                Location(),
+            )
+            return rec
+    # ACTIVE→submitted, or an in-flight status (e.g. CLOSING_POSITIONS) we don't re-submit.
+    rec.verdict = CLOSING
+    return rec
+
+
+# --------------------------------------------------------------------------- the verb
+
+def run_close(
+    target: str,
+    base_state_dir: str,
+    *,
+    wallet: Optional[str] = None,
+    strategy_id: Optional[str] = None,
+    list_fn: ListFn = _box.default_list_runtimes,
+    delete_fn: DeleteFn = _box.default_delete_runtime,
+    mcp_fn: McpFn = _box.default_mcp_call,
+) -> CloseResult:
+    """Close a strategy safely (see module docstring)."""
+    if wallet and not _WALLET_ADDR.match(wallet):
+        return _refused(target, TeachingError(
+            "CMP205", "`--wallet` is not a 0x… address.",
+            "Pass a 40-hex `0x…` wallet, or omit `--wallet` and pass the strategy name / "
+            "runtime id / strategyId as the target.",
+            Location(),
+        ))
+
+    # Fetch live strategies ONCE (shared across resolution + every close_one). Missing creds is
+    # a loud CMP223 (never a silent skip that would fail to submit strategy_close).
+    mcp_ok = True
+    try:
+        raw = mcp_fn("strategy_list", status=LIVE_STATUSES)
+        strategies = _find_list(raw, "strategies")
+    except McpCredsMissing as e:
+        return _refused(target, TeachingError(
+            "CMP223", f"MCP credentials missing: {e}",
+            "Set SENPI_AUTH_TOKEN or SENPI_API_KEY (and optionally SENPI_MCP_URL) in the environment — close needs "
+            "the MCP server to resolve the strategyId and submit strategy_close.",
+            Location(),
+        ))
+    except McpError:
+        strategies, mcp_ok = [], False   # transport hiccup — degrade to artifact-only
+
+    targets = _resolve_targets(target, base_state_dir, strategies, wallet, strategy_id)
+    if not targets:
+        return _refused(target, TeachingError(
+            "CMP225", f"could not resolve {target!r} to any strategy to close.",
+            "Pass a strategy the composer installed (a name / runtime id under the state dir, or "
+            "a canonical hash dir), a bare `0x…` wallet, or — for an ops-deployed strategy — its "
+            "strategyId or attribution skillName. `strategy_list` shows open strategies.",
+            Location(),
+        ))
+
+    instances = [_close_one(t, list_fn, delete_fn, mcp_fn, mcp_ok) for t in targets]
+    verdicts = {i.verdict for i in instances}
+    overall = (FAILED if FAILED in verdicts else
+               CLOSING if CLOSING in verdicts else CLOSED)
+    n = len(instances)
+    msg = (f"closed {n} strateg{'y' if n == 1 else 'ies'}." if overall == CLOSED else
+           f"closing {n} strateg{'y' if n == 1 else 'ies'} (runtime(s) stopped)." if overall == CLOSING
+           else "one or more instances failed to close cleanly (see below).")
+    return CloseResult(target=target, verdict=overall, instances=instances, message=msg)