opensell-cli 0.1.0__tar.gz

opensell_cli-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_cli-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: opensell-cli
+Version: 0.1.0
+Summary: OPENSELL marketplace CLI for AI agents
+Requires-Python: >=3.12
+Requires-Dist: aixianyu-mcp
+Requires-Dist: click>=8.1
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.2.0; extra == 'dev'

opensell_cli-0.1.0/README.md

@@ -0,0 +1,36 @@
+# opensell-cli
+
+A CLI front door to the OPENSELL marketplace for AI agents — the same
+capabilities as the `aixianyu-mcp` MCP server, as shell commands. Commands are
+generated from the shared `TOOL_REGISTRY`, so MCP and CLI never drift.
+
+## Install
+
+```bash
+uvx opensell-cli            # or: pip install opensell-cli
+```
+
+## Configure
+
+```bash
+export AIXIANYU_BASE_URL="https://<host>"
+export AIXIANYU_AGENT_TOKEN="ats_xxx"   # from /console/agent-tokens
+```
+
+## Use
+
+```bash
+opensell catalog                              # machine-readable command list
+opensell search-items --q "GPT-4o key" --max-price 50
+opensell place-order --item-id 18
+opensell pay-order --order-id 7
+```
+
+## Result contract
+
+- Success: JSON payload to stdout, exit 0.
+- Failure: normalized `{"error","message"}` to stderr, non-zero exit (e.g.
+  `AGENT_SANDBOX_LIMIT`=4, `UNAUTHORIZED`=2). See `opensell catalog` for scopes.
+
+Scopes and per-transaction / balance sandbox limits are enforced by the backend,
+exactly as for the MCP server.

opensell_cli-0.1.0/opensell_cli/catalog.py

@@ -0,0 +1,39 @@
+# opensell_cli/catalog.py
+from __future__ import annotations
+
+import json
+
+import click
+from aixianyu_mcp.registry import TOOL_REGISTRY
+
+
+def build_catalog() -> dict:
+    """The CLI's machine-readable surface — the analog of MCP list_tools."""
+    commands = []
+    for name, spec in TOOL_REGISTRY.items():
+        props = spec.input_schema.get("properties", {})
+        required = set(spec.input_schema.get("required", []))
+        commands.append(
+            {
+                "command": name.replace("_", "-"),
+                "tool": name,
+                "scope": spec.scope,
+                "tier": spec.tier,
+                "description": spec.description,
+                "args": [
+                    {
+                        "name": pname,
+                        "type": pspec.get("type", "string"),
+                        "required": pname in required,
+                        "default": pspec.get("default"),
+                    }
+                    for pname, pspec in props.items()
+                ],
+            }
+        )
+    return {"commands": commands}
+
+
+@click.command("catalog", help="Emit the full command surface as JSON (for agents).")
+def catalog_command() -> None:
+    click.echo(json.dumps(build_catalog(), ensure_ascii=False, indent=2))

opensell_cli-0.1.0/opensell_cli/cli.py

@@ -0,0 +1,76 @@
+# opensell_cli/cli.py
+from __future__ import annotations
+
+import asyncio
+import json
+
+import click
+from aixianyu_mcp.errors import MCPToolError
+from aixianyu_mcp.registry import TOOL_REGISTRY, ToolSpec
+
+from .catalog import catalog_command
+from .execute import run_tool
+from .output import emit_error, emit_success
+from .schema_to_click import options_for_schema
+
+
+def _decode_object_args(spec: ToolSpec, args: dict) -> dict:
+    """Return a copy of args with any type:object property (passed as a JSON
+    string) decoded. Malformed JSON becomes a clean Click usage error."""
+    props = spec.input_schema.get("properties", {})
+    out = dict(args)
+    for name, pspec in props.items():
+        if pspec.get("type") == "object" and isinstance(out.get(name), str):
+            try:
+                out[name] = json.loads(out[name])
+            except json.JSONDecodeError as exc:
+                raise click.BadParameter(
+                    f"must be a valid JSON object ({exc})",
+                    param_hint=f"--{name.replace('_', '-')}",
+                )
+    return out
+
+
+def _make_command(tool_name: str, spec: ToolSpec) -> click.Command:
+    def callback(**kwargs):
+        ctx = click.get_current_context()
+        args = {k: v for k, v in kwargs.items() if v is not None}
+        args = _decode_object_args(spec, args)
+        try:
+            result = asyncio.run(
+                run_tool(
+                    tool_name,
+                    args,
+                    base_url=ctx.obj["base_url"],
+                    token=ctx.obj["token"],
+                )
+            )
+            emit_success(result)
+        except MCPToolError as err:
+            emit_error(err)
+
+    return click.Command(
+        name=tool_name.replace("_", "-"),
+        params=options_for_schema(spec.input_schema),
+        callback=callback,
+        help=f"{spec.description}\n\nRequires scope: {spec.scope}",
+    )
+
+
+def build_cli() -> click.Group:
+    @click.group()
+    @click.option("--token", envvar="AIXIANYU_AGENT_TOKEN", default="")
+    @click.option("--base-url", envvar="AIXIANYU_BASE_URL", default=None)
+    @click.pass_context
+    def cli(ctx: click.Context, token: str, base_url: str | None):
+        """OPENSELL marketplace CLI for AI agents."""
+        ctx.obj = {"token": token, "base_url": base_url}
+
+    for name, spec in TOOL_REGISTRY.items():
+        cli.add_command(_make_command(name, spec))
+    cli.add_command(catalog_command)
+    return cli
+
+
+def main() -> None:
+    build_cli()()

