PyPI - mobox-cli - Versions diffs - 0.1.0__py3-none-any.whl - Mend

mobox-cli 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

mobox/__init__.py +1 -0
mobox/auth.py +254 -0
mobox/client.py +98 -0
mobox/commands/__init__.py +0 -0
mobox/commands/deploy.py +149 -0
mobox/commands/local.py +82 -0
mobox/commands/manage.py +188 -0
mobox/commands/ops.py +125 -0
mobox/config.py +82 -0
mobox/local/__init__.py +0 -0
mobox/local/analyze_volumes.py +483 -0
mobox/local/config_utils.py +632 -0
mobox/local/detect_framework.py +1406 -0
mobox/local/detect_project.py +388 -0
mobox/local/pack_project.py +543 -0
mobox/main.py +109 -0
mobox/utils.py +52 -0
mobox_cli-0.1.0.dist-info/METADATA +9 -0
mobox_cli-0.1.0.dist-info/RECORD +21 -0
mobox_cli-0.1.0.dist-info/WHEEL +4 -0
mobox_cli-0.1.0.dist-info/entry_points.txt +2 -0

mobox/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ __version__ = "0.1.0"

mobox/auth.py ADDED Viewed

@@ -0,0 +1,254 @@
+"""Authentication commands: login, logout, whoami"""
+import asyncio
+import json
+import random
+import re
+import secrets
+import time
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs, quote, urlparse
+import typer
+from rich.prompt import Prompt
+from mobox import utils
+from mobox.config import (
+    DEFAULT_SERVER,
+    clear_credentials,
+    load_credentials,
+    save_credentials,
+)
+_I18N = {
+    "zh": {
+        "success_title": "\u2705 登录成功！",
+        "success_body": "你可以关闭此页面，返回终端继续操作。",
+        "error_state": "状态不匹配（CSRF 校验失败）",
+        "error_missing_key": "回调缺少密钥（mcp_key）",
+    },
+    "en": {
+        "success_title": "\u2705 Login successful!",
+        "success_body": "You can close this page and return to terminal.",
+        "error_state": "State mismatch (CSRF protection)",
+        "error_missing_key": "Missing mcp_key in callback",
+    },
+}
+def _detect_lang(accept_language: str | None) -> str:
+    if not accept_language:
+        return "en"
+    for part in re.split(r",\s*", accept_language):
+        tag = part.split(";")[0].strip().lower()
+        if tag.startswith("zh"):
+            return "zh"
+        if tag.startswith("en"):
+            return "en"
+    return "en"
+def _make_callback_handler(state: str, login_result: dict | None = None, server: str = ""):
+    if login_result is None:
+        login_result = {"received": False, "error": None}
+    class CallbackHandler(BaseHTTPRequestHandler):
+        def do_GET(self):
+            parsed = urlparse(self.path)
+            if parsed.path != "/callback":
+                self.send_response(404)
+                self.end_headers()
+                return
+            lang = _detect_lang(self.headers.get("Accept-Language"))
+            t = _I18N[lang]
+            params = parse_qs(parsed.query)
+            received_state = params.get("state", [""])[0]
+            if received_state != state:
+                self.send_response(400)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(t["error_state"].encode("utf-8"))
+                login_result["error"] = "State mismatch (CSRF protection)"
+                return
+            mcp_key = params.get("mcp_key", [""])[0]
+            namespace = params.get("namespace", [""])[0]
+            if not mcp_key:
+                self.send_response(400)
+                self.send_header("Content-Type", "text/html; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(t["error_missing_key"].encode("utf-8"))
+                login_result["error"] = "Missing mcp_key in callback"
+                return
+            login_result["mcp_key"] = mcp_key
+            login_result["namespace"] = namespace
+            login_result["server_url"] = server or DEFAULT_SERVER
+            login_result["received"] = True
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            html = (
+                "<html><body style='text-align:center;padding:60px;font-family:sans-serif'>"
+                f"<h2>{t['success_title']}</h2>"
+                f"<p>{t['success_body']}</p>"
+                "</body></html>"
+            )
+            self.wfile.write(html.encode("utf-8"))
+        def log_message(self, format, *args):
+            pass
+    return CallbackHandler
+def login(
+    key: str = typer.Option("", "--key", "-k", help="MCP Key"),
+    browser: bool = typer.Option(False, "--browser", "-b", help="Browser login"),
+    server: str = typer.Option("", "--server", "-s", help="Hub Server URL"),
+):
+    """Login to Mobox Hub Server"""
+    if browser:
+        _browser_login(server)
+        return
+    _manual_login(key, server)
+def _manual_login(key: str, server: str):
+    if not key:
+        key = Prompt.ask("[bold]MCP Key[/bold]")
+    if not key:
+        utils.error("MCP Key is required")
+        raise typer.Exit(1)
+    if not server:
+        server = Prompt.ask(
+            "[bold]Hub Server URL[/bold]",
+            default=DEFAULT_SERVER,
+        )
+    utils.waiting("Verifying key...")
+    result = asyncio.run(_verify_key(key, server))
+    if not result["success"]:
+        utils.error(f"Verification failed: {result.get('error', 'unknown')}")
+        raise typer.Exit(1)
+    namespace = result.get("namespace", "unknown")
+    save_credentials(key, namespace, server)
+    utils.success(f"Login successful! namespace={namespace}")
+    utils.info(f"Server: {server}")
+async def _verify_key(key: str, server_url: str) -> dict:
+    """Verify MCP key by calling query list on Hub Server"""
+    try:
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamablehttp_client
+        async with streamablehttp_client(
+            server_url,
+            headers={"X-MCP-Key": key},
+        ) as (read_stream, write_stream, _):
+            async with ClientSession(read_stream, write_stream) as session:
+                await session.initialize()
+                result = await session.call_tool("query", {
+                    "description": "verify",
+                    "mode": "list",
+                    "options": {"type": "apps"},
+                })
+                for item in result.content:
+                    if hasattr(item, "text"):
+                        try:
+                            data = json.loads(item.text)
+                            ns = data.get("namespace", "")
+                            if ns:
+                                return {"success": True, "namespace": ns}
+                        except json.JSONDecodeError:
+                            pass
+                return {"success": True, "namespace": "user"}
+    except Exception as e:
+        error_str = str(e)
+        # Check HTTP status code patterns more precisely
+        for code in ("401", "403"):
+            if f"HTTP {code}" in error_str or f"status {code}" in error_str:
+                return {"success": False, "error": "Invalid MCP Key"}
+        return {"success": False, "error": error_str}
+def _browser_login(server: str):
+    """Browser-based OAuth-style login"""
+    state = secrets.token_hex(32)
+    port = random.randint(18900, 18999)
+    callback_url = f"http://127.0.0.1:{port}/callback"
+    auth_url = (
+        f"https://modelgate.net/mobox/cli-auth"
+        f"?callback={quote(callback_url, safe='')}&state={state}"
+    )
+    login_result = {"received": False, "error": None}
+    handler_cls = _make_callback_handler(state, login_result, server)
+    httpd = HTTPServer(("127.0.0.1", port), handler_cls)
+    utils.waiting(f"Starting local server on 127.0.0.1:{port}...")
+    utils.info(f"Opening browser: {auth_url}")
+    webbrowser.open(auth_url)
+    utils.waiting("Waiting for login callback (timeout: 5 min)...")
+    # Loop until valid callback or timeout (handles favicon/preflight requests)
+    deadline = time.time() + 300
+    while not login_result["received"] and not login_result["error"]:
+        remaining = deadline - time.time()
+        if remaining <= 0:
+            break
+        httpd.timeout = remaining
+        httpd.handle_request()
+    httpd.server_close()
+    if not login_result["received"]:
+        if login_result["error"]:
+            utils.error(login_result["error"])
+        else:
+            utils.error("Login timed out. Try again or use --key.")
+        raise typer.Exit(1)
+    save_credentials(
+        login_result["mcp_key"],
+        login_result["namespace"],
+        login_result["server_url"],
+    )
+    utils.success(f"Login successful! namespace={login_result['namespace']}")
+    utils.info(f"Server: {login_result['server_url']}")
+def logout():
+    """Clear local credentials"""
+    clear_credentials()
+    utils.success("Logged out. Credentials removed.")
+def whoami():
+    """Show current auth status"""
+    creds = load_credentials()
+    if not creds or not creds.get("mcp_key"):
+        utils.error("Not logged in. Run [bold]mobox login[/bold] first.")
+        raise typer.Exit(1)
+    key = creds["mcp_key"]
+    masked = key[:4] + "..." + key[-4:] if len(key) > 20 else "***"
+    utils.console.print(f"  Namespace: [bold]{creds.get('namespace', 'N/A')}[/bold]")
+    utils.console.print(f"  Server:    {creds.get('server_url', 'N/A')}")
+    utils.console.print(f"  Key:       {masked}")
+    utils.console.print(f"  Since:     {creds.get('created_at', 'N/A')}")

mobox/client.py ADDED Viewed

@@ -0,0 +1,98 @@
+"""MoboxClient - MCP protocol communication with Hub Server"""
+import json
+from typing import Any, Optional
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+class MoboxClient:
+    """Wrapper around MCP SDK StreamableHTTP client"""
+    def __init__(self, server_url: str, mcp_key: str):
+        self.server_url = server_url
+        self.mcp_key = mcp_key
+    async def call_tool(self, tool_name: str, arguments: dict) -> dict:
+        """Call a remote MCP tool and return parsed result"""
+        try:
+            async with streamablehttp_client(
+                self.server_url,
+                headers={"X-MCP-Key": self.mcp_key},
+            ) as (read_stream, write_stream, _):
+                async with ClientSession(read_stream, write_stream) as session:
+                    await session.initialize()
+                    result = await session.call_tool(tool_name, arguments)
+                    return self._parse_result(result)
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+    def _parse_result(self, result) -> dict:
+        """Parse MCP CallToolResult into dict"""
+        if not result or not result.content:
+            return {"success": False, "error": "Empty response"}
+        for item in result.content:
+            if hasattr(item, "text"):
+                try:
+                    return json.loads(item.text)
+                except json.JSONDecodeError:
+                    return {"success": True, "text": item.text}
+        return {"success": True, "raw": str(result.content)}
+    # --- Convenience methods ---
+    async def upload(self, mode: str, options: Optional[dict] = None) -> dict:
+        args: dict[str, Any] = {"description": "CLI upload", "mode": mode}
+        if options:
+            args["options"] = options
+        return await self.call_tool("upload", args)
+    async def build(self, mode: str, options: Optional[dict] = None) -> dict:
+        args: dict[str, Any] = {"description": "CLI build", "mode": mode}
+        if options:
+            args["options"] = options
+        return await self.call_tool("build", args)
+    async def control(self, mode: str, options: Optional[dict] = None) -> dict:
+        args: dict[str, Any] = {"description": "CLI control", "mode": mode}
+        if options:
+            args["options"] = options
+        return await self.call_tool("control", args)
+    async def query(self, mode: str, options: Optional[dict] = None) -> dict:
+        args: dict[str, Any] = {"description": "CLI query", "mode": mode}
+        if options:
+            args["options"] = options
+        return await self.call_tool("query", args)
+    async def boxbash(self, mode: str, options: Optional[dict] = None) -> dict:
+        args: dict[str, Any] = {
+            "mode": mode,
+            "description": "CLI boxbash",
+        }
+        if options:
+            # command is a top-level param in boxbash, not inside options
+            if "command" in options:
+                args["command"] = options.pop("command")
+            args["options"] = options
+        return await self.call_tool("boxbash", args)
+    async def boxfile(self, mode: str, options: Optional[dict] = None) -> dict:
+        args: dict[str, Any] = {
+            "mode": mode,
+            "description": "CLI boxfile",
+        }
+        if options:
+            args["options"] = options
+        return await self.call_tool("boxfile", args)
+def get_client() -> MoboxClient:
+    """Create MoboxClient from saved credentials, exit if not logged in"""
+    from mobox.utils import require_auth
+    creds = require_auth()
+    return MoboxClient(creds["server_url"], creds["mcp_key"])

mobox/commands/__init__.py ADDED Viewed

File without changes

mobox/commands/deploy.py ADDED Viewed

@@ -0,0 +1,149 @@
+"""Deploy commands: upload, deploy"""
+import asyncio
+import hashlib
+from pathlib import Path
+import httpx
+import typer
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+from mobox import utils
+from mobox.client import get_client
+def upload(
+    file: str = typer.Argument(..., help="Path to tar.gz file"),
+):
+    """Upload package to Hub Server"""
+    file_path = Path(file).resolve()
+    if not file_path.exists():
+        utils.error(f"File not found: {file_path}")
+        raise typer.Exit(1)
+    client = get_client()
+    upload_name = file_path.name
+    # Step 1: Get upload config
+    utils.waiting("Getting upload config...")
+    config_result = asyncio.run(
+        client.upload("get", {"upload_name": upload_name})
+    )
+    if not config_result.get("success"):
+        utils.error(config_result.get("error", "Failed to get upload config"))
+        raise typer.Exit(1)
+    config = config_result.get("config", {})
+    upload_url = config.get("upload_url")
+    upload_token = config.get("temp_api_key")
+    upload_id = config_result.get("upload_id", "")
+    if not upload_url:
+        utils.error("Server did not return upload URL")
+        raise typer.Exit(1)
+    # Step 2: Upload file via HTTP
+    md5 = _calculate_md5(file_path)
+    size = file_path.stat().st_size
+    asyncio.run(_upload_file(upload_url, upload_token, file_path, md5, size))
+    # Step 3: Check upload status
+    utils.waiting("Verifying upload...")
+    check_result = asyncio.run(
+        client.upload("check", {"upload_id": upload_id})
+    )
+    if check_result.get("success"):
+        uid = check_result.get("upload_id", upload_id)
+        utils.success(f"Upload complete, upload_id: {uid}")
+    else:
+        utils.warn("Upload sent but verification unclear. Check with `mobox apps`.")
+async def _upload_file(
+    url: str, token: str, path: Path, md5: str, size: int
+):
+    """Upload file via HTTP POST multipart form-data"""
+    headers = {"X-Temp-API-Key": token}
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+    ) as progress:
+        task = progress.add_task("Uploading...", total=size)
+        async with httpx.AsyncClient(
+            timeout=httpx.Timeout(300.0),
+        ) as http:
+            with open(path, "rb") as f:
+                resp = await http.post(
+                    url,
+                    files={"file": (path.name, f, "application/gzip")},
+                    data={"fileMD5": md5, "fileSize": str(size)},
+                    headers=headers,
+                )
+            progress.update(task, completed=size)
+            if resp.status_code not in (200, 201):
+                utils.error(f"Upload failed: HTTP {resp.status_code}")
+                raise typer.Exit(1)
+def deploy(
+    app_name: str = typer.Argument(..., help="Application name"),
+    upload_id: str = typer.Option(
+        "", "--upload-id", "-u", help="Upload ID"
+    ),
+    action: str = typer.Option(
+        "auto", "--action", "-a", help="deploy/update/redeploy/auto"
+    ),
+    framework: str = typer.Option(
+        "", "--framework", "-f", help="Framework (e.g. nextjs/express/vite-react)"
+    ),
+):
+    """Deploy or update an application"""
+    if action not in ("deploy", "update", "redeploy", "auto"):
+        utils.error(f"Invalid action: {action}. Use deploy/update/redeploy/auto")
+        raise typer.Exit(1)
+    if not framework:
+        config_path = Path.cwd() / "app-deploy.json"
+        if config_path.exists():
+            try:
+                import json
+                fw = json.loads(config_path.read_text()).get("framework", "")
+                if fw:
+                    framework = fw
+            except Exception:
+                pass
+    client = get_client()
+    options = {"app_name": app_name, "action": action}
+    if upload_id:
+        options["upload_id"] = upload_id
+    if framework:
+        options["framework"] = framework
+    utils.waiting(f"Deploying {app_name} ({action})...")
+    result = asyncio.run(client.build("deploy", options))
+    if not result.get("success"):
+        utils.error(result.get("error", f"Failed to deploy {app_name}"))
+        raise typer.Exit(1)
+    utils.success("Deploy task submitted")
+    url = result.get("url", "")
+    if url:
+        utils.info(f"URL: {url}")
+def _calculate_md5(path: Path) -> str:
+    md5 = hashlib.md5()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            md5.update(chunk)
+    return md5.hexdigest()

