wxz-cli 1.0.0__py3-none-any.whl

wxz_cli/__init__.py

@@ -0,0 +1,7 @@
+"""wxz-cli — CLI for 万小智 AI 建站平台.
+
+A command-line interface for the wxz (Wan Xiao Zhi) conversational AI
+website builder on Alibaba Cloud.
+"""
+
+__version__ = "1.0.0"

wxz_cli/acp/__init__.py

@@ -0,0 +1 @@
+"""ACP (Agent Client Protocol) support for wxz-cli."""

wxz_cli/acp/event_bridge.py

@@ -0,0 +1,112 @@
+"""Chat event to ACP event bridge.
+
+Consumes wxz SSE chat events (from CreateAppChat) and converts them
+into ACP session/update notifications.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+from typing import Generator
+
+from wxz_cli.acp.server import ACPServer
+from wxz_cli.core.pop_client import PopClient
+
+
+class SSEtoACPBridge:
+    """Consumes wxz SSE chat events and forwards them as ACP notifications."""
+
+    def __init__(self, server: ACPServer, pop_client: PopClient, session_id: str):
+        self.server = server
+        self.pop_client = pop_client
+        self.session_id = session_id
+        self.last_event_id = 0
+
+    def start_stream(
+        self,
+        sse_stream: Generator[dict, None, None],
+    ):
+        """Start consuming SSE events in a background thread."""
+        self._thread = threading.Thread(
+            target=self._consume_stream,
+            args=(sse_stream,),
+            daemon=True,
+        )
+        self._thread.start()
+
+    def _consume_stream(self, sse_stream: Generator[dict, None, None]):
+        """Consume SSE generator and emit ACP updates."""
+        for event in sse_stream:
+            self._emit_acp_update(event)
+            eid = event.get("id")
+            if eid is not None:
+                try:
+                    self.last_event_id = int(eid)
+                except (ValueError, TypeError):
+                    self.last_event_id = eid
+
+    def _emit_acp_update(self, event: dict):
+        """Convert a single SSE event to an ACP session/update notification."""
+        name = event.get("name", "")
+        data = event.get("data", {})
+        event_id = event.get("id", 0)
+
+        match name:
+            case "message.delta":
+                if isinstance(data, dict):
+                    content = data.get("content", "")
+                    role = data.get("role", "")
+                    ctype = data.get("contentType", "")
+                    if content and role == "assistant" and ctype == "text":
+                        self.server.send_notification("session/update", {
+                            "sessionId": self.session_id,
+                            "sessionUpdate": "agent_message_chunk",
+                            "text": content,
+                        })
+
+            case "message.tool":
+                if isinstance(data, dict):
+                    meta = data.get("metaData", {})
+                    tool_name = meta.get("name", "") if isinstance(meta, dict) else ""
+                    content = data.get("content", "")
+                    self.server.send_notification("session/update", {
+                        "sessionId": self.session_id,
+                        "sessionUpdate": "tool_call",
+                        "toolCallId": f"call_{event_id}",
+                        "title": f"{tool_name}: {content}" if tool_name else content,
+                        "kind": "edit",
+                        "status": "completed",
+                    })
+
+            case "message.interrupt":
+                self.server.send_notification("session/update", {
+                    "sessionId": self.session_id,
+                    "sessionUpdate": "agent_message_chunk",
+                    "text": "[等待输入] AI 需要更多信息",
+                })
+
+            case "chat.completed":
+                self.server.send_notification("session/update", {
+                    "sessionId": self.session_id,
+                    "sessionUpdate": "plan",
+                    "entries": [
+                        {"content": "对话完成", "priority": "high", "status": "completed"},
+                    ],
+                })
+
+            case "message.error" | "error":
+                if isinstance(data, dict):
+                    content = data.get("content", "")
+                    try:
+                        err = json.loads(content) if isinstance(content, str) else content
+                        msg = err.get("errorMsg", content) if isinstance(err, dict) else content
+                    except (json.JSONDecodeError, ValueError):
+                        msg = data.get("errorMsg", str(data))
+                else:
+                    msg = str(data)
+                self.server.send_notification("session/update", {
+                    "sessionId": self.session_id,
+                    "sessionUpdate": "agent_message_chunk",
+                    "text": f"[错误] {msg}",
+                })

wxz_cli/acp/handlers.py

@@ -0,0 +1,113 @@
+"""ACP method handlers for wxz-cli.
+
+Registers JSON-RPC methods for the Agent Client Protocol.
+"""
+
+from __future__ import annotations
+
+import os
+
+from wxz_cli.acp.server import ACPServer
+from wxz_cli.acp.session_manager import ACPSessionManager
+
+
+class ACPHandlers:
+    """Registers ACP JSON-RPC method handlers."""
+
+    def __init__(self, server: ACPServer, session_mgr: ACPSessionManager):
+        self.server = server
+        self.session_mgr = session_mgr
+        self._register_all()
+
+    def _register_all(self):
+        @self.server.method("initialize")
+        def handle_initialize(params):
+            return {
+                "protocolVersion": min(params.get("protocolVersion", 1), 1),
+                "agentCapabilities": {
+                    "loadSession": True,
+                    "promptCapabilities": {"image": True, "embeddedContext": True},
+                    "auth": {"logout": {}},
+                    "sessionCapabilities": {"list": True, "resume": True, "close": True},
+                },
+                "agentInfo": {
+                    "name": "wxz",
+                    "title": "万小智 AI 建站",
+                    "version": "1.0.0",
+                },
+                "authMethods": [
+                    {
+                        "id": "aliyun-ak",
+                        "name": "阿里云 AK/SK",
+                        "description": "使用阿里云 AccessKey 认证",
+                    }
+                ],
+            }
+
+        @self.server.method("authenticate")
+        def handle_authenticate(params):
+            ok = self.session_mgr.authenticate()
+            if not ok:
+                raise RuntimeError("Authentication required: set ALIBABACLOUD_ACCESS_KEY_ID and ALIBABACLOUD_ACCESS_KEY_SECRET, or run 'wxz login'")
+            return {}
+
+        @self.server.method("session/new")
+        def handle_session_new(params):
+            session_id = self.session_mgr.create_session(params.get("cwd", ""))
+            return {
+                "sessionId": session_id,
+                "configOptions": [
+                    {
+                        "id": "mode",
+                        "name": "建站模式",
+                        "description": "控制 AI 的行为方式",
+                        "category": "mode",
+                        "type": "select",
+                        "currentValue": "build",
+                        "options": [
+                            {"value": "build", "name": "建站模式", "description": "AI 生成完整网站代码并部署"},
+                            {"value": "ask", "name": "咨询模式", "description": "只回答问题，不修改代码"},
+                        ],
+                    }
+                ],
+            }
+
+        @self.server.method("session/load")
+        def handle_session_load(params):
+            self.session_mgr.load_session(params["sessionId"], params.get("cwd", ""))
+            return {}
+
+        @self.server.method("session/list")
+        def handle_session_list(params):
+            # Return empty list for now; can be extended to query real instances
+            return {"sessions": []}
+
+        @self.server.method("session/prompt")
+        def handle_prompt(params):
+            session_id = params["sessionId"]
+            prompt_text = self._extract_text(params.get("prompt", []))
+            self.session_mgr.handle_prompt(session_id, prompt_text)
+            # In a full implementation, this would start polling
+            # ListAIStaffChatEvents and emit session/update notifications.
+            return {"stopReason": "end_turn"}
+
+        @self.server.method("session/cancel")
+        def handle_cancel(params):
+            self.session_mgr.cancel_session(params["sessionId"])
+            return {}
+
+        @self.server.method("logout")
+        def handle_logout(params):
+            self.session_mgr.logout()
+            return {}
+
+    def _extract_text(self, prompt_blocks: list) -> str:
+        """Extract text from ACP content blocks."""
+        parts = []
+        for block in prompt_blocks:
+            if block.get("type") == "text":
+                parts.append(block.get("text", ""))
+            elif block.get("type") == "resource":
+                resource = block.get("resource", {})
+                parts.append(f"[参考文件: {resource.get('uri', '')}]")
+        return "\n".join(parts)

wxz_cli/acp/server.py

@@ -0,0 +1,78 @@
+"""JSON-RPC 2.0 server over stdio for ACP mode."""
+
+from __future__ import annotations
+
+import json
+import sys
+import logging
+from typing import Callable
+
+logger = logging.getLogger("wxz.acp")
+
+
+class ACPServer:
+    """JSON-RPC 2.0 server based on stdio transport."""
+
+    def __init__(self):
+        self._methods: dict[str, Callable] = {}
+        self._initialized = False
+
+    def method(self, name: str):
+        """Decorator to register a JSON-RPC method handler."""
+        def decorator(func):
+            self._methods[name] = func
+            return func
+        return decorator
+
+    def run(self):
+        """Main loop: read JSON-RPC messages from stdin and dispatch."""
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                msg = json.loads(line)
+            except json.JSONDecodeError:
+                self._send_error(None, -32700, "Parse error")
+                continue
+
+            method_name = msg.get("method")
+            msg_id = msg.get("id")  # None for notifications
+            params = msg.get("params", {})
+
+            if method_name == "initialize":
+                self._initialized = True
+
+            if not self._initialized and method_name != "initialize":
+                if msg_id is not None:
+                    self._send_error(msg_id, -32002, "Server not initialized")
+                continue
+
+            if method_name in self._methods:
+                try:
+                    result = self._methods[method_name](params)
+                    if msg_id is not None:
+                        self._send_result(msg_id, result)
+                except Exception as e:
+                    logger.exception("Error handling %s", method_name)
+                    if msg_id is not None:
+                        self._send_error(msg_id, -32603, str(e))
+            else:
+                if msg_id is not None:
+                    self._send_error(msg_id, -32601, f"Method not found: {method_name}")
+
+    def send_notification(self, method: str, params: dict):
+        """Send a JSON-RPC notification (no id, no response needed)."""
+        msg = {"jsonrpc": "2.0", "method": method, "params": params}
+        sys.stdout.write(json.dumps(msg, ensure_ascii=False) + "\n")
+        sys.stdout.flush()
+
+    def _send_result(self, msg_id, result):
+        msg = {"jsonrpc": "2.0", "id": msg_id, "result": result}
+        sys.stdout.write(json.dumps(msg, ensure_ascii=False) + "\n")
+        sys.stdout.flush()
+
+    def _send_error(self, msg_id, code, message):
+        msg = {"jsonrpc": "2.0", "id": msg_id, "error": {"code": code, "message": message}}
+        sys.stdout.write(json.dumps(msg, ensure_ascii=False) + "\n")
+        sys.stdout.flush()

wxz_cli/acp/session_manager.py

@@ -0,0 +1,89 @@
+"""ACP session manager for wxz-cli.
+
+Manages ACP sessions mapped to wxz conversations.
+Uses PopClient with alibabacloud SDK for API calls.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+from wxz_cli.core.session import Session
+from wxz_cli.core.pop_client import PopClient
+
+
+class ACPSessionManager:
+    """Manages ACP sessions and their mapping to wxz conversations."""
+
+    def __init__(self, session: Session):
+        self.session = session
+        self._pop_client: Optional[PopClient] = None
+        self._sessions: dict[str, dict[str, Any]] = {}
+
+    def _get_client(self) -> PopClient:
+        if self._pop_client is None:
+            self._pop_client = PopClient(
+                access_key_id=self.session.access_key_id or None,
+                access_key_secret=self.session.access_key_secret or None,
+                security_token=self.session.security_token or None,
+                region=self.session.region_id,
+            )
+        return self._pop_client
+
+    def authenticate(self) -> bool:
+        """Authenticate using session credentials or env vars."""
+        # Check if we have credentials from session or environment
+        ak = self.session.access_key_id
+        sk = self.session.access_key_secret
+        if not ak or not sk:
+            # The PopClient will use the default credential chain
+            # (env vars, shared config, ECS role) if no explicit credentials
+            pass
+        return True  # PopClient handles credential resolution internally
+
+    def create_session(self, cwd: str) -> str:
+        """Create a new wxz conversation and return session ID."""
+        client = self._get_client()
+        resp = client.create_ai_staff_conversation(text=f"New project in {cwd}")
+        module = resp.get("Module", resp)
+        session_id = module.get("ConversationId", "")
+        self._sessions[session_id] = {
+            "cwd": cwd,
+            "conversation_id": session_id,
+            "biz_id": module.get("SiteId"),
+            "chat_id": module.get("ChatId"),
+            "bot_id": module.get("BotId", "Zero2"),
+        }
+        return session_id
+
+    def load_session(self, session_id: str, cwd: str) -> None:
+        """Load an existing session."""
+        self._sessions[session_id] = {
+            "cwd": cwd,
+            "conversation_id": session_id,
+        }
+
+    def get_session(self, session_id: str) -> Optional[dict[str, Any]]:
+        return self._sessions.get(session_id)
+
+    def handle_prompt(self, session_id: str, prompt_text: str):
+        """Handle a user prompt in an ACP session."""
+        sess = self.get_session(session_id)
+        if not sess:
+            raise RuntimeError(f"Session not found: {session_id}")
+        # Actual prompt handling is done by the caller (event bridge + poll)
+        return sess
+
+    def cancel_session(self, session_id: str) -> None:
+        self._sessions.pop(session_id, None)
+
+    def logout(self) -> None:
+        self.session.access_key_id = ""
+        self.session.access_key_secret = ""
+        self.session.save()
+
+    def close(self) -> None:
+        if self._pop_client:
+            self._pop_client.close()
+            self._pop_client = None