opensell_cli-0.1.0/opensell_cli/execute.py

@@ -0,0 +1,26 @@
+# opensell_cli/execute.py
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from aixianyu_mcp.errors import MCPError, MCPToolError
+from aixianyu_mcp.rest_client import AixianyuRESTClient
+from aixianyu_mcp.server import TOOL_HANDLERS
+
+
+async def run_tool(name: str, args: dict, *, base_url: str | None, token: str) -> Any:
+    """Execute a registry tool by reusing the MCP handler, then unwrap the
+    TextContent result back into a plain Python object.
+
+    `name` is the snake_case registry/tool name (e.g. "get_item").
+    Raises MCPToolError on backend errors (handled by the caller).
+    """
+    client = AixianyuRESTClient(base_url=base_url, agent_token=token)
+    if name == "ping":
+        return await client.ping()
+    handler = TOOL_HANDLERS.get(name)
+    if handler is None:
+        raise MCPToolError(MCPError.SERVER_ERROR)
+    blocks = await handler(client, args)
+    return json.loads(blocks[0].text)

opensell_cli-0.1.0/opensell_cli/output.py

@@ -0,0 +1,34 @@
+# opensell_cli/output.py
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from aixianyu_mcp.errors import MCPToolError
+
+# Stable exit codes per MCPError name. Covers every enum member so a newly
+# added error can never fall through to an undefined code.
+EXIT_CODES: dict[str, int] = {
+    "INVALID_ARGS": 1,
+    "UNAUTHORIZED": 2,
+    "INSUFFICIENT_SCOPE": 3,
+    "AGENT_SANDBOX_LIMIT": 4,
+    "INSUFFICIENT_BALANCE": 5,
+    "RATE_LIMITED": 6,
+    "ITEM_NOT_FOUND": 7,
+    "CONVERSATION_NOT_FOUND": 7,
+    "SERVER_ERROR": 8,
+}
+
+
+def emit_success(payload: Any) -> None:
+    """Print the tool payload as JSON to stdout and exit 0."""
+    sys.stdout.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    raise SystemExit(0)
+
+
+def emit_error(err: MCPToolError) -> None:
+    """Print the normalized error to stderr and exit with its mapped code."""
+    sys.stderr.write(json.dumps(err.to_dict(), ensure_ascii=False) + "\n")
+    raise SystemExit(EXIT_CODES.get(err.error.name, 8))

opensell_cli-0.1.0/opensell_cli/schema_to_click.py

@@ -0,0 +1,38 @@
+# opensell_cli/schema_to_click.py
+from __future__ import annotations
+
+import click
+
+_SCALAR = {"integer": click.INT, "number": click.FLOAT, "string": click.STRING}
+
+
+def options_for_schema(schema: dict) -> list[click.Option]:
+    """Build one click.Option per JSON-Schema property.
+
+    - property name `item_id` -> flag `--item-id` (Click maps it back to the
+      `item_id` callback kwarg automatically).
+    - integer/number/string -> matching Click types; enum -> click.Choice;
+      boolean -> is_flag; object -> STRING (a JSON string, decoded at dispatch).
+    - names in `required` are required unless they declare a `default`.
+    """
+    props = schema.get("properties", {})
+    required = set(schema.get("required", []))
+    options: list[click.Option] = []
+    for name, spec in props.items():
+        flag = "--" + name.replace("_", "-")
+        help_text = spec.get("description", "")
+        if spec.get("type") == "boolean":
+            options.append(click.Option([flag], is_flag=True, help=help_text))
+            continue
+        kwargs: dict = {"help": help_text, "required": name in required}
+        if "default" in spec:
+            kwargs["default"] = spec["default"]
+            kwargs["required"] = False
+        if "enum" in spec:
+            kwargs["type"] = click.Choice(spec["enum"])
+        elif spec.get("type") == "object":
+            kwargs["type"] = click.STRING
+        else:
+            kwargs["type"] = _SCALAR.get(spec.get("type"), click.STRING)
+        options.append(click.Option([flag], **kwargs))
+    return options

