opensell-mcp 0.1.0__tar.gz

opensell_mcp-0.1.0/.gitignore

@@ -0,0 +1,52 @@
+# .omx 内部
+.omx/
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Node
+node_modules/
+.next/
+out/
+dist/
+*.tsbuildinfo
+.turbo/
+
+# 环境与密钥
+.env
+.env.*
+!.env.example
+!.env.*.example
+*.pem
+*.key
+secrets/
+thisisserver.conf
+
+# IDE / OS
+.DS_Store
+.vscode/
+.idea/
+*.swp
+
+# 构建产物
+build/
+*.log
+
+# 本地研究与会话上下文（不进 grant 仓库）
+/arc/
+*-context.txt
+.superpowers/
+
+# 本地工具/IDE 配置与录制源（不进 grant 仓库）
+.qoder/
+.mcp.json
+.codegraph/
+docs/arc/recordings/

opensell_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: opensell-mcp
+Version: 0.1.0
+Summary: OpenSell MCP Server for C2C agentic commerce
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=0.9.0
+Requires-Dist: pydantic>=2.7.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.2.0; extra == 'dev'

opensell_mcp-0.1.0/aixianyu_mcp/__init__.py

@@ -0,0 +1,2 @@
+"""Aixianyu MCP Server — Plan 0 skeleton."""
+__version__ = "0.1.0"

opensell_mcp-0.1.0/aixianyu_mcp/errors.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class MCPError(Enum):
+    INSUFFICIENT_SCOPE = "Insufficient permissions. Required scope: {required}"
+    ITEM_NOT_FOUND = "Item not found or delisted"
+    AGENT_SANDBOX_LIMIT = "Agent sandbox limit exceeded (limit: {limit})"
+    RATE_LIMITED = "Rate limited. Retry after {retry_after} seconds"
+    INVALID_ARGS = "Invalid arguments: {details}"
+    SERVER_ERROR = "Platform error. Please retry later"
+    UNAUTHORIZED = "Agent token invalid or expired"
+    CONVERSATION_NOT_FOUND = "Conversation not found"
+    INSUFFICIENT_BALANCE = "Insufficient wallet balance"
+
+
+class MCPToolError(Exception):
+    def __init__(self, error: MCPError, **kwargs: str):
+        self.error = error
+        self.message = error.value.format(**kwargs) if kwargs else error.value
+        super().__init__(self.message)
+
+    def to_dict(self) -> dict:
+        return {"error": self.error.name, "message": self.message}

