wayfinder-paths 0.1.29__py3-none-any.whl → 0.1.31__py3-none-any.whl

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/manifest.yaml

@@ -0,0 +1,29 @@
+schema_version: "0.1"
+entrypoint: "wayfinder_paths.strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy"
+permissions:
+  policy: |
+    (wallet.id == 'FORMAT_WALLET_ID') AND (
+      # Allow HyperLend supply and withdraw
+      (action.type == 'hyperlend_supply') OR
+      (action.type == 'hyperlend_withdraw') OR
+      # Allow WHYPE wrap/unwrap
+      (action.type == 'whype_deposit') OR
+      (action.type == 'whype_withdraw') OR
+      # Allow swaps via supported routers (Enso, LiFi, PRJX)
+      (action.type == 'swap' AND action.chain_id == 999) OR
+      # Allow ERC20 approvals for routers
+      (action.type == 'erc20_approve') OR
+      # Allow withdrawals to main wallet
+      (action.type == 'erc20_transfer' AND action.to == main_wallet.address)
+    )
+adapters:
+  - name: "BALANCE"
+    capabilities: ["wallet_read", "wallet_transfer"]
+  - name: "LEDGER"
+    capabilities: ["ledger.read", "ledger.write", "strategy.transactions"]
+  - name: "TOKEN"
+    capabilities: ["token.read"]
+  - name: "HYPERLEND"
+    capabilities: ["market.read", "supply", "withdraw", "rates"]
+  - name: "BRAP"
+    capabilities: ["swap.quote", "swap.execute"]

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -196,10 +196,12 @@ class HyperlendStableYieldStrategy(Strategy):
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
+        strategy_sign_typed_data: Callable[[dict], Awaitable[str]] | None = None,
     ):
         super().__init__(
             main_wallet_signing_callback=main_wallet_signing_callback,
             strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+            strategy_sign_typed_data=strategy_sign_typed_data,
         )
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/manifest.yaml

@@ -0,0 +1,33 @@
+schema_version: "0.1"
+entrypoint: "wayfinder_paths.strategies.moonwell_wsteth_loop_strategy.strategy.MoonwellWstethLoopStrategy"
+permissions:
+  policy: |
+    (wallet.id == 'FORMAT_WALLET_ID') AND (
+      # Allow Moonwell lending operations
+      (action.type == 'moonwell_mint') OR
+      (action.type == 'moonwell_redeem') OR
+      (action.type == 'moonwell_borrow') OR
+      (action.type == 'moonwell_repay') OR
+      (action.type == 'moonwell_enter_markets') OR
+      (action.type == 'moonwell_claim_rewards') OR
+      # Allow WETH wrap/unwrap
+      (action.type == 'weth_deposit') OR
+      (action.type == 'weth_withdraw') OR
+      # Allow swaps via Enso router
+      (action.type == 'swap' AND action.chain_id == 8453) OR
+      # Allow ERC20 approvals
+      (action.type == 'erc20_approve') OR
+      # Allow withdrawals to main wallet
+      (action.type == 'erc20_transfer' AND action.to == main_wallet.address)
+    )
+adapters:
+  - name: "BALANCE"
+    capabilities: ["wallet_read", "wallet_transfer"]
+  - name: "LEDGER"
+    capabilities: ["ledger.read", "ledger.write", "strategy.transactions"]
+  - name: "TOKEN"
+    capabilities: ["token.read"]
+  - name: "MOONWELL"
+    capabilities: ["market.read", "supply", "withdraw", "borrow", "repay", "collateral"]
+  - name: "BRAP"
+    capabilities: ["swap.quote", "swap.execute"]

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -181,10 +181,12 @@ class MoonwellWstethLoopStrategy(Strategy):
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
+        strategy_sign_typed_data: Callable[[dict], Awaitable[str]] | None = None,
     ):
         super().__init__(
             main_wallet_signing_callback=main_wallet_signing_callback,
             strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+            strategy_sign_typed_data=strategy_sign_typed_data,
         )
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:

