m2f-cli 0.2.0__py3-none-any.whl

m2f_cli/__init__.py

@@ -0,0 +1,3 @@
+"""M2F Agent Platform CLI client."""
+
+__version__ = "0.2.0"

m2f_cli/__main__.py

@@ -0,0 +1,3 @@
+from m2f_cli.main import main
+
+main()

m2f_cli/api_client.py

@@ -0,0 +1,365 @@
+"""HTTP client for the M2F Agent Platform backend API."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, BinaryIO, Dict, List, Optional
+
+import httpx
+
+# Bypass proxy for local backend connections
+for _key in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY"):
+    os.environ.pop(_key, None)
+os.environ.setdefault("no_proxy", "localhost,127.0.0.1")
+
+from m2f_cli.config import load_config
+
+DEFAULT_TIMEOUT = 30.0
+UPLOAD_TIMEOUT = 300.0
+
+
+class APIError(Exception):
+    """Raised when an API call returns a non-success status."""
+
+    def __init__(self, status_code: int, detail: str) -> None:
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+class M2FClient:
+    """Synchronous HTTP client wrapping the M2F backend API."""
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        access_token: Optional[str] = None,
+    ) -> None:
+        config = load_config()
+        self.base_url = (base_url or config.server_url or "").rstrip("/")
+        self.api_key = api_key or config.api_key
+        self.access_token = access_token or config.access_token
+
+        if not self.base_url:
+            raise APIError(0, "Server URL is not configured. Run `m2f login` or `m2f auth` first.")
+
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            timeout=DEFAULT_TIMEOUT,
+        )
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _auth_headers(self) -> Dict[str, str]:
+        """Return the appropriate Authorization header."""
+        if self.api_key:
+            return {"Authorization": self.api_key}
+        if self.access_token:
+            return {"Authorization": f"Bearer {self.access_token}"}
+        return {}
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Any = None,
+        data: Any = None,
+        files: Any = None,
+        params: Any = None,
+        timeout: Optional[float] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Any:
+        """Send an HTTP request and return the parsed JSON body."""
+        merged_headers = {**self._auth_headers(), **(headers or {})}
+        resp = self._client.request(
+            method,
+            path,
+            json=json,
+            data=data,
+            files=files,
+            params=params,
+            headers=merged_headers,
+            timeout=timeout or DEFAULT_TIMEOUT,
+        )
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise APIError(resp.status_code, detail)
+        if resp.status_code == 204:
+            return None
+        try:
+            return resp.json()
+        except Exception:
+            return resp.text
+
+    # ------------------------------------------------------------------
+    # Auth endpoints
+    # ------------------------------------------------------------------
+
+    def login(self, email: str, password: str) -> Dict[str, Any]:
+        """POST /api/v1/auth/login"""
+        return self._request(
+            "POST",
+            "/api/v1/auth/login",
+            json={"email": email, "password": password},
+        )
+
+    def me(self) -> Dict[str, Any]:
+        """GET /api/v1/auth/me"""
+        return self._request("GET", "/api/v1/auth/me")
+
+    # ------------------------------------------------------------------
+    # Project endpoints
+    # ------------------------------------------------------------------
+
+    def create_project(self, name: str, source_type: str = "upload") -> Dict[str, Any]:
+        """POST /api/v1/projects"""
+        return self._request(
+            "POST",
+            "/api/v1/projects",
+            json={"name": name, "source_type": source_type},
+        )
+
+    def list_projects(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        source_type: Optional[str] = None,
+        status_in: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """GET /api/v1/projects — returns {items, total, page, page_size}."""
+        params: List[tuple[str, Any]] = [("page", page), ("page_size", page_size)]
+        if source_type:
+            params.append(("source_type", source_type))
+        if status_in:
+            for s in status_in:
+                params.append(("status", s))
+        return self._request("GET", "/api/v1/projects", params=params)
+
+    def get_project(self, project_id: str) -> Dict[str, Any]:
+        """GET /api/v1/projects/{project_id}"""
+        return self._request("GET", f"/api/v1/projects/{project_id}")
+
+    def get_project_progress(self, project_id: str) -> Dict[str, Any]:
+        """GET /api/v1/projects/{project_id}/progress"""
+        return self._request("GET", f"/api/v1/projects/{project_id}/progress")
+
+    def get_project_logs(self, project_id: str, offset: int = 0) -> Dict[str, Any]:
+        """GET /api/v1/projects/{project_id}/logs"""
+        return self._request(
+            "GET",
+            f"/api/v1/projects/{project_id}/logs",
+            params={"offset": offset},
+        )
+
+    # ------------------------------------------------------------------
+    # Upload endpoints
+    # ------------------------------------------------------------------
+
+    def upload_init(
+        self,
+        project_id: str,
+        filename: str,
+        total_chunks: int,
+    ) -> Dict[str, Any]:
+        """POST /api/v1/upload/{project_id}/init (multipart form)."""
+        return self._request(
+            "POST",
+            f"/api/v1/upload/{project_id}/init",
+            data={
+                "filename": filename,
+                "total_chunks": str(total_chunks),
+            },
+        )
+
+    def upload_chunk(
+        self,
+        project_id: str,
+        upload_id: str,
+        chunk_index: int,
+        chunk_data: BinaryIO,
+    ) -> Dict[str, Any]:
+        """POST /api/v1/upload/{project_id}/chunk"""
+        return self._request(
+            "POST",
+            f"/api/v1/upload/{project_id}/chunk",
+            data={
+                "upload_id": upload_id,
+                "chunk_index": str(chunk_index),
+            },
+            files={"file": ("chunk", chunk_data, "application/octet-stream")},
+            timeout=UPLOAD_TIMEOUT,
+        )
+
+    def upload_complete(self, project_id: str, upload_id: str) -> Dict[str, Any]:
+        """POST /api/v1/upload/{project_id}/complete"""
+        return self._request(
+            "POST",
+            f"/api/v1/upload/{project_id}/complete",
+            data={"upload_id": upload_id},
+        )
+
+    # ------------------------------------------------------------------
+    # Formalize endpoints
+    # ------------------------------------------------------------------
+
+    def create_formalize_job(
+        self,
+        statement_prompt: str,
+        formalize_proof: bool = False,
+        proof_prompt: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """POST /api/v1/formalize-jobs"""
+        payload: Dict[str, Any] = {
+            "statement_prompt": statement_prompt,
+            "formalize_proof": formalize_proof,
+        }
+        if proof_prompt:
+            payload["proof_prompt"] = proof_prompt
+        return self._request("POST", "/api/v1/formalize-jobs", json=payload)
+
+    def list_formalize_jobs(self, page: int = 1, page_size: int = 50, project_id: str | None = None) -> Dict[str, Any]:
+        """GET /api/v1/formalize-jobs"""
+        params: Dict[str, Any] = {"page": page, "page_size": page_size}
+        if project_id:
+            params["project_id"] = project_id
+        return self._request("GET", "/api/v1/formalize-jobs", params=params)
+
+    def get_formalize_job(self, job_id: str) -> Dict[str, Any]:
+        """GET /api/v1/formalize-jobs/{job_id}"""
+        return self._request("GET", f"/api/v1/formalize-jobs/{job_id}")
+
+    def get_formalize_job_output(self, job_id: str) -> str:
+        """GET /api/v1/formalize-jobs/{job_id}/output"""
+        return self._request("GET", f"/api/v1/formalize-jobs/{job_id}/output")
+
+    def get_formalize_job_log(self, job_id: str) -> str:
+        """GET /api/v1/formalize-jobs/{job_id}/log"""
+        return self._request("GET", f"/api/v1/formalize-jobs/{job_id}/log")
+
+    # ------------------------------------------------------------------
+    # CLI Fill Sorry endpoints
+    # ------------------------------------------------------------------
+
+    def create_cli_job(
+        self,
+        mode: str = "item",
+        need_proof: bool = True,
+        target_file: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """POST /api/v1/json-jobs/cli"""
+        payload: Dict[str, Any] = {
+            "mode": mode,
+            "need_proof": need_proof,
+        }
+        if target_file:
+            payload["target_file"] = target_file
+        return self._request("POST", "/api/v1/json-jobs/cli", json=payload)
+
+    def upload_job_zip(
+        self,
+        job_id: str,
+        zip_data: BinaryIO,
+        target_file: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """PUT /api/v1/json-jobs/{job_id}/upload-zip"""
+        data = {}
+        if target_file:
+            data["target_file"] = target_file
+        return self._request(
+            "PUT",
+            f"/api/v1/json-jobs/{job_id}/upload-zip",
+            data=data or None,
+            files={"file": ("project.zip", zip_data, "application/zip")},
+            timeout=UPLOAD_TIMEOUT,
+        )
+
+    def download_artifact(self, job_id: str, artifact: str) -> bytes:
+        """GET /api/v1/json-jobs/{job_id}/download/{artifact} - returns raw bytes."""
+        resp = self._client.request(
+            "GET",
+            f"/api/v1/json-jobs/{job_id}/download/{artifact}",
+            headers=self._auth_headers(),
+            timeout=UPLOAD_TIMEOUT,
+        )
+        if resp.status_code >= 400:
+            raise APIError(resp.status_code, "Download failed")
+        return resp.content
+
+    def list_cli_jobs(self, page: int = 1, page_size: int = 50) -> Dict[str, Any]:
+        """GET /api/v1/formalize-jobs?source_type=cli"""
+        return self._request(
+            "GET", "/api/v1/formalize-jobs",
+            params={"page": page, "page_size": page_size, "source_type": "cli"},
+        )
+
+    def get_job_file_content(self, job_id: str, path: str) -> Dict[str, Any]:
+        """GET /api/v1/json-jobs/{job_id}/file-content?path=xxx"""
+        return self._request(
+            "GET",
+            f"/api/v1/json-jobs/{job_id}/file-content",
+            params={"path": path},
+        )
+
+    # ------------------------------------------------------------------
+    # Sorry CLI (Prover) endpoints
+    # ------------------------------------------------------------------
+
+    def sorry_upload(
+        self,
+        tar_gz_data: bytes,
+        project_name: str = "CLI Upload",
+    ) -> Dict[str, Any]:
+        """POST /api/v1/sorry-cli/upload — upload tar.gz, creates job."""
+        resp = self._client.request(
+            "POST",
+            "/api/v1/sorry-cli/upload",
+            content=tar_gz_data,
+            headers={
+                **self._auth_headers(),
+                "Content-Type": "application/gzip",
+                "X-Project-Name": project_name,
+            },
+            timeout=UPLOAD_TIMEOUT,
+        )
+        if resp.status_code >= 400:
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                detail = resp.text
+            raise APIError(resp.status_code, detail)
+        return resp.json()
+
+    def sorry_list_files(self, job_id: str) -> Dict[str, Any]:
+        """GET /api/v1/sorry-cli/{job_id}/files"""
+        return self._request("GET", f"/api/v1/sorry-cli/{job_id}/files")
+
+    def sorry_list_sorries(self, job_id: str, path: str) -> Dict[str, Any]:
+        """GET /api/v1/sorry-cli/{job_id}/sorries?path=..."""
+        return self._request("GET", f"/api/v1/sorry-cli/{job_id}/sorries", params={"path": path})
+
+    def sorry_run(self, job_id: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """POST /api/v1/sorry-cli/{job_id}/run — queue compile+prove via Worker."""
+        return self._request("POST", f"/api/v1/sorry-cli/{job_id}/run", json=payload)
+
+    def sorry_status(self, job_id: str) -> Dict[str, Any]:
+        """GET /api/v1/sorry-cli/{job_id} — read status from DB."""
+        return self._request("GET", f"/api/v1/sorry-cli/{job_id}")
+
+    def sorry_read_file(self, job_id: str, path: str) -> Dict[str, Any]:
+        """GET /api/v1/sorry-cli/{job_id}/file?path=..."""
+        return self._request("GET", f"/api/v1/sorry-cli/{job_id}/file", params={"path": path})
+
+    def sorry_history(self, job_id: str, limit: int = 50) -> Dict[str, Any]:
+        """GET /api/v1/sorry-cli/{job_id}/history"""
+        return self._request("GET", f"/api/v1/sorry-cli/{job_id}/history", params={"limit": limit})
+
+    def sorry_tasks(self, job_id: str, limit: int = 50) -> Dict[str, Any]:
+        """GET /api/v1/sorry-cli/{job_id}/tasks"""
+        return self._request("GET", f"/api/v1/sorry-cli/{job_id}/tasks", params={"limit": limit})

m2f_cli/config.py

@@ -0,0 +1,61 @@
+"""Configuration management for M2F CLI.
+
+Stores configuration at ~/.m2f/config.json.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel
+
+CONFIG_DIR = Path.home() / ".m2f"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+class M2FConfig(BaseModel):
+    """CLI configuration model."""
+
+    server_url: Optional[str] = None
+    api_key: Optional[str] = None
+    access_token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    username: Optional[str] = None
+    language: str = "zh"
+
+
+def _ensure_config_dir() -> None:
+    """Create ~/.m2f/ directory if it does not exist."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> M2FConfig:
+    """Load configuration from disk. Returns defaults if file is missing."""
+    if not CONFIG_FILE.exists():
+        return M2FConfig()
+    try:
+        data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        return M2FConfig(**data)
+    except (json.JSONDecodeError, TypeError):
+        return M2FConfig()
+
+
+def save_config(config: M2FConfig) -> None:
+    """Persist configuration to disk."""
+    _ensure_config_dir()
+    CONFIG_FILE.write_text(
+        json.dumps(config.model_dump(), indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+
+def update_config(**kwargs) -> M2FConfig:
+    """Load config, update given fields, save, and return the new config."""
+    config = load_config()
+    for key, value in kwargs.items():
+        if hasattr(config, key):
+            setattr(config, key, value)
+    save_config(config)
+    return config