opensell_mcp-0.1.0/aixianyu_mcp/registry.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ToolSpec:
+    name: str
+    description: str
+    scope: str
+    tier: int
+    input_schema: dict[str, Any] = field(default_factory=dict)
+    requires_copilot: bool = False
+    sandbox_checks: list[str] = field(default_factory=list)
+
+
+TOOL_REGISTRY: dict[str, ToolSpec] = {
+    "ping": ToolSpec(
+        name="ping",
+        description="Connectivity check. Returns 'pong' and backend health status.",
+        scope="items:read",
+        tier=0,
+        input_schema={"type": "object", "properties": {}, "additionalProperties": False},
+    ),
+    "search_items": ToolSpec(
+        name="search_items",
+        description=(
+            "Search items listed on Aixianyu. Supports keyword + category + price range filtering. "
+            "Results include trust_score — prefer items with trust_score >= 70."
+        ),
+        scope="items:read",
+        tier=1,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "q": {"type": "string", "description": "Search keywords"},
+                "category_id": {"type": "integer", "description": "Filter by category ID"},
+                "min_price": {"type": "number", "description": "Minimum price (CNY)"},
+                "max_price": {"type": "number", "description": "Maximum price (CNY)"},
+                "sort": {
+                    "type": "string",
+                    "enum": ["newest", "price_asc", "price_desc", "trust_score_desc"],
+                    "default": "trust_score_desc",
+                },
+                "limit": {"type": "integer", "default": 20, "maximum": 100},
+            },
+        },
+    ),
+    "get_item": ToolSpec(
+        name="get_item",
+        description="Get detailed information about a specific item including seller info, trust_score, and structured attributes.",
+        scope="items:read",
+        tier=1,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "item_id": {"type": "integer", "description": "Item ID"},
+            },
+            "required": ["item_id"],
+        },
+    ),
+    "list_categories": ToolSpec(
+        name="list_categories",
+        description="List all available item categories on Aixianyu.",
+        scope="items:read",
+        tier=1,
+        input_schema={"type": "object", "properties": {}},
+    ),
+    "get_order": ToolSpec(
+        name="get_order",
+        description="Get the current status and details of one of your orders (state, price, shipping, settlement).",
+        scope="orders:read",
+        tier=1,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "order_id": {"type": "integer", "description": "Order ID"},
+            },
+            "required": ["order_id"],
+        },
+    ),
+    "get_wallet": ToolSpec(
+        name="get_wallet",
+        description="Get the current user's wallet balance and recent transactions.",
+        scope="payment:spend",
+        tier=1,
+        input_schema={"type": "object", "properties": {}},
+    ),
+    "list_conversations": ToolSpec(
+        name="list_conversations",
+        description="List the current user's message conversations with other users.",
+        scope="messages:read",
+        tier=1,
+        input_schema={"type": "object", "properties": {}},
+    ),
+    "get_messages": ToolSpec(
+        name="get_messages",
+        description="Get messages in a specific conversation. Returns messages in reverse chronological order.",
+        scope="messages:read",
+        tier=1,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "conversation_id": {"type": "integer", "description": "Conversation ID"},
+                "limit": {"type": "integer", "default": 50, "maximum": 200},
+                "before": {"type": "string", "description": "ISO timestamp cursor for pagination"},
+            },
+            "required": ["conversation_id"],
+        },
+    ),
+    "publish_item": ToolSpec(
+        name="publish_item",
+        description=(
+            "Publish a new item listing on Aixianyu. For categories with schema support, "
+            "structured_attributes will be validated against the category schema (Copilot-assisted)."
+        ),
+        scope="items:publish",
+        tier=3,
+        requires_copilot=True,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "title": {"type": "string", "description": "Item title"},
+                "description": {"type": "string", "description": "Item description"},
+                "price": {"type": "number", "description": "Price in CNY"},
+                "category_id": {"type": "integer", "description": "Category ID"},
+                "condition": {"type": "string", "enum": ["new", "almost_new", "used"]},
+                "structured_attributes": {
+                    "type": "object",
+                    "description": "Category-specific attributes (e.g. {\"brand\": \"Apple\", \"storage_gb\": 256})",
+                },
+            },
+            "required": ["title", "description", "price", "category_id"],
+        },
+    ),
+    "update_item": ToolSpec(
+        name="update_item",
+        description="Update an existing item listing. Only the fields provided will be updated.",
+        scope="items:edit",
+        tier=3,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "item_id": {"type": "integer", "description": "Item ID to update"},
+                "title": {"type": "string"},
+                "description": {"type": "string"},
+                "price": {"type": "number"},
+                "condition": {"type": "string", "enum": ["new", "almost_new", "used"]},
+                "structured_attributes": {"type": "object"},
+            },
+            "required": ["item_id"],
+        },
+    ),
+    "contact_seller": ToolSpec(
+        name="contact_seller",
+        description=(
+            "Start a conversation with the seller of an item. "
+            "Use this to ask questions about an item before purchasing."
+        ),
+        scope="messages:send",
+        tier=2,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "item_id": {"type": "integer", "description": "ID of the item whose seller to contact"},
+                "message": {"type": "string", "description": "Initial message to the seller"},
+            },
+            "required": ["item_id", "message"],
+        },
+    ),
+    "send_message": ToolSpec(
+        name="send_message",
+        description="Send a message in an existing conversation.",
+        scope="messages:send",
+        tier=2,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "conversation_id": {"type": "integer", "description": "Conversation ID"},
+                "content": {"type": "string", "description": "Message content"},
+            },
+            "required": ["conversation_id", "content"],
+        },
+    ),
+    "place_order": ToolSpec(
+        name="place_order",
+        description=(
+            "Create a pending-payment order for an item. This does not pay or consume "
+            "Agent sandbox budget; call pay_order to execute wallet payment."
+        ),
+        scope="orders:create",
+        tier=4,
+        input_schema={
+            "type": "object",
+            "properties": {
+                "item_id": {"type": "integer", "description": "Item ID to order"},
+                "quantity": {"type": "integer", "default": 1, "minimum": 1},
+            },
+            "required": ["item_id"],
+        },
+    ),
+    "pay_order": ToolSpec(
+        name="pay_order",
+        description=(
+            "Pay an existing pending order with the Agent wallet. The backend enforces "
+            "per_tx_limit and balance_limit in cents and returns paid or pending."
+        ),
+        scope="payment:spend",
+        tier=4,
+        sandbox_checks=["per_tx_limit", "balance_limit"],
+        input_schema={
+            "type": "object",
+            "properties": {
+                "order_id": {"type": "integer", "description": "Order ID to pay"},
+            },
+            "required": ["order_id"],
+        },
+    ),
+    "wallet_withdraw": ToolSpec(
+        name="wallet_withdraw",
+        description=(
+            "Request a withdrawal from the user's wallet. "
+            "Subject to Agent sandbox per_tx_limit and daily_spend limits."
+        ),
+        scope="payment:withdraw",
+        tier=4,
+        sandbox_checks=["per_tx_limit", "daily_spend"],
+        input_schema={
+            "type": "object",
+            "properties": {
+                "amount": {"type": "number", "description": "Amount to withdraw (CNY)", "minimum": 0.01},
+            },
+            "required": ["amount"],
+        },
+    ),
+}
+
+
+def filter_tools_by_scopes(agent_scopes: set[str]) -> list[ToolSpec]:
+    return [spec for spec in TOOL_REGISTRY.values() if spec.scope in agent_scopes]