wayfinder_paths/strategies/stablecoin_yield_strategy/manifest.yaml

@@ -0,0 +1,23 @@
+schema_version: "0.1"
+entrypoint: "wayfinder_paths.strategies.stablecoin_yield_strategy.strategy.StablecoinYieldStrategy"
+permissions:
+  policy: |
+    (wallet.id == 'FORMAT_WALLET_ID') AND (
+      # Allow swaps via Enso router on Base
+      (action.type == 'swap' AND action.chain_id == 8453) OR
+      # Allow ERC20 approvals for routers
+      (action.type == 'erc20_approve') OR
+      # Allow withdrawals to main wallet
+      (action.type == 'erc20_transfer' AND action.to == main_wallet.address)
+    )
+adapters:
+  - name: "BALANCE"
+    capabilities: ["wallet_read", "wallet_transfer"]
+  - name: "LEDGER"
+    capabilities: ["ledger.read", "ledger.write", "strategy.transactions"]
+  - name: "TOKEN"
+    capabilities: ["token.read"]
+  - name: "POOL"
+    capabilities: ["pool.read", "pool.search"]
+  - name: "BRAP"
+    capabilities: ["swap.quote", "swap.execute"]

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -155,10 +155,12 @@ class StablecoinYieldStrategy(Strategy):
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,
+        strategy_sign_typed_data: Callable[[dict], Awaitable[str]] | None = None,
     ):
         super().__init__(
             main_wallet_signing_callback=main_wallet_signing_callback,
             strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+            strategy_sign_typed_data=strategy_sign_typed_data,
         )
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:

wayfinder_paths/tests/test_manifests.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+from typing import Any
+
+import pytest
+import yaml
+
+from wayfinder_paths.core.engine.manifest import load_strategy_manifest
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    data = yaml.safe_load(path.read_text())
+    assert isinstance(data, dict), f"manifest must be a mapping: {path}"
+    return data
+
+
+def _import_entrypoint(entrypoint: str) -> None:
+    assert isinstance(entrypoint, str) and entrypoint.strip()
+    module_path, symbol = entrypoint.rsplit(".", 1)
+
+    last_exc: Exception | None = None
+    for candidate in (module_path, f"wayfinder_paths.{module_path}"):
+        try:
+            mod = importlib.import_module(candidate)
+            if not hasattr(mod, symbol):
+                raise AttributeError(f"{candidate} missing {symbol}")
+            return
+        except Exception as exc:  # noqa: BLE001
+            last_exc = exc
+
+    raise AssertionError(f"Failed to import entrypoint: {entrypoint}") from last_exc
+
+
+def test_all_adapters_have_manifest_yaml_and_entrypoint_imports():
+    adapters_dir = Path(__file__).parent.parent / "adapters"
+    if not adapters_dir.exists():
+        pytest.skip("Adapters directory not found")
+
+    missing: list[str] = []
+    for adapter_dir in sorted(adapters_dir.iterdir()):
+        if not adapter_dir.is_dir() or adapter_dir.name.startswith("_"):
+            continue
+        if not (adapter_dir / "adapter.py").exists():
+            continue
+
+        manifest_path = adapter_dir / "manifest.yaml"
+        if not manifest_path.exists():
+            missing.append(adapter_dir.name)
+            continue
+
+        manifest = _load_yaml(manifest_path)
+        assert manifest.get("schema_version"), (
+            f"Missing schema_version: {manifest_path}"
+        )
+        entrypoint = manifest.get("entrypoint")
+        assert entrypoint, f"Missing entrypoint: {manifest_path}"
+        _import_entrypoint(str(entrypoint))
+
+        caps = manifest.get("capabilities")
+        assert isinstance(caps, list), f"capabilities must be a list: {manifest_path}"
+
+    if missing:
+        pytest.fail(f"Adapters missing manifest.yaml: {', '.join(missing)}")
+
+
+def test_all_strategies_have_manifest_yaml_and_validate():
+    strategies_dir = Path(__file__).parent.parent / "strategies"
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    missing: list[str] = []
+    for strat_dir in sorted(strategies_dir.iterdir()):
+        if not strat_dir.is_dir() or strat_dir.name.startswith("_"):
+            continue
+        if not (strat_dir / "strategy.py").exists():
+            continue
+
+        manifest_path = strat_dir / "manifest.yaml"
+        if not manifest_path.exists():
+            missing.append(strat_dir.name)
+            continue
+
+        # Use the canonical validator.
+        manifest = load_strategy_manifest(str(manifest_path))
+        assert manifest.schema_version
+        assert manifest.entrypoint
+
+        _import_entrypoint(manifest.entrypoint)
+
+    if missing:
+        pytest.fail(f"Strategies missing manifest.yaml: {', '.join(missing)}")