opensell_cli-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "opensell-cli"
+version = "0.1.0"
+description = "OPENSELL marketplace CLI for AI agents"
+requires-python = ">=3.12"
+dependencies = ["aixianyu-mcp", "click>=8.1"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.2.0", "pytest-asyncio>=0.23.0"]
+
+[project.scripts]
+opensell = "opensell_cli.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv.sources]
+aixianyu-mcp = { path = "../mcp-server", editable = true }
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["."]

opensell_cli-0.1.0/tests/conftest.py

@@ -0,0 +1,9 @@
+# opensell-cli/tests/conftest.py
+import pytest
+from opensell_cli.cli import build_cli
+
+
+@pytest.fixture
+def cli():
+    """The fully-assembled Click group (registry commands + catalog)."""
+    return build_cli()

opensell_cli-0.1.0/tests/test_catalog.py

@@ -0,0 +1,28 @@
+import json
+
+from aixianyu_mcp.registry import TOOL_REGISTRY
+from click.testing import CliRunner
+from opensell_cli.catalog import build_catalog, catalog_command
+
+
+def test_build_catalog_covers_every_tool():
+    cat = build_catalog()
+    commands = {c["tool"] for c in cat["commands"]}
+    assert commands == set(TOOL_REGISTRY.keys())
+
+
+def test_catalog_entry_shape():
+    cat = build_catalog()
+    by_tool = {c["tool"]: c for c in cat["commands"]}
+    place = by_tool["place_order"]
+    assert place["command"] == "place-order"
+    assert place["scope"] == "orders:create"
+    arg_names = {a["name"]: a for a in place["args"]}
+    assert arg_names["item_id"]["required"] is True
+
+
+def test_catalog_command_emits_json():
+    result = CliRunner().invoke(catalog_command, [])
+    assert result.exit_code == 0
+    parsed = json.loads(result.output)
+    assert "commands" in parsed and len(parsed["commands"]) == len(TOOL_REGISTRY)

opensell_cli-0.1.0/tests/test_cli_e2e.py

@@ -0,0 +1,55 @@
+# opensell-cli/tests/test_cli_e2e.py
+import json
+from unittest.mock import AsyncMock, patch
+
+from aixianyu_mcp.errors import MCPError, MCPToolError
+from aixianyu_mcp.registry import TOOL_REGISTRY
+from click.testing import CliRunner
+
+
+def test_all_registry_tools_plus_catalog_are_commands(cli):
+    names = set(cli.commands.keys())
+    for tool in TOOL_REGISTRY:
+        assert tool.replace("_", "-") in names
+    assert "catalog" in names
+
+
+def test_success_prints_json_and_exit_zero(cli):
+    with patch(
+        "opensell_cli.cli.run_tool",
+        new=AsyncMock(return_value={"id": 18, "title": "GPT-4o key"}),
+    ):
+        result = CliRunner().invoke(cli, ["get-item", "--item-id", "18"])
+    assert result.exit_code == 0
+    assert json.loads(result.stdout) == {"id": 18, "title": "GPT-4o key"}
+
+
+def test_backend_error_maps_to_exit_code(cli):
+    err = MCPToolError(MCPError.UNAUTHORIZED)
+    with patch("opensell_cli.cli.run_tool", new=AsyncMock(side_effect=err)):
+        result = CliRunner().invoke(cli, ["get-wallet"])
+    assert result.exit_code == 2
+    assert json.loads(result.stderr)["error"] == "UNAUTHORIZED"
+
+
+def test_missing_required_arg_is_usage_error(cli):
+    result = CliRunner().invoke(cli, ["get-item"])  # no --item-id
+    assert result.exit_code == 2  # Click usage error
+    assert "Missing option" in result.output
+
+
+def test_invalid_object_arg_is_usage_error(cli):
+    result = CliRunner().invoke(
+        cli, ["update-item", "--item-id", "1", "--structured-attributes", "not json"]
+    )
+    assert result.exit_code == 2
+    assert "valid JSON" in result.output
+
+
+def test_two_commands_dispatch_independently(cli):
+    from unittest.mock import AsyncMock, patch
+    with patch("opensell_cli.cli.run_tool", new=AsyncMock(return_value={})) as mock:
+        CliRunner().invoke(cli, ["get-item", "--item-id", "1"])
+        CliRunner().invoke(cli, ["get-wallet"])
+    assert mock.await_args_list[0].args[0] == "get_item"
+    assert mock.await_args_list[1].args[0] == "get_wallet"

opensell_cli-0.1.0/tests/test_execute.py

@@ -0,0 +1,41 @@
+import json
+from unittest.mock import AsyncMock, patch
+
+import mcp.types as types
+import pytest
+from opensell_cli.execute import run_tool
+
+
+@pytest.mark.asyncio
+async def test_run_tool_unwraps_handler_textcontent():
+    fake_handler = AsyncMock(
+        return_value=[types.TextContent(type="text", text=json.dumps({"id": 18}))]
+    )
+    with patch.dict("opensell_cli.execute.TOOL_HANDLERS", {"get_item": fake_handler}):
+        with patch("opensell_cli.execute.AixianyuRESTClient") as Client:
+            result = await run_tool(
+                "get_item", {"item_id": 18}, base_url="http://x", token="t"
+            )
+    assert result == {"id": 18}
+    fake_handler.assert_awaited_once()
+    # handler called as (client, args)
+    args = fake_handler.await_args.args
+    assert args[1] == {"item_id": 18}
+    Client.assert_called_once_with(base_url="http://x", agent_token="t")
+
+
+@pytest.mark.asyncio
+async def test_run_tool_ping_is_inline():
+    with patch("opensell_cli.execute.AixianyuRESTClient") as Client:
+        Client.return_value.ping = AsyncMock(return_value={"status": "pong"})
+        result = await run_tool("ping", {}, base_url=None, token="")
+    assert result == {"status": "pong"}
+
+
+@pytest.mark.asyncio
+async def test_run_tool_unknown_tool_raises_mcptoolerror():
+    from aixianyu_mcp.errors import MCPToolError
+    with patch("opensell_cli.execute.AixianyuRESTClient"):
+        with patch.dict("opensell_cli.execute.TOOL_HANDLERS", {}, clear=False):
+            with pytest.raises(MCPToolError):
+                await run_tool("does_not_exist", {}, base_url=None, token="")

opensell_cli-0.1.0/tests/test_output.py

@@ -0,0 +1,29 @@
+import json
+import pytest
+from aixianyu_mcp.errors import MCPError, MCPToolError
+from opensell_cli.output import emit_success, emit_error, EXIT_CODES
+
+
+def test_emit_success_writes_json_and_exits_zero(capsys):
+    with pytest.raises(SystemExit) as exc:
+        emit_success({"order_id": 7, "status": "escrow_hold"})
+    assert exc.value.code == 0
+    out = json.loads(capsys.readouterr().out)
+    assert out == {"order_id": 7, "status": "escrow_hold"}
+
+
+def test_emit_error_writes_to_stderr_with_mapped_exit(capsys):
+    err = MCPToolError(MCPError.AGENT_SANDBOX_LIMIT, limit="20000")
+    with pytest.raises(SystemExit) as exc:
+        emit_error(err)
+    assert exc.value.code == 4
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    body = json.loads(captured.err)
+    assert body["error"] == "AGENT_SANDBOX_LIMIT"
+    assert "20000" in body["message"]
+
+
+def test_every_mcp_error_has_an_exit_code():
+    for member in MCPError:
+        assert member.name in EXIT_CODES

opensell_cli-0.1.0/tests/test_schema_to_click.py

@@ -0,0 +1,44 @@
+import click
+from opensell_cli.schema_to_click import options_for_schema
+
+
+def _by_name(options):
+    return {o.name: o for o in options}
+
+
+def test_required_typed_and_kebab_cased():
+    schema = {
+        "type": "object",
+        "properties": {
+            "item_id": {"type": "integer", "description": "Item ID"},
+            "quantity": {"type": "integer", "default": 1},
+        },
+        "required": ["item_id"],
+    }
+    opts = _by_name(options_for_schema(schema))
+    assert opts["item_id"].opts == ["--item-id"]
+    assert opts["item_id"].required is True
+    assert opts["item_id"].type is click.INT
+    # default makes it optional
+    assert opts["quantity"].required is False
+    assert opts["quantity"].default == 1
+
+
+def test_enum_becomes_choice_and_bool_is_flag():
+    schema = {
+        "type": "object",
+        "properties": {
+            "sort": {"type": "string", "enum": ["newest", "price_asc"]},
+            "verbose": {"type": "boolean"},
+        },
+    }
+    opts = _by_name(options_for_schema(schema))
+    assert isinstance(opts["sort"].type, click.Choice)
+    assert list(opts["sort"].type.choices) == ["newest", "price_asc"]
+    assert opts["verbose"].is_flag is True
+
+
+def test_object_type_maps_to_string():
+    schema = {"type": "object", "properties": {"structured_attributes": {"type": "object"}}}
+    opts = _by_name(options_for_schema(schema))
+    assert opts["structured_attributes"].type is click.STRING