wxz_cli/cli.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""CLI entry point for wxz-cli.
+
+A command-line interface for the wxz (Wan Xiao Zhi) AI-powered
+conversational website builder on Alibaba Cloud.
+
+Usage:
+    wxz --help
+    wxz login --ak <AK> --sk <SK>
+    wxz chat start "帮我做一个科技公司官网"
+    wxz deploy --watch
+    wxz acp --stdio
+"""
+
+from __future__ import annotations
+
+import click
+
+from wxz_cli import __version__
+from wxz_cli.core.session import Session
+
+from wxz_cli.commands.auth import login_cmd, logout_cmd, whoami_cmd
+from wxz_cli.commands.chat import chat
+from wxz_cli.commands.code import code
+from wxz_cli.commands.projects import projects
+from wxz_cli.commands.deploy import deploy
+from wxz_cli.commands.domain import domain
+from wxz_cli.commands.preview import preview_cmd
+from wxz_cli.commands.sandbox import sandbox
+from wxz_cli.commands.acp_cmd import acp_cmd
+
+
+@click.group()
+@click.option("--base-url", envvar="WXZ_BASE_URL", default="https://websitebuild.aliyuncs.com",
+              help="POP gateway base URL (env: WXZ_BASE_URL).")
+@click.option("--biz-id", envvar="WXZ_BIZ_ID", default=None,
+              help="Business/instance ID context (env: WXZ_BIZ_ID).")
+@click.option("--conversation-id", envvar="WXZ_CONVERSATION_ID", default=None,
+              help="Conversation ID context (env: WXZ_CONVERSATION_ID).")
+@click.option("--json", "json_mode", is_flag=True, default=False,
+              help="Output machine-readable JSON.")
+@click.option("--dry-run", is_flag=True, default=False,
+              help="Show what would be done without executing.")
+@click.version_option(version=__version__, prog_name="wxz")
+@click.pass_context
+def cli(ctx: click.Context, base_url: str, biz_id: str | None,
+        conversation_id: str | None, json_mode: bool, dry_run: bool) -> None:
+    """wxz-cli — AI-powered conversational website builder.
+
+    Build, preview, and deploy websites via natural language conversation
+    with the 万小智 (Wan Xiao Zhi) AI agent on Alibaba Cloud.
+    """
+    sess = Session.load()
+
+    # CLI flags override persisted session values
+    if base_url != "https://websitebuild.aliyuncs.com" or not sess.base_url:
+        sess.base_url = base_url
+    if biz_id:
+        sess.biz_id = biz_id
+    if conversation_id:
+        sess.conversation_id = conversation_id
+
+    ctx.ensure_object(dict)
+    ctx.obj["session"] = sess
+    ctx.obj["json_mode"] = json_mode
+    ctx.obj["dry_run"] = dry_run
+
+
+# ---------------------------------------------------------------------------
+# Register commands
+# ---------------------------------------------------------------------------
+
+cli.add_command(login_cmd)
+cli.add_command(logout_cmd)
+cli.add_command(whoami_cmd)
+cli.add_command(chat)
+cli.add_command(code)
+cli.add_command(projects)
+cli.add_command(deploy)
+cli.add_command(domain)
+cli.add_command(preview_cmd)
+cli.add_command(sandbox)
+cli.add_command(acp_cmd)
+
+
+if __name__ == "__main__":
+    cli()

wxz_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules for wxz-cli."""