wayfinder_paths/tests/test_mcp_balances.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.mcp.tools.balances import _dedupe_ordered, balances
+
+
+def test_dedupe_ordered_is_case_insensitive():
+    assert _dedupe_ordered(["ETH", "eth", "USDC", "usdc", "Eth"]) == ["ETH", "USDC"]
+
+
+@pytest.mark.asyncio
+async def test_balances_enriched_filters_solana_for_evm_wallet():
+    fake_client = AsyncMock()
+    fake_client.get_enriched_wallet_balances = AsyncMock(
+        return_value={
+            "balances": [
+                {"network": "base", "balanceUSD": 1.5},
+                {"network": "solana", "balanceUSD": 999.0},
+                {"network": "arbitrum", "balanceUSD": "2.0"},
+            ],
+            "total_balance_usd": 1002.5,
+        }
+    )
+
+    with patch(
+        "wayfinder_paths.mcp.tools.balances.BalanceClient", return_value=fake_client
+    ):
+        out = await balances(
+            "enriched",
+            wallet_address="0x000000000000000000000000000000000000dEaD",
+            include_solana=False,
+        )
+
+    assert out["ok"] is True
+    res = out["result"]
+    assert res["total_balance_usd"] == pytest.approx(3.5)
+    assert res["chain_breakdown"]["base"] == pytest.approx(1.5)
+    assert res["chain_breakdown"]["arbitrum"] == pytest.approx(2.0)
+    assert all(b["network"].lower() != "solana" for b in res["balances"])
+    assert res["filtered"]["original_count"] == 3
+    assert res["filtered"]["filtered_count"] == 2
+
+
+@pytest.mark.asyncio
+async def test_balances_token_dedupes_and_returns_per_token_results():
+    fake_client = AsyncMock()
+
+    async def _get_token_balance(
+        *, token_id: str, wallet_address: str, human_readable: bool
+    ):
+        if token_id == "bad":
+            raise RuntimeError("boom")
+        return {"token_id": token_id, "balance": 1}
+
+    fake_client.get_token_balance = AsyncMock(side_effect=_get_token_balance)
+
+    with patch(
+        "wayfinder_paths.mcp.tools.balances.BalanceClient", return_value=fake_client
+    ):
+        out = await balances(
+            "token",
+            wallet_address="0x000000000000000000000000000000000000dEaD",
+            token_ids=["a", "A", "bad", "a"],
+        )
+
+    assert out["ok"] is True
+    rows = out["result"]["balances"]
+    assert [r["token_id"] for r in rows] == ["a", "bad"]
+    assert rows[0]["ok"] is True
+    assert rows[1]["ok"] is False

