@suiflex/suitest-mcp 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@suiflex/suitest-mcp",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "publishConfig": {
     "access": "public"
   },

package/python/suitest_lifecycle/blackbox/mcp.py

@@ -414,10 +414,7 @@ def blackbox_publish_results(**kwargs: Any) -> dict[str, Any]:
     token = _os.environ.get("SUITEST_API_KEY", "")
     if not api_url or not token:
         return _envelope(False, "SUITEST_API_URL / SUITEST_API_KEY not set")
-    try:
-        from suitest_sdk import SuitestAPIError, SuitestClient
-    except ImportError:
-        return _envelope(False, "suiflex-suitest-sdk not installed")
+    from suitest_lifecycle.http_client import SuitestAPIError, SuitestClient
 
     plan_path = paths.test_plan_json
     if not plan_path.is_file():

package/python/suitest_lifecycle/http_client.py

@@ -0,0 +1,207 @@
+"""Stdlib-only Suitest API client for the bundled lifecycle.
+
+Mirrors the slice of the ``suiflex-suitest-sdk`` surface the lifecycle needs
+(binding resolve, bulk import, run ingest, artifact upload, LLM proxy) using
+only ``urllib`` — so ``npx @suiflex/suitest-mcp`` publishes out of the box,
+with zero ``pip install`` on the host. The pip SDK remains the richer client
+for external integrations; this one exists so a brand-new QA user's first run
+lands in the web UI instead of silently skipping publish.
+"""
+
+from __future__ import annotations
+
+import json
+import mimetypes
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any
+
+JSONDict = dict[str, Any]
+
+
+class SuitestAPIError(RuntimeError):
+    """Raised on a non-2xx API response. Carries status + parsed body."""
+
+    def __init__(self, status_code: int, body: object) -> None:
+        super().__init__(f"Suitest API error {status_code}: {body}")
+        self.status_code = status_code
+        self.body = body
+
+
+class SuitestClient:
+    """Drop-in for the SDK client's lifecycle-facing methods (sync, stdlib)."""
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        token: str | None = None,
+        workspace_id: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self._base = base_url.rstrip("/")
+        self._timeout = timeout
+        self._headers: dict[str, str] = {"Accept": "application/json"}
+        if token:
+            self._headers["Authorization"] = f"Bearer {token}"
+        if workspace_id:
+            self._headers["X-Workspace-Id"] = workspace_id
+
+    def __enter__(self) -> SuitestClient:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    def close(self) -> None:  # urllib is connectionless — kept for SDK parity
+        return None
+
+    # -- low level ----------------------------------------------------------
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, object] | None = None,
+        json_body: JSONDict | None = None,
+        data: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> object:
+        url = self._base + path
+        if params:
+            url += "?" + urllib.parse.urlencode({k: str(v) for k, v in params.items()})
+        hdrs = dict(self._headers)
+        body: bytes | None = data
+        if json_body is not None:
+            body = json.dumps(json_body).encode("utf-8")
+            hdrs["Content-Type"] = "application/json"
+        if headers:
+            hdrs.update(headers)
+        req = urllib.request.Request(url, data=body, method=method, headers=hdrs)
+        try:
+            with urllib.request.urlopen(req, timeout=self._timeout) as resp:
+                raw = resp.read()
+                if resp.status == 204 or not raw:
+                    return None
+                return json.loads(raw)
+        except urllib.error.HTTPError as exc:
+            raw = exc.read()
+            try:
+                parsed: object = json.loads(raw)
+            except ValueError:
+                parsed = raw.decode("utf-8", errors="replace")
+            raise SuitestAPIError(exc.code, parsed) from exc
+
+    # -- LLM proxy ------------------------------------------------------------
+    def llm_complete(
+        self,
+        prompt: str,
+        *,
+        system: str | None = None,
+        max_tokens: int = 4096,
+        temperature: float = 0.2,
+    ) -> str:
+        body: JSONDict = {"prompt": prompt, "maxTokens": max_tokens, "temperature": temperature}
+        if system is not None:
+            body["system"] = system
+        result = self._request("POST", "/api/v1/llm/complete", json_body=body)
+        return str(result.get("content", "")) if isinstance(result, dict) else ""
+
+    # -- lifecycle ingest -----------------------------------------------------
+    def resolve_project(
+        self, *, project_id: str = "", project_slug: str = "", project_name: str = ""
+    ) -> JSONDict:
+        result = self._request(
+            "POST",
+            "/api/v1/ingest/resolve-project",
+            json_body={
+                "projectId": project_id,
+                "projectSlug": project_slug,
+                "projectName": project_name,
+            },
+        )
+        return result if isinstance(result, dict) else {}
+
+    def bulk_import_cases(
+        self,
+        *,
+        project_id: str = "",
+        suite_name: str,
+        mode: str,
+        cases: list[JSONDict],
+        project_slug: str = "",
+        project_name: str = "",
+        mark_stale: bool = False,
+    ) -> JSONDict:
+        result = self._request(
+            "POST",
+            "/api/v1/test-cases/bulk-import",
+            json_body={
+                "projectId": project_id,
+                "projectSlug": project_slug,
+                "projectName": project_name,
+                "suiteName": suite_name,
+                "mode": mode,
+                "cases": cases,
+                "markStale": mark_stale,
+            },
+        )
+        return result if isinstance(result, dict) else {}
+
+    def ingest_run(
+        self,
+        *,
+        project_id: str = "",
+        suite_name: str,
+        name: str,
+        results: list[JSONDict],
+        env: str = "staging",
+        branch: str | None = None,
+        commit_sha: str | None = None,
+        project_slug: str = "",
+        project_name: str = "",
+    ) -> JSONDict:
+        body: JSONDict = {
+            "projectId": project_id,
+            "projectSlug": project_slug,
+            "projectName": project_name,
+            "suiteName": suite_name,
+            "name": name,
+            "env": env,
+            "results": results,
+        }
+        if branch is not None:
+            body["branch"] = branch
+        if commit_sha is not None:
+            body["commitSha"] = commit_sha
+        result = self._request("POST", "/api/v1/runs/ingest", json_body=body)
+        return result if isinstance(result, dict) else {}
+
+    def upload_file(self, path: str, *, content_type: str | None = None) -> str:
+        """Multipart upload to /api/v1/files; returns the durable s3:// URL.
+
+        The whole file is buffered in memory — run videos are a few MB, fine.
+        """
+        ct = content_type or mimetypes.guess_type(path)[0] or "application/octet-stream"
+        boundary = uuid.uuid4().hex
+        name = os.path.basename(path)
+        with open(path, "rb") as fh:
+            payload = fh.read()
+        head = (
+            f"--{boundary}\r\n"
+            f'Content-Disposition: form-data; name="file"; filename="{name}"\r\n'
+            f"Content-Type: {ct}\r\n\r\n"
+        ).encode()
+        tail = f"\r\n--{boundary}--\r\n".encode()
+        result = self._request(
+            "POST",
+            "/api/v1/files",
+            data=head + payload + tail,
+            headers={"Content-Type": f"multipart/form-data; boundary={boundary}"},
+        )
+        if not isinstance(result, dict):
+            raise SuitestAPIError(0, "unexpected upload response")
+        return str(result["url"])

