@senpi/runtime 3.0.0-dev.openclaw-upgrade-mai.20260623210452 → 3.0.0-dev.runtime-phase-2.20260623210537

package/dist/runtime/reconcile-run.js

@@ -1,173 +0,0 @@
-/**
- * Impure reconcile executor: wires decideReconcile (pure) with the I/O side-effects
- * (adoptPosition, resizePosition, archiveGoneState).
- *
- * Design contract:
- * - decideReconcile is the SOLE decision source (no second gone-computation here).
- * - CH fetch returning null/undefined → success:false, zero mutations (R7 fail-safe).
- * - getOpenPositions undefined (CH never fetched) → success:false, zero mutations.
- * - Execution order within the serialize pass: archive gone FIRST, then adopt/resize
- *   (frees state before re-adopting; mirrors monitor order).
- * - Each action is individually try/caught; one failure does not abort the rest.
- * - Only successfully applied actions count toward ReconcileCounts.
- */
-import { decideReconcile } from "./reconcile-decide.js";
-import { archiveGoneState } from "./reconcile-state.js";
-import { createLogger } from "../utils/logger.js";
-const logger = createLogger("[senpi-core][reconcile-run]");
-// ─── OpenPosition → PositionOpenedEvent mapping ───────────────────────────────
-/**
- * Map an OpenPosition (from clearinghouse) to the PositionOpenedEvent shape expected
- * by adoptPosition / resizePosition.
- *
- * Field mapping:
- *   address  → address (strategy wallet; same as deps.address)
- *   wallet   → position.wallet if set, else address (clearinghouse rows rarely carry wallet)
- *   coin     → position.coin
- *   szi      → String(position.szi)   — signed; positive=LONG, negative=SHORT
- *   entryPx  → String(position.entryPx ?? 0)
- *   leverage → position.leverage ?? 1
- *   dex      → position.dex if non-empty, else undefined (handlePositionOpened normalizes "")
- *
- * Note: PositionOpenedEvent.szi is a string (the handler parses it); OpenPosition.szi is a number.
- */
-export function openPositionToPayload(pos, address) {
-    const dex = (pos.dex ?? "").trim();
-    return {
-        address,
-        wallet: pos.wallet ?? address,
-        coin: pos.coin,
-        szi: String(pos.szi ?? 0),
-        entryPx: String(pos.entryPx ?? 0),
-        leverage: pos.leverage ?? 1,
-        ...(dex ? { dex } : { dex: "" }),
-    };
-}
-// ─── Executor ─────────────────────────────────────────────────────────────────
-export async function runReconcile(deps) {
-    const { address, strategyState, senpi, stateManager, adopter, bus, serialize = (fn) => fn(), } = deps;
-    const zeroCounts = { adopted: 0, resized: 0, archived: 0 };
-    // Fetch the exchange snapshot + list DSL state + decide + execute, ALL inside the
-    // serialize lock, so the exchange view and the DSL view are captured atomically vs
-    // the trade loop.
-    //
-    // BUG 3 fix: list DSL state + decide INSIDE the lock so the plan is computed against
-    // the same DSL snapshot the execute pass mutates.
-    // BUG 5 fix (bugbot #156): fetch the exchange snapshot INSIDE the lock too. Capturing
-    // it outside (a caller prefetch, or a pre-lock fetch) let a concurrent new-entry land
-    // between snapshot and decision — reconcile then saw a DSL position absent from the
-    // STALE exchange set, emitted "gone", and archived a LIVE managed position. Fetching
-    // here means no trade can interleave between the exchange read and the DSL read. Cost:
-    // one extra clearinghouse fetch per address per tick (the monitor's per-tick gate fetch
-    // is the first; the dropped `prefetched` flag reused it, but that snapshot was the stale
-    // one). Negligible against the monitor cadence (30s default, 5s floor).
-    const outcome = await serialize(async () => {
-        // PROPOSED (deferred — larger change, not implemented here):
-        // This clearinghouse fetch runs INSIDE the reconcile lock and has no time limit. A
-        // genuinely hung MCP connection (a freeze, not just slowness) would hold the lock
-        // indefinitely and could stall stop() (which drains the consumer that contends this
-        // lock). The risk is pre-existing and shared by EVERY in-lock exchange call (trade-path
-        // create/close, etc.), not just this one — so the fix belongs at that whole layer.
-        //   Proposed policy (callTool already accepts an AbortSignal; we just don't pass one):
-        //     - while running: bound each in-lock exchange call with a timeout + up to 3 retries,
-        //       then give up. A clean give-up is safe — the gate stays closed and self-heals on
-        //       the next boot-retry / monitor tick once MCP recovers.
-        //     - on shutdown: give up after ~30s (no retries) so stop() can never hang.
-        const ch = await strategyState.fetchClearinghouseState();
-        if (ch == null) {
-            logger.warn("reconcile-run: fetchClearinghouseState returned null/undefined — skipping (R7 fail-safe)", {
-                address,
-            });
-            return { unavailable: true };
-        }
-        const exchangePositions = strategyState.getOpenPositions();
-        if (exchangePositions === undefined) {
-            logger.warn("reconcile-run: getOpenPositions returned undefined (clearinghouse never fetched) — skipping", {
-                address,
-            });
-            return { unavailable: true };
-        }
-        const runtimeDslStates = await stateManager.listDslStates(address);
-        const decision = decideReconcile({ address, exchangePositions, runtimeDslStates });
-        const c = { adopted: 0, resized: 0, archived: 0 };
-        // BUG 2 fix: track action failures so success reflects whether the reconcile
-        // ACTIONS actually applied, not merely that CH was fetched + a decision ran.
-        let f = 0;
-        // Archive gone FIRST (frees state slots before re-adopting).
-        for (const action of decision.actions) {
-            if (action.kind !== "gone")
-                continue;
-            try {
-                const outcome = await archiveGoneState(stateManager, senpi, action.state, {
-                    bus,
-                    strategyState,
-                });
-                if (outcome === "archived")
-                    c.archived++;
-                // "skipped" is a by-design no-op (a different live position now holds the key, or
-                // the state is already gone) — NOT a failure. Only "failed" blocks the gate.
-                else if (outcome === "failed")
-                    f++;
-            }
-            catch (err) {
-                f++;
-                logger.warn("reconcile-run: archiveGoneState threw unexpectedly", {
-                    address,
-                    coin: action.coin,
-                    dex: action.dex,
-                    err,
-                });
-            }
-        }
-        // Adopt orphaned positions.
-        for (const action of decision.actions) {
-            if (action.kind !== "adopt")
-                continue;
-            try {
-                await adopter.adoptPosition(openPositionToPayload(action.position, address));
-                c.adopted++;
-            }
-            catch (err) {
-                f++;
-                logger.warn("reconcile-run: adoptPosition failed", {
-                    address,
-                    coin: action.coin,
-                    dex: action.dex,
-                    err,
-                });
-            }
-        }
-        // Resize drifted positions.
-        for (const action of decision.actions) {
-            if (action.kind !== "resize")
-                continue;
-            try {
-                await adopter.resizePosition(openPositionToPayload(action.position, address));
-                c.resized++;
-            }
-            catch (err) {
-                f++;
-                logger.warn("reconcile-run: resizePosition failed", {
-                    address,
-                    coin: action.coin,
-                    dex: action.dex,
-                    err,
-                });
-            }
-        }
-        return { unavailable: false, counts: c, failures: f, decided: decision.actions.length };
-    });
-    // CH unavailable / never fetched → R7 fail-safe (success:false, no mutation).
-    if (outcome.unavailable) {
-        return { success: false, counts: zeroCounts };
-    }
-    const { counts, failures, decided } = outcome;
-    // success only when every decided action applied. Zero actions (converged) → success.
-    const success = failures === 0;
-    if (decided === 0) {
-        return { success: true, counts: zeroCounts };
-    }
-    logger.info("reconcile-run: complete", { address, counts, failures, success });
-    return { success, counts };
-}
-//# sourceMappingURL=reconcile-run.js.map