mobox/commands/local.py ADDED Viewed

@@ -0,0 +1,82 @@
+"""Local commands: detect, pack"""
+import tempfile
+from pathlib import Path
+import typer
+from mobox import utils
+def detect(
+    path: str = typer.Argument(".", help="Project path to detect"),
+):
+    """Detect project framework and generate app-deploy.json"""
+    project_path = Path(path).resolve()
+    if not project_path.exists():
+        utils.error(f"Path not found: {project_path}")
+        raise typer.Exit(1)
+    from mobox.local.detect_project import ProjectDetector
+    detector = ProjectDetector(str(project_path))
+    result = detector.detect()
+    if not result.get("success"):
+        utils.error(result.get("error", "Detection failed"))
+        raise typer.Exit(1)
+    config = result.get("config", {})
+    utils.success(f"Framework: {config.get('framework', 'unknown')}")
+    build_cmd = config.get("build", {}).get("command", "")
+    if build_cmd:
+        utils.info(f"Build: {build_cmd}")
+    port = config.get("port")
+    if port:
+        utils.info(f"Port: {port}")
+    utils.info("app-deploy.json generated")
+def pack(
+    path: str = typer.Argument(".", help="Project path to pack"),
+    name: str = typer.Option("", "--name", "-n", help="Application name"),
+    ver: str = typer.Option("", "--version", "-V", help="Version"),
+    output: str = typer.Option("", "--output", "-o", help="Output path"),
+):
+    """Pack project into tar.gz for upload"""
+    project_path = Path(path).resolve()
+    if not project_path.exists():
+        utils.error(f"Path not found: {project_path}")
+        raise typer.Exit(1)
+    if not output:
+        output = str(Path(tempfile.gettempdir()) / "mobox-pack.tar.gz")
+    from mobox.local.pack_project import ProjectPackager
+    packager = ProjectPackager(
+        str(project_path),
+        output,
+        app_name=name or None,
+        app_version=ver or None,
+    )
+    result = packager.package()
+    if not result.get("success"):
+        err = result.get("error", "")
+        if err == "BUILD_REQUIRED":
+            details = result.get("details", {})
+            utils.error(
+                f"Project needs build first: {details.get('build_command', 'npm run build')}"
+            )
+        else:
+            utils.error(err or "Pack failed")
+        raise typer.Exit(1)
+    utils.success(f"Packed: {result['output_path']} ({result['size']})")
+    utils.info(
+        f"Files: {result['included_files']} included, {result['excluded_files']} excluded"
+    )