opensell_mcp-0.1.0/aixianyu_mcp/rest_client.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+import os
+from typing import Any
+import httpx
+
+from aixianyu_mcp.errors import MCPToolError, MCPError
+
+
+class AixianyuRESTClient:
+    def __init__(self, base_url: str | None = None, agent_token: str | None = None):
+        self.base_url = base_url or os.getenv("AIXIANYU_BASE_URL", "https://varybai.online/api")
+        self.agent_token = agent_token or os.getenv("AIXIANYU_AGENT_TOKEN", "")
+        self._headers = {"Authorization": f"Agent {self.agent_token}"} if self.agent_token else {}
+
+    def _client(self) -> httpx.AsyncClient:
+        return httpx.AsyncClient(base_url=self.base_url, headers=self._headers, timeout=10.0)
+
+    def _handle_error(self, r: httpx.Response) -> None:
+        """Map HTTP errors to MCPToolError."""
+        if r.is_success:
+            return
+        if r.status_code == 401:
+            raise MCPToolError(MCPError.UNAUTHORIZED)
+        if r.status_code == 403:
+            body = r.json() if r.headers.get("content-type", "").startswith("application/json") else {}
+            limit = body.get("detail", {}).get("limit", "unknown") if isinstance(body.get("detail"), dict) else "unknown"
+            raise MCPToolError(MCPError.AGENT_SANDBOX_LIMIT, limit=str(limit))
+        if r.status_code == 404:
+            raise MCPToolError(MCPError.ITEM_NOT_FOUND)
+        if r.status_code == 422:
+            detail = r.json().get("detail", "validation error")
+            raise MCPToolError(MCPError.INVALID_ARGS, details=str(detail))
+        if r.status_code == 429:
+            retry = r.headers.get("Retry-After", "60")
+            raise MCPToolError(MCPError.RATE_LIMITED, retry_after=retry)
+        raise MCPToolError(MCPError.SERVER_ERROR)
+
+    async def ping(self) -> dict:
+        async with self._client() as c:
+            r = await c.get("/health")
+            self._handle_error(r)
+            return {"status": "pong", "backend": self.base_url, "health": r.json()}
+
+    async def search_items(self, params: dict[str, Any]) -> dict:
+        async with self._client() as c:
+            r = await c.get("/v1/items", params=params)
+            self._handle_error(r)
+            return r.json()
+
+    async def get_item(self, item_id: int) -> dict:
+        async with self._client() as c:
+            r = await c.get(f"/v1/items/{item_id}")
+            self._handle_error(r)
+            return r.json()
+
+    async def list_categories(self) -> dict:
+        async with self._client() as c:
+            r = await c.get("/v1/categories")
+            self._handle_error(r)
+            return r.json()
+
+    async def get_order(self, order_id: int) -> dict:
+        async with self._client() as c:
+            r = await c.get(f"/v1/orders/{order_id}")
+            self._handle_error(r)
+            return r.json()
+
+    async def get_wallet(self) -> dict:
+        async with self._client() as c:
+            r = await c.get("/v1/wallet")
+            self._handle_error(r)
+            return r.json()
+
+    async def list_conversations(self) -> dict:
+        async with self._client() as c:
+            r = await c.get("/v1/conversations")
+            self._handle_error(r)
+            return r.json()
+
+    async def get_messages(self, conversation_id: int, params: dict[str, Any] | None = None) -> dict:
+        async with self._client() as c:
+            r = await c.get(f"/v1/conversations/{conversation_id}/messages", params=params or {})
+            self._handle_error(r)
+            return r.json()
+
+    async def contact_seller(self, item_id: int, message: str) -> dict:
+        """Start a conversation with an item's seller."""
+        async with self._client() as c:
+            r = await c.post(
+                "/v1/conversations/contact",
+                json={"item_id": item_id, "type": "text", "body": {"text": message}},
+            )
+            self._handle_error(r)
+            return r.json()
+
+    async def send_message(self, conversation_id: int, content: str) -> dict:
+        """Send a message in an existing conversation."""
+        async with self._client() as c:
+            r = await c.post(
+                f"/v1/conversations/{conversation_id}/messages",
+                json={"type": "text", "body": {"text": content}},
+            )
+            self._handle_error(r)
+            return r.json()
+
+    async def publish_item(self, payload: dict[str, Any]) -> dict:
+        """Publish a new item listing (Copilot-assisted structured listing)."""
+        async with self._client() as c:
+            r = await c.post("/v1/items", json=payload)
+            self._handle_error(r)
+            return r.json()
+
+    async def update_item(self, item_id: int, payload: dict[str, Any]) -> dict:
+        """Update an existing item listing."""
+        async with self._client() as c:
+            r = await c.put(f"/v1/items/{item_id}", json=payload)
+            self._handle_error(r)
+            return r.json()
+
+    async def place_order(self, item_id: int, quantity: int = 1) -> dict:
+        """Create a pending-payment order for an item."""
+        async with self._client() as c:
+            r = await c.post("/v1/orders", json={"item_id": item_id, "quantity": quantity})
+            self._handle_error(r)
+            return r.json()
+
+    async def pay_order(self, order_id: int) -> dict:
+        """Pay an order with the Agent wallet sandbox."""
+        async with self._client() as c:
+            r = await c.post(
+                f"/v1/orders/{order_id}/pay",
+                json={"payment_method": "wallet"},
+            )
+            self._handle_error(r)
+            return r.json()
+
+    async def wallet_withdraw(self, amount: float) -> dict:
+        """Request a wallet withdrawal."""
+        async with self._client() as c:
+            r = await c.post("/v1/wallet/withdraw", json={"amount": amount})
+            self._handle_error(r)
+            return r.json()
+
+    async def get_token_info(self) -> dict:
+        """Introspect the current Agent Token to get scopes and sandbox config."""
+        async with self._client() as c:
+            r = await c.get("/v1/agent/token/me")
+            self._handle_error(r)
+            return r.json()