wayfinder_paths/tests/test_mcp_discovery.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import pytest
+
+from wayfinder_paths.mcp.tools.discovery import describe, discover
+
+
+@pytest.mark.asyncio
+async def test_discover_adapters_includes_hyperliquid():
+    out = await discover("adapter")
+    assert out["ok"] is True
+    items = out["result"]["items"]
+    names = {i["name"] for i in items}
+    assert "hyperliquid_adapter" in names
+
+
+@pytest.mark.asyncio
+async def test_discover_strategies_includes_basis_and_boros():
+    out = await discover("strategy")
+    assert out["ok"] is True
+    items = out["result"]["items"]
+    names = {i["name"] for i in items}
+    assert "boros_hype_strategy" in names
+    assert "basis_trading_strategy" in names
+
+
+@pytest.mark.asyncio
+async def test_describe_strategy_returns_manifest_and_readme_excerpt():
+    out = await describe("strategy", "boros_hype_strategy")
+    assert out["ok"] is True
+    res = out["result"]
+    assert res["kind"] == "strategy"
+    assert res["name"] == "boros_hype_strategy"
+    assert isinstance(res.get("manifest"), dict)

wayfinder_paths/tests/test_mcp_execute.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.mcp.tools.execute import execute
+
+
+@pytest.mark.asyncio
+async def test_execute_validation_error_is_structured():
+    out = await execute(request={"kind": "swap", "wallet_label": "main"})
+    assert out["ok"] is False
+    assert out["error"]["code"] == "invalid_request"
+    assert isinstance(out["error"]["details"], list)
+
+
+@pytest.mark.asyncio
+async def test_execute_swap_dry_run_is_idempotent(tmp_path: Path, monkeypatch):
+    monkeypatch.setenv("DRY_RUN", "1")
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(tmp_path / "runs"))
+
+    wallet = {
+        "address": "0x000000000000000000000000000000000000dEaD",
+        "private_key_hex": "0x" + "11" * 32,
+    }
+
+    class FakeTokenClient:
+        async def get_token_details(self, query: str):
+            if query == "from":
+                return {
+                    "token_id": "from",
+                    "symbol": "FROM",
+                    "decimals": 6,
+                    "chain_id": 42161,
+                    "address": "0x1111111111111111111111111111111111111111",
+                }
+            if query == "to":
+                return {
+                    "token_id": "to",
+                    "symbol": "TO",
+                    "decimals": 6,
+                    "chain_id": 42161,
+                    "address": "0x2222222222222222222222222222222222222222",
+                }
+            raise AssertionError(f"unexpected token query: {query}")
+
+        async def get_gas_token(self, chain_code: str):  # pragma: no cover
+            raise AssertionError("not used")
+
+    class FakeBRAPClient:
+        async def get_quote(self, **kwargs):  # noqa: ANN003
+            assert kwargs["from_chain"] == 42161
+            assert kwargs["to_chain"] == 42161
+            assert kwargs["from_amount"] == "1000000"
+            return {
+                "quotes": [
+                    {"provider": "brap_best"},
+                    {"provider": "brap_alt"},
+                ],
+                "best_quote": {
+                    "provider": "brap_best",
+                    "input_amount": "1000000",
+                    "calldata": {
+                        "to": "0x" + "33" * 20,
+                        "data": "0xdeadbeef",
+                        "value": "0",
+                    },
+                },
+            }
+
+    async def fake_ensure_allowance(**_kwargs):  # noqa: ANN003
+        return True, {"tx_hash": "0xapprove"}
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.execute.find_wallet_by_label",
+            return_value=wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.execute.TokenClient",
+            return_value=FakeTokenClient(),
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.execute.BRAPClient",
+            return_value=FakeBRAPClient(),
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.execute.ensure_allowance",
+            new=AsyncMock(side_effect=fake_ensure_allowance),
+        ),
+    ):
+        req = {
+            "kind": "swap",
+            "wallet_label": "main",
+            "from_token": "from",
+            "to_token": "to",
+            "amount": "1",
+            "slippage_bps": 50,
+        }
+        out1 = await execute(request=req)
+        assert out1["ok"] is True
+        assert out1["result"]["status"] == "dry_run"
+        assert out1["result"]["kind"] == "swap"
+        assert any(e.get("label") == "approve" for e in out1["result"]["effects"])
+
+        out2 = await execute(request=req)
+        assert out2["ok"] is True
+        assert out2["result"]["status"] == "duplicate"
+
+
+@pytest.mark.asyncio
+async def test_execute_does_not_cache_preflight_errors(tmp_path: Path, monkeypatch):
+    monkeypatch.setenv("DRY_RUN", "1")
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(tmp_path / "runs"))
+
+    req = {
+        "kind": "send",
+        "wallet_label": "main",
+        "token": "native",
+        "chain_id": 8453,
+        "recipient": "0x000000000000000000000000000000000000dEaD",
+        "amount": "0.01",
+    }
+
+    # First call: wallet missing -> ok=False error stored
+    with patch(
+        "wayfinder_paths.mcp.tools.execute.find_wallet_by_label", return_value=None
+    ):
+        out1 = await execute(request=req, idempotency_key="same")
+        assert out1["ok"] is False
+
+    # Second call with same idempotency key but now wallet exists -> should proceed
+    wallet = {
+        "address": "0x000000000000000000000000000000000000dEaD",
+        "private_key_hex": "0x" + "11" * 32,
+    }
+    with patch(
+        "wayfinder_paths.mcp.tools.execute.find_wallet_by_label", return_value=wallet
+    ):
+        out2 = await execute(request=req, idempotency_key="same")
+        assert out2["ok"] is True
+        assert out2["result"]["status"] == "dry_run"