package/python/suitest_lifecycle/llm_bridge.py

@@ -124,11 +124,8 @@ class RemoteLlmClient:
     def _complete(self, prompt: str, *, system: str | None = None, max_tokens: int = 4096) -> str:
         if self._disabled:
             return ""
-        try:
-            from suitest_sdk import SuitestAPIError, SuitestClient
-        except ImportError:
-            self._disabled = True
-            return ""
+        from suitest_lifecycle.http_client import SuitestAPIError, SuitestClient
+
         try:
             with SuitestClient(
                 self._api_url,

package/python/suitest_lifecycle/mcp_server.py

@@ -12,7 +12,10 @@ Every tool takes a single ``config_path`` argument and returns the structured
 from __future__ import annotations
 
 import json
+import os
 import sys
+import urllib.error
+import urllib.request
 from typing import TYPE_CHECKING, TextIO
 
 from suitest_lifecycle.tools import KWARG_TOOLS, TOOLS
@@ -147,7 +150,7 @@ def handle(message: dict[str, object]) -> dict[str, object] | None:
             {
                 "protocolVersion": PROTOCOL_VERSION,
                 "capabilities": {"tools": {}},
-                "serverInfo": {"name": "suitest-lifecycle", "version": "0.1.1"},
+                "serverInfo": {"name": "suitest-lifecycle", "version": "0.1.2"},
             },
         )
     if method in ("notifications/initialized", "initialized"):