opensell_mcp-0.1.0/aixianyu_mcp/server.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+import asyncio, json
+from typing import Any
+
+import mcp.server.stdio
+import mcp.types as types
+from mcp.server import Server
+
+from aixianyu_mcp.registry import TOOL_REGISTRY, filter_tools_by_scopes, ToolSpec
+from aixianyu_mcp.rest_client import AixianyuRESTClient
+from aixianyu_mcp.errors import MCPToolError
+from aixianyu_mcp.tools.tier1_read import (
+    handle_search_items, handle_get_item, handle_list_categories,
+    handle_get_order, handle_get_wallet, handle_list_conversations,
+    handle_get_messages,
+)
+from aixianyu_mcp.tools.tier2_message import handle_contact_seller, handle_send_message
+from aixianyu_mcp.tools.tier3_write import handle_publish_item, handle_update_item
+from aixianyu_mcp.tools.tier4_payment import (
+    handle_pay_order,
+    handle_place_order,
+    handle_wallet_withdraw,
+)
+
+server = Server("aixianyu-mcp")
+
+TOOL_HANDLERS = {
+    "ping": None,  # handled inline
+    "search_items": handle_search_items,
+    "get_item": handle_get_item,
+    "list_categories": handle_list_categories,
+    "get_order": handle_get_order,
+    "get_wallet": handle_get_wallet,
+    "list_conversations": handle_list_conversations,
+    "get_messages": handle_get_messages,
+    "contact_seller": handle_contact_seller,
+    "send_message": handle_send_message,
+    "publish_item": handle_publish_item,
+    "update_item": handle_update_item,
+    "place_order": handle_place_order,
+    "pay_order": handle_pay_order,
+    "wallet_withdraw": handle_wallet_withdraw,
+}
+
+_client = AixianyuRESTClient()
+_cached_scopes: set[str] | None = None
+
+
+async def _get_scopes() -> set[str]:
+    global _cached_scopes
+    if _cached_scopes is not None:
+        return _cached_scopes
+    try:
+        info = await _client.get_token_info()
+        _cached_scopes = set(info.get("scopes", []))
+    except Exception:
+        # If token introspection fails, show only Tier 0 (ping)
+        _cached_scopes = {"items:read"}
+    return _cached_scopes
+
+
+@server.list_tools()
+async def list_tools() -> list[types.Tool]:
+    scopes = await _get_scopes()
+    visible = filter_tools_by_scopes(scopes)
+    return [
+        types.Tool(name=s.name, description=s.description, inputSchema=s.input_schema)
+        for s in visible
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[types.TextContent]:
+    if name == "ping":
+        try:
+            result = await _client.ping()
+            return [types.TextContent(type="text", text=json.dumps(result))]
+        except Exception as e:
+            return [types.TextContent(type="text", text=json.dumps({"error": str(e)}))]
+
+    handler = TOOL_HANDLERS.get(name)
+    if handler is None:
+        raise ValueError(f"Unknown tool: {name}")
+
+    # Verify scope before calling
+    scopes = await _get_scopes()
+    spec = TOOL_REGISTRY.get(name)
+    if spec and spec.scope not in scopes:
+        return [types.TextContent(
+            type="text",
+            text=json.dumps({"error": f"Insufficient scope. Required: {spec.scope}"}),
+        )]
+
+    try:
+        return await handler(_client, arguments)
+    except MCPToolError as e:
+        return [types.TextContent(type="text", text=json.dumps(e.to_dict()))]
+    except Exception as e:
+        return [types.TextContent(type="text", text=json.dumps({"error": "UNEXPECTED", "message": str(e)}))]
+
+
+async def run():
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main():
+    asyncio.run(run())
+
+
+if __name__ == "__main__":
+    main()

opensell_mcp-0.1.0/aixianyu_mcp/tools/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

opensell_mcp-0.1.0/aixianyu_mcp/tools/tier1_read.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+import json
+from typing import Any
+
+import mcp.types as types
+from aixianyu_mcp.rest_client import AixianyuRESTClient
+
+
+async def handle_search_items(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    params = {}
+    if q := arguments.get("q"):
+        params["keyword"] = q
+    if cat := arguments.get("category_id"):
+        params["category_id"] = cat
+    if mp := arguments.get("min_price"):
+        params["min_price"] = mp
+    if xp := arguments.get("max_price"):
+        params["max_price"] = xp
+    if sort := arguments.get("sort"):
+        params["sort"] = sort
+    if limit := arguments.get("limit"):
+        params["limit"] = limit
+    result = await client.search_items(params)
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+
+async def handle_get_item(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    item_id = arguments["item_id"]
+    result = await client.get_item(item_id)
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+
+async def handle_list_categories(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    result = await client.list_categories()
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+
+async def handle_get_order(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    order_id = arguments["order_id"]
+    result = await client.get_order(order_id)
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+
+async def handle_get_wallet(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    result = await client.get_wallet()
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+
+async def handle_list_conversations(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    result = await client.list_conversations()
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+
+async def handle_get_messages(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    conversation_id = arguments["conversation_id"]
+    params = {}
+    if limit := arguments.get("limit"):
+        params["limit"] = limit
+    if before := arguments.get("before"):
+        params["before"] = before
+    result = await client.get_messages(conversation_id, params)
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]

opensell_mcp-0.1.0/aixianyu_mcp/tools/tier2_message.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+import json
+from typing import Any
+
+import mcp.types as types
+from aixianyu_mcp.rest_client import AixianyuRESTClient
+
+
+async def handle_contact_seller(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    item_id = arguments["item_id"]
+    message = arguments["message"]
+    result = await client.contact_seller(item_id, message)
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+
+
+async def handle_send_message(client: AixianyuRESTClient, arguments: dict[str, Any]) -> list[types.TextContent]:
+    conversation_id = arguments["conversation_id"]
+    content = arguments["content"]
+    result = await client.send_message(conversation_id, content)
+    return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]