package/dist/runtime/reconcile-run.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reconcile-run.js","sourceRoot":"","sources":["../../src/runtime/reconcile-run.ts"],"names":[],"mappings":"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"}

package/dist/scanners/external/scaffold/ctx.py

@@ -1,78 +0,0 @@
-"""The author-facing `ctx` object handed to scan(inputs, ctx).
-
-`ScanContext` is the second argument to the author's `scan(inputs, ctx)`. It is
-two tiers (design §2.1):
-
-  Capabilities you CALL:
-    state       — the StateManager (B2): a disk-persisted, bounded, transactional
-                  series. Passed in AS-IS (never wrapped/copied) so author mutations
-                  and the scaffold's commit/rollback hit the SAME object. May be None
-                  when history is disabled (state_history_max_count 0/unset).
-    senpi_mcp   — the MCP client capability. PRESENT but EMPTY this block (None);
-                  B5 fills it. The slot exists now so B5 is purely additive — no
-                  structural change to ctx later.
-
-  Read-only metadata you READ:
-    wallet            — str, the strategy wallet (routing identity).
-    scanner_name      — str, this scanner's recipe name.
-    interval_seconds  — int, tick cadence in seconds.
-
-The metadata is FROZEN: mutating, deleting, or adding any attribute raises. The
-author can read `ctx.wallet` but cannot rebind it (or scribble a backdoor onto
-ctx). `state` and `senpi_mcp` are likewise immutable bindings on ctx — the author
-uses them through their own APIs, never by reassigning the slot.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Optional
-
-
-class ScanContext:
-    """Frozen, read-only metadata + capability handles for scan(inputs, ctx).
-
-    Construction seam the scaffold uses:
-
-        ScanContext(
-            *,
-            state,              # a StateManager instance (or None when history disabled)
-            wallet: str,
-            scanner_name: str,
-            interval_seconds: int,
-            senpi_mcp=None,     # B5 fills this; None/absent this block
-        )
-    """
-
-    # Lock the attribute set: no __dict__, so any unknown attribute (mutate / add /
-    # delete) raises AttributeError. The five documented slots are the only ones.
-    __slots__ = ("state", "senpi_mcp", "wallet", "scanner_name", "interval_seconds")
-
-    def __init__(
-        self,
-        *,
-        state: Any,
-        wallet: str,
-        scanner_name: str,
-        interval_seconds: int,
-        senpi_mcp: Optional[Any] = None,
-    ) -> None:
-        # Bypass our own frozen __setattr__ to populate the slots once at
-        # construction. object.__setattr__ writes the slot directly.
-        object.__setattr__(self, "state", state)
-        object.__setattr__(self, "senpi_mcp", senpi_mcp)
-        object.__setattr__(self, "wallet", wallet)
-        object.__setattr__(self, "scanner_name", scanner_name)
-        object.__setattr__(self, "interval_seconds", interval_seconds)
-
-    # -- frozen: block every post-construction mutation --------------------
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        raise AttributeError(
-            f"ctx is read-only: cannot set {name!r}. The metadata "
-            "(wallet/scanner_name/interval_seconds) is frozen, and the "
-            "capability slots (state/senpi_mcp) are used through their own APIs, "
-            "never reassigned."
-        )
-
-    def __delattr__(self, name: str) -> None:
-        raise AttributeError(f"ctx is read-only: cannot delete {name!r}.")

package/dist/scanners/external/scaffold/requirements.txt

@@ -1,11 +0,0 @@
-# Runtime dependencies for the scaffold harness (src/scanners/external/scaffold/).
-#
-# The scaffold is shipped to the scanner box and run via `python3 -m scaffold`.
-# `mcp` (the official Model Context Protocol Python SDK) backs ctx.senpi_mcp:
-# `streamablehttp_client` + a single persistent `ClientSession` (see senpi_mcp.py).
-# It is LAZY-IMPORTED at first use, so the package still imports where `mcp` is
-# absent (e.g. unit tests inject a fake SDK) — install this on the box that runs
-# scanners that call ctx.senpi_mcp.
-#
-# `mcp[cli]` is NOT needed — only the client transport + ClientSession surface.
-mcp>=1.9.0

package/dist/scanners/external/scaffold/senpi_mcp.py

@@ -1,250 +0,0 @@
-"""`ctx.senpi_mcp` — the MCP client capability (runtime v2.0.0, Block B5).
-
-The author's `scan(inputs, ctx)` is SYNC. `ctx.senpi_mcp.call_tool(name, args)`
-is therefore a SYNC surface: the author never sees `await`. Internally it bridges
-the OFFICIAL MCP Python SDK (`mcp`), which is async-only:
-
-    from mcp import ClientSession
-    from mcp.client.streamable_http import streamablehttp_client
-
-    async with streamablehttp_client(url, headers=...) as (read, write, _):
-        async with ClientSession(read, write) as session:
-            await session.initialize()
-            result = await session.call_tool(name, arguments=args)
-
-DECISION (locked, execution-plan B5): use the SDK the STANDARD way — a SINGLE
-PERSISTENT `ClientSession` created ONCE (and `initialize()`d once), reused across
-every call. NO extra guards: no custom timeout, no reconnect/retry wrapper, no
-pooling toggle, no fresh-connection-per-call. The async context managers must
-STAY OPEN for the client's lifetime, so we drive them on a dedicated event loop
-running in a background thread; `call_tool` submits work onto that loop and blocks
-for the result (the sync↔async bridge).
-
-Response normalization MATCHES producer.mjs `createSenpiToolClient`:
-    1. isError truthy            -> RAISE with the error text (never a silent None).
-    2. structuredContent present -> return it.
-    3. else first text content   -> json.loads it (fallback to the raw text).
-    4. else                      -> return content as-is.
-
-The `mcp` package is LAZY-IMPORTED on first connect (NOT at module top), so
-`import scaffold.senpi_mcp` works even where `mcp` is not installed. Missing creds
-are LOUD AT FIRST USE: `call_tool` raises, construction never does.
-
-TEARDOWN (intentional, one-process-per-scanner model): there is NO explicit
-close()/shutdown for the persistent session. The background loop runs on a DAEMON
-thread, so it dies with the process. The scaffold runs exactly ONE client per
-process for that process's whole life — the supervisor restarts by spawning a
-FRESH child process (not by re-running run_scaffold in-place), so a single client
-is never replaced in-process and there is no loop/session leak across restart.
-On graceful stop (SIGTERM/SIGINT) run_scaffold exits its loop and the process
-returns; on a hard kill the OS reclaims the thread. We deliberately do NOT drive
-an AsyncExitStack.aclose() from a shutdown hook: it buys nothing over the dropped
-TCP connection (streamable-http is request/response, no protocol goodbye) and a
-cross-thread aclose() on a wedged transport could itself hang a path that today
-cannot hang.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import threading
-from typing import Any, Iterable, Optional
-
-
-# --------------------------------------------------------------------------
-# Producer MCP write boundary — read-only by default.
-# --------------------------------------------------------------------------
-#
-# A supervised producer's scan(inputs, ctx) runs in-process with the strategy's
-# full-capability SENPI_API_KEY. Without a boundary it could call ANY MCP tool —
-# including money/state mutations — bypassing every runtime guard (risk-guard,
-# DSL, slots, dedup). MUTATION_TOOLS enumerates those money/state-mutating tools;
-# call_tool BLOCKS them by default unless the EXACT tool name is on the client's
-# write_allowlist (least privilege — one permitted tool does not unlock others).
-#
-# Read tools (discovery_*, leaderboard_*, market_*, strategy_get*, strategy_list,
-# execution_get*, account_get*, user_get*, arena_*, audit_*, get_*,
-# list_senpi_guides, read_senpi_guide, ratchet_stop_get/list/events) are NOT in
-# this set and therefore always pass.
-MUTATION_TOOLS: frozenset[str] = frozenset(
-    {
-        "create_position",
-        "close_position",
-        "edit_position",
-        "cancel_order",
-        "send_usdc",
-        "transfer_spot_to_perps",
-        "strategy_create",
-        "strategy_create_custom_strategy",
-        "strategy_close",
-        "strategy_close_positions",
-        "strategy_update",
-        "strategy_pause",
-        "strategy_top_up",
-        "strategy_withdraw_funds",
-        "strategy_bridge_funds_from_hyperliquid_to_evm",
-        "ratchet_stop_add",
-        "ratchet_stop_edit",
-        "ratchet_stop_delete",
-        "user_claim_referral_rewards",
-    }
-)
-
-# THE allowlist a scaffold maintainer edits to permit a mutation tool for
-# producers. EMPTY BY DEFAULT — every MUTATION_TOOLS entry is blocked. The ONLY
-# way to permit a mutation is to add its exact tool name to this frozenset
-# (e.g. {"create_position"}). This is scaffold-maintainer-owned source: it is
-# not operator/env-configurable and is not reachable by authored producer code.
-PRODUCER_WRITE_ALLOWLIST: frozenset[str] = frozenset()
-
-
-class SenpiMcpClient:
-    """Sync MCP client over the official async SDK with one persistent session.
-
-    Construction is cheap and never touches the network or imports `mcp`. The
-    first `call_tool` lazily imports the SDK, spins up a private event loop on a
-    background thread, opens the transport + ClientSession ONCE, and initializes
-    it ONCE. Every subsequent call reuses that same session.
-    """
-
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        mcp_url: Optional[str] = None,
-        write_allowlist: Iterable[str] = (),
-    ) -> None:
-        self._api_key = api_key
-        self._mcp_url = mcp_url
-        # Mutation tools the operator has explicitly permitted. EMPTY by default
-        # → every MUTATION_TOOLS entry is blocked (read-only producer boundary).
-        self._write_allowlist: frozenset[str] = frozenset(write_allowlist)
-
-        # Persistent bridge state — created lazily on first call_tool.
-        self._loop: Optional[asyncio.AbstractEventLoop] = None
-        self._thread: Optional[threading.Thread] = None
-        self._session: Any = None
-        self._stack: Any = None
-        self._connected = False
-        self._connect_lock = threading.Lock()
-
-    # -- public sync surface ----------------------------------------------
-
-    def call_tool(self, name: str, args: Optional[dict] = None) -> Any:
-        """Invoke an MCP tool synchronously; return the unwrapped result.
-
-        Raises (loud, never a silent None) when the tool is a money/state
-        mutation not on the write allowlist, when creds are missing, or when the
-        tool reports `isError`.
-        """
-        # Read-only producer boundary, enforced PRE-CONNECT (no transport opened
-        # for a blocked write). A mutation tool passes only if its exact name is
-        # on the write allowlist (least privilege — one tool ≠ all).
-        if name in MUTATION_TOOLS and name not in self._write_allowlist:
-            raise PermissionError(
-                f'senpi_mcp: tool "{name}" is a money/state-mutating MCP tool and '
-                "is blocked — producers are READ-ONLY by default. The ONLY way to "
-                f'permit it is to add "{name}" to the PRODUCER_WRITE_ALLOWLIST '
-                "frozenset in src/scanners/external/scaffold/senpi_mcp.py "
-                "(scaffold-maintainer-owned source; not operator/env-configurable; "
-                "not reachable by authored producer code)."
-            )
-
-        self._ensure_connected()
-        result = self._run(self._session.call_tool(name, arguments=args))
-        return self._unwrap(name, result)
-
-    # -- persistent session lifecycle -------------------------------------
-
-    def _ensure_connected(self) -> None:
-        if self._connected:
-            return
-        with self._connect_lock:
-            if self._connected:
-                return
-
-            # Loud at first use: creds are required to reach the MCP server.
-            if not self._api_key:
-                raise RuntimeError(
-                    "senpi_mcp: SENPI_API_KEY is not set; cannot call MCP tools "
-                    "(creds are resolved at launch from SENPI_API_KEY/SENPI_MCP_URL)."
-                )
-            if not self._mcp_url:
-                raise RuntimeError(
-                    "senpi_mcp: SENPI_MCP_URL is not set; cannot call MCP tools "
-                    "(creds are resolved at launch from SENPI_API_KEY/SENPI_MCP_URL)."
-                )
-
-            # Dedicated event loop on a background thread. The async context
-            # managers (transport + session) must stay OPEN for the client's
-            # lifetime, so we cannot use asyncio.run() per call — that would
-            # tear the session down between calls.
-            self._loop = asyncio.new_event_loop()
-            self._thread = threading.Thread(
-                target=self._loop.run_forever,
-                name="senpi-mcp-loop",
-                daemon=True,
-            )
-            self._thread.start()
-
-            self._run(self._connect())
-            self._connected = True
-
-    async def _connect(self) -> None:
-        """Open the transport + ClientSession ONCE and initialize ONCE.
-
-        Lazy-import the SDK here so `import scaffold.senpi_mcp` succeeds in envs
-        without `mcp` installed (tests inject a fake `mcp` into sys.modules).
-        """
-        from mcp import ClientSession
-        from mcp.client.streamable_http import streamablehttp_client
-
-        # Keep the async context managers alive by holding their __aenter__
-        # values on self and only __aexit__-ing them at close. We use
-        # AsyncExitStack so both nest correctly and unwind in order.
-        from contextlib import AsyncExitStack
-
-        self._stack = AsyncExitStack()
-        headers = {"Authorization": f"Bearer {self._api_key}"}
-        read, write, _ = await self._stack.enter_async_context(
-            streamablehttp_client(self._mcp_url, headers=headers)
-        )
-        session = await self._stack.enter_async_context(ClientSession(read, write))
-        await session.initialize()
-        self._session = session
-
-    def _run(self, coro: Any) -> Any:
-        """Drive a coroutine to completion on the persistent loop, blocking."""
-        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
-        return future.result()
-
-    # -- response normalization (matches producer.mjs createSenpiToolClient) --
-
-    @staticmethod
-    def _unwrap(name: str, result: Any) -> Any:
-        if getattr(result, "isError", False):
-            content = getattr(result, "content", None)
-            if (
-                isinstance(content, list)
-                and len(content) > 0
-                and getattr(content[0], "type", None) == "text"
-            ):
-                error_text = content[0].text
-            else:
-                error_text = json.dumps(content, default=str)
-            raise RuntimeError(f'MCP tool "{name}" returned error: {error_text}')
-
-        structured = getattr(result, "structuredContent", None)
-        if structured is not None:
-            return structured
-
-        content = getattr(result, "content", None)
-        if isinstance(content, list) and len(content) > 0:
-            first = content[0]
-            if getattr(first, "type", None) == "text":
-                try:
-                    return json.loads(first.text)
-                except (ValueError, TypeError):
-                    return first.text
-
-        return content