@@ -194,7 +197,39 @@ def handle(message: dict[str, object]) -> dict[str, object] | None:
     return None
 
 
+def verify_credentials() -> str | None:
+    """Check SUITEST_API_URL + SUITEST_API_KEY; return an error string if unusable.
+
+    Both must be set, and the key must authenticate against the URL
+    (``GET /api/v1/api-keys/whoami`` — the key pins the workspace/project every
+    tool publishes into). Any failure must abort the connection: a server that
+    accepts empty or mismatched credentials silently drops all publishes.
+    """
+    api_url = os.environ.get("SUITEST_API_URL", "").strip().rstrip("/")
+    api_key = os.environ.get("SUITEST_API_KEY", "").strip()
+    if not api_url or not api_key:
+        return (
+            "SUITEST_API_URL and SUITEST_API_KEY are both required "
+            "(set them in the mcpServers env block); refusing to start"
+        )
+    req = urllib.request.Request(
+        f"{api_url}/api/v1/api-keys/whoami",
+        headers={"Authorization": f"Bearer {api_key}"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10):
+            return None
+    except urllib.error.HTTPError as exc:
+        return f"SUITEST_API_KEY rejected by {api_url} (HTTP {exc.code}); refusing to start"
+    except (urllib.error.URLError, OSError) as exc:
+        return f"SUITEST_API_URL {api_url} unreachable ({exc}); refusing to start"
+
+
 def serve(stdin: TextIO = sys.stdin, stdout: TextIO = sys.stdout) -> None:
+    error = verify_credentials()
+    if error is not None:
+        sys.stderr.write(f"suitest-mcp: {error}\n")
+        raise SystemExit(1)
     for line in stdin:
         line = line.strip()
         if not line:

package/python/suitest_lifecycle/models.py

@@ -142,6 +142,9 @@ class TestResult:
     error: str = ""
     automation_file: str = ""
     artifacts: list[str] = field(default_factory=list)
+    # Captured subprocess output (tail-bounded) — published as run log lines.
+    stdout: str = ""
+    stderr: str = ""
     # Phase 2 — rich recording (collected from each test's sidecar JSON).
     steps: list[StepResult] = field(default_factory=list)
     video_path: str = ""

package/python/suitest_lifecycle/publish.py

@@ -2,9 +2,10 @@
 
 Builds the bulk-import (cases + steps + source code) and run-ingest (completed
 run + per-step outcomes + video/screenshot artifacts) payloads, then sends them
-via the Suitest SDK. The SDK is imported lazily so the lifecycle core stays
-stdlib-only; if it (or the server) is unavailable, publishing degrades to a
-clean ``{"published": False, "reason": ...}`` instead of failing the run.
+via the bundled stdlib client (:mod:`suitest_lifecycle.http_client`) — no pip
+install needed on the host, so ``npx @suiflex/suitest-mcp`` publishes out of
+the box. If the server is unavailable, publishing degrades to a clean
+``{"published": False, "reason": ...}`` instead of failing the run.
 """
 
 from __future__ import annotations
@@ -149,6 +150,8 @@ def _result_payloads(
                 "durationMs": r.duration_ms,
                 "error": r.error,
                 "failureKind": kinds.get(r.test_id, ""),
+                "stdout": r.stdout,
+                "stderr": r.stderr,
                 "steps": [
                     {
                         "order": s.index,
@@ -187,10 +190,9 @@ def publish_results(
     # No binding info (legacy caller) + no id → refuse rather than guess.
     if binding is None and not config.publish.project_id:
         return {"published": False, "reason": "publish.projectId not set"}
-    try:
-        from suitest_sdk import SuitestAPIError, SuitestClient
-    except ImportError:
-        return {"published": False, "reason": "suiflex-suitest-sdk not installed"}
+    # Bundled stdlib client — publish works out of the box under
+    # `npx @suiflex/suitest-mcp`, no pip install required on the host.
+    from suitest_lifecycle.http_client import SuitestAPIError, SuitestClient
 
     # first_setup / explicit recreate publish by slug (server find-or-creates);
     # valid / repaired / unverified publish by explicit id (server 404s stale ids

package/python/suitest_lifecycle/retest.py

@@ -95,16 +95,14 @@ def rewrite_project_id(config_path: Path, project_id: str) -> bool:
         return False
 
 
-def _make_client(config: Config) -> BindingClient | None:
+def _make_client(config: Config) -> BindingClient:
     import os
 
-    try:
-        from suitest_sdk import SuitestClient
-    except ImportError:
-        return None
+    from suitest_lifecycle.http_client import SuitestClient
+
     api_url = config.publish.api_url or os.environ.get("SUITEST_API_URL", "")
     token = config.publish.token or os.environ.get("SUITEST_API_KEY") or None
-    return SuitestClient(  # type: ignore[no-any-return]
+    return SuitestClient(
         api_url, token=token, workspace_id=config.publish.workspace_id or None, timeout=30.0
     )
 
@@ -117,10 +115,6 @@ def resolve_binding(
         return BindingResult("local_only", "publish_disabled")
     if client is None:
         client = _make_client(config)
-    if client is None:
-        return BindingResult(
-            "local_only", "sdk_not_installed", detail="suiflex-suitest-sdk not installed"
-        )
 
     slug = project_slug(config.project_name)
     if not config.publish.project_id:

package/python/suitest_lifecycle/runner.py

@@ -62,7 +62,15 @@ def _as_outcome(value: str) -> TestOutcome:
         return TestOutcome.PASSED
 
 
-def _run_one(file_path: Path, python: str, timeout_sec: int) -> tuple[TestOutcome, int, str]:
+def _tail(text: str | None, lines: int = 500) -> str:
+    # ponytail: 500-line tail bound keeps the ingest payload sane for chatty tests.
+    return "\n".join((text or "").strip().splitlines()[-lines:])
+
+
+def _run_one(
+    file_path: Path, python: str, timeout_sec: int
+) -> tuple[TestOutcome, int, str, str, str]:
+    """Returns (outcome, duration_ms, error, stdout_tail, stderr_tail)."""
     start = time.monotonic()
     try:
         proc = subprocess.run(
@@ -72,19 +80,25 @@ def _run_one(file_path: Path, python: str, timeout_sec: int) -> tuple[TestOutcom
             timeout=timeout_sec,
             cwd=str(file_path.parent),
         )
-    except subprocess.TimeoutExpired:
+    except subprocess.TimeoutExpired as exc:
+        out = exc.stdout.decode() if isinstance(exc.stdout, bytes) else (exc.stdout or "")
+        err = exc.stderr.decode() if isinstance(exc.stderr, bytes) else (exc.stderr or "")
         return (
             TestOutcome.ERROR,
             int((time.monotonic() - start) * 1000),
             f"timeout after {timeout_sec}s",
+            _tail(out),
+            _tail(err),
         )
     duration_ms = int((time.monotonic() - start) * 1000)
+    out_tail = _tail(proc.stdout)
+    err_tail_full = _tail(proc.stderr)
     if proc.returncode == 0:
-        return TestOutcome.PASSED, duration_ms, ""
+        return TestOutcome.PASSED, duration_ms, "", out_tail, err_tail_full
     err = (proc.stderr or "").strip() or (proc.stdout or "").strip() or f"exit {proc.returncode}"
     # Keep the last ~30 lines — enough to see the assertion without flooding the report.
     err_tail = "\n".join(err.splitlines()[-30:])
-    return TestOutcome.FAILED, duration_ms, err_tail
+    return TestOutcome.FAILED, duration_ms, err_tail, out_tail, err_tail_full
 
 
 def run_tests(
@@ -114,7 +128,9 @@ def run_tests(
             )
             continue
         file_path = test_dir / case.automation_file
-        outcome, duration_ms, error = _run_one(file_path, interpreter, timeout_sec)
+        outcome, duration_ms, error, out_tail, err_tail = _run_one(
+            file_path, interpreter, timeout_sec
+        )
         steps, video, screenshot = _collect_steps(case, test_dir, outcome)
         artifacts = [p for p in (video, screenshot) if p]
         results.append(
@@ -126,6 +142,8 @@ def run_tests(
                 duration_ms=duration_ms,
                 error=error,
                 automation_file=case.automation_file,
+                stdout=out_tail,
+                stderr=err_tail,
                 steps=steps,
                 video_path=video,
                 screenshot_path=screenshot,