wayfinder_paths/tests/test_mcp_hyperliquid_execute.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from wayfinder_paths.core.constants.hyperliquid import HYPE_FEE_WALLET
+from wayfinder_paths.mcp.tools.hyperliquid import (
+    _resolve_builder_fee,
+    _resolve_perp_asset_id,
+    hyperliquid_execute,
+)
+
+
+def test_resolve_builder_fee_rejects_wrong_builder_wallet():
+    with pytest.raises(ValueError, match="config builder_fee\\.b must be"):
+        _resolve_builder_fee(
+            config={"builder_fee": {"b": "0x" + "00" * 20, "f": 10}},
+            builder_fee_tenths_bp=None,
+        )
+
+
+def test_resolve_builder_fee_prefers_explicit_fee():
+    fee = _resolve_builder_fee(config={}, builder_fee_tenths_bp=7)
+    assert fee == {"b": HYPE_FEE_WALLET.lower(), "f": 7}
+
+
+def test_resolve_perp_asset_id_accepts_coin_and_strips_perp_suffix():
+    class StubAdapter:
+        coin_to_asset = {"HYPE": 7}
+
+    ok, res = _resolve_perp_asset_id(StubAdapter(), coin="HYPE-perp", asset_id=None)
+    assert ok is True
+    assert res == 7
+
+
+@pytest.mark.asyncio
+async def test_hyperliquid_execute_withdraw_dry_run_is_idempotent(
+    tmp_path: Path, monkeypatch
+):
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(tmp_path / "runs"))
+
+    wallet = {
+        "address": "0x000000000000000000000000000000000000dEaD",
+        "private_key_hex": "0x" + "11" * 32,
+    }
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.hyperliquid.find_wallet_by_label",
+            return_value=wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.hyperliquid.load_config_json", return_value={}
+        ),
+    ):
+        out1 = await hyperliquid_execute(
+            "withdraw", wallet_label="main", amount_usdc=10, dry_run=True
+        )
+        assert out1["ok"] is True
+        assert out1["result"]["status"] == "dry_run"
+
+        out2 = await hyperliquid_execute(
+            "withdraw", wallet_label="main", amount_usdc=10, dry_run=True
+        )
+        assert out2["ok"] is True
+        assert out2["result"]["status"] == "duplicate"

wayfinder_paths/tests/test_mcp_idempotency_store.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from wayfinder_paths.mcp.state.store import IdempotencyStore
+
+
+def test_idempotency_store_encodes_bytes(tmp_path: Path):
+    store = IdempotencyStore(tmp_path / "state.sqlite3")
+    store.put("k", {"req": b"\x01\x02"}, {"ok": True, "tx": b"\xaa"})
+    out = store.get("k")
+    assert out is not None
+    assert out["ok"] is True
+    assert out["tx"] == "aa"