wxz_cli/commands/acp_cmd.py

@@ -0,0 +1,26 @@
+"""ACP Agent mode command: acp --stdio."""
+
+from __future__ import annotations
+
+import click
+
+from wxz_cli.core.session import Session
+from wxz_cli.acp.server import ACPServer
+from wxz_cli.acp.handlers import ACPHandlers
+from wxz_cli.acp.session_manager import ACPSessionManager
+
+
+@click.command(name="acp")
+@click.option("--stdio", is_flag=True, required=True, help="Run as ACP Agent over stdio.")
+@click.pass_context
+def acp_cmd(ctx, stdio):
+    """Run wxz-cli as an ACP Agent (JSON-RPC over stdio)."""
+    if not stdio:
+        raise click.ClickException("ACP mode requires --stdio flag.")
+
+    sess = ctx.obj.get("session") or Session.load()
+    server = ACPServer()
+    session_mgr = ACPSessionManager(sess)
+    handlers = ACPHandlers(server, session_mgr)
+
+    server.run()

wxz_cli/commands/auth.py

@@ -0,0 +1,95 @@
+"""Authentication commands: login, logout, whoami."""
+
+from __future__ import annotations
+
+import click
+
+from wxz_cli.core.session import Session
+from wxz_cli.core.pop_client import PopClient
+from wxz_cli.core.ui import print_success, print_error, print_info
+from wxz_cli.core.output import format_api_response
+
+
+@click.command(name="login")
+@click.option("--access-key-id", "--ak", help="Alibaba Cloud AccessKey ID.")
+@click.option("--access-key-secret", "--sk", help="Alibaba Cloud AccessKey Secret.")
+@click.option("--profile", default="default", help="Credential profile name.")
+@click.option("--region", default="cn-hangzhou", help="Alibaba Cloud region.")
+@click.option("--endpoint", default="websitebuild.aliyuncs.com", help="POP endpoint.")
+@click.pass_context
+def login_cmd(ctx, access_key_id, access_key_secret, profile, region, endpoint):
+    """Authenticate with Alibaba Cloud AK/SK."""
+    json_mode = ctx.obj.get("json_mode", False)
+
+    ak = access_key_id or click.prompt("AccessKey ID", type=str)
+    sk = access_key_secret or click.prompt("AccessKey Secret", type=str, hide_input=True)
+
+    sess = Session.load()
+    sess.access_key_id = ak
+    sess.access_key_secret = sk
+    sess.region_id = region
+    sess.base_url = f"https://{endpoint}"
+    sess.save()
+
+    # Verify credentials by calling a lightweight read API
+    client = PopClient(
+        access_key_id=ak,
+        access_key_secret=sk,
+        endpoint=endpoint,
+        region=region,
+    )
+    try:
+        resp = client.list_app_instances(page_size=1)
+        if json_mode:
+            format_api_response({"success": True, "data": {"profile": profile}}, json_mode)
+        else:
+            print_success(f"Login successful! Profile: {profile}")
+    except Exception as e:
+        if json_mode:
+            format_api_response({"success": False, "error": str(e)}, json_mode)
+        else:
+            print_error(f"Login failed: {e}")
+        raise click.ClickException("Authentication failed.")
+
+
+@click.command(name="logout")
+@click.pass_context
+def logout_cmd(ctx):
+    """Clear local credentials."""
+    json_mode = ctx.obj.get("json_mode", False)
+    sess = Session.load()
+    sess.access_key_id = ""
+    sess.access_key_secret = ""
+    sess.security_token = ""
+    sess.biz_id = None
+    sess.conversation_id = None
+    sess.save()
+    if json_mode:
+        format_api_response({"success": True, "message": "Logged out"}, json_mode)
+    else:
+        print_success("Logged out. Local credentials cleared.")
+
+
+@click.command(name="whoami")
+@click.pass_context
+def whoami_cmd(ctx):
+    """Show current user info."""
+    json_mode = ctx.obj.get("json_mode", False)
+    sess = Session.load()
+    info = {
+        "access_key_id": sess.access_key_id[:8] + "..." if sess.access_key_id else None,
+        "region_id": sess.region_id,
+        "base_url": sess.base_url,
+        "biz_id": sess.biz_id,
+        "conversation_id": sess.conversation_id,
+    }
+    if json_mode:
+        format_api_response({"success": True, "data": info}, json_mode)
+    else:
+        print_info(f"AK: {info['access_key_id']}")
+        print_info(f"Region: {info['region_id']}")
+        print_info(f"Endpoint: {info['base_url']}")
+        if info['biz_id']:
+            print_info(f"Biz: {info['biz_id']}")
+        if info['conversation_id']:
+            print_info(f"Conversation: {info['conversation_id']}")