wayfinder_paths/tests/test_mcp_quote_swap.py

@@ -163,3 +163,63 @@ async def test_quote_swap_can_include_calldata_when_requested():
     assert out["ok"] is True
     best = out["result"]["quote"]["best_quote"]
     assert best["calldata"] == calldata
+
+
+@pytest.mark.asyncio
+async def test_quote_swap_accepts_top_level_brap_shape():
+    fake_wallet = {"address": "0x000000000000000000000000000000000000dEaD"}
+
+    token_client = AsyncMock()
+    token_client.get_token_details = AsyncMock(
+        side_effect=[
+            {
+                "token_id": "usd-coin-arbitrum",
+                "asset_id": "usd-coin",
+                "symbol": "USDC",
+                "decimals": 6,
+                "chain_id": 42161,
+                "address": "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+            },
+            {
+                "token_id": "tether-arbitrum",
+                "asset_id": "tether",
+                "symbol": "USDT",
+                "decimals": 6,
+                "chain_id": 42161,
+                "address": "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+            },
+        ]
+    )
+
+    brap_client = AsyncMock()
+    brap_client.get_quote = AsyncMock(
+        return_value={
+            "quotes": [{"provider": "brap_best"}, {"provider": "brap_alt"}],
+            "best_quote": {
+                "provider": "brap_best",
+                "output_amount": "1",
+                "calldata": "0xabc",
+            },
+        }
+    )
+
+    with (
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.find_wallet_by_label",
+            return_value=fake_wallet,
+        ),
+        patch(
+            "wayfinder_paths.mcp.tools.quotes.TokenClient", return_value=token_client
+        ),
+        patch("wayfinder_paths.mcp.tools.quotes.BRAPClient", return_value=brap_client),
+    ):
+        out = await quote_swap(
+            wallet_label="main",
+            from_token="usd-coin-arbitrum",
+            to_token="tether-arbitrum",
+            amount="1",
+        )
+
+    assert out["ok"] is True
+    assert out["result"]["quote"]["quote_count"] == 2
+    assert out["result"]["quote"]["providers"] == ["brap_best", "brap_alt"]

wayfinder_paths/tests/test_mcp_run_script.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from wayfinder_paths.mcp.tools.run_script import run_script
+
+
+@pytest.mark.asyncio
+async def test_run_script_rejects_outside_runs_dir(tmp_path: Path, monkeypatch):
+    runs_root = tmp_path / "runs"
+    runs_root.mkdir()
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(runs_root))
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+
+    outside = tmp_path / "outside.py"
+    outside.write_text("print('nope')\n")
+
+    out = await run_script(script_path=str(outside), dry_run=True)
+    assert out["ok"] is False
+    assert out["error"]["code"] == "invalid_request"
+
+
+@pytest.mark.asyncio
+async def test_run_script_executes_and_is_idempotent(tmp_path: Path, monkeypatch):
+    runs_root = tmp_path / "runs"
+    runs_root.mkdir()
+    monkeypatch.setenv("WAYFINDER_RUNS_DIR", str(runs_root))
+    monkeypatch.setenv("WAYFINDER_MCP_STATE_PATH", str(tmp_path / "mcp.sqlite3"))
+
+    script = runs_root / "hello.py"
+    script.write_text(
+        "import os\n"
+        "print('DRY_RUN=' + os.getenv('DRY_RUN', ''))\n"
+        "print('PWD=' + os.getcwd())\n"
+    )
+
+    out1 = await run_script(script_path=str(script), dry_run=True, timeout_s=30)
+    assert out1["ok"] is True
+    assert out1["result"]["exit_code"] == 0
+    assert "DRY_RUN=1" in out1["result"]["stdout"]
+
+    out2 = await run_script(script_path=str(script), dry_run=True, timeout_s=30)
+    assert out2["ok"] is True
+    assert out2["result"]["status"] == "duplicate"
+    assert out2["result"]["idempotency_key"]