@suiflex/suitest-mcp 0.1.0 → 0.1.2

package/package.json

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

package/python/suitest_lifecycle/blackbox/mcp.py

@@ -388,15 +388,22 @@ def blackbox_publish_results(**kwargs: Any) -> dict[str, Any]:
     import os as _os
     import re as _re
 
+    from suitest_lifecycle.retest import rewrite_project_id
+
     project_id = str(kwargs.pop("project_id", "") or "")
     suite_name = str(kwargs.pop("suite_name", "") or "")
+    # EXPLICIT recreate opt-in — mirrors the lifecycle run tools. Without it a
+    # stale binding fails this publish instead of minting a fresh project.
+    recreate = bool(kwargs.pop("recreate_project", False))
     config_path = str(kwargs.get("config_path", "") or "")
     ui, paths = _resolve(**kwargs)
-    if config_path and not project_id:
+    if config_path:
         from suitest_lifecycle.config import load_config
 
         cfg = load_config(config_path)
-        project_id = cfg.publish.project_id
+        if not project_id:
+            project_id = cfg.publish.project_id
+        recreate = recreate or cfg.publish.recreate
     # No project configured → the server finds-or-creates one by a slug derived
     # from the target host. Publishing is MANDATORY in the blackbox pipeline;
     # "no project yet" is not an excuse to keep results local.
@@ -424,6 +431,66 @@ def blackbox_publish_results(**kwargs: Any) -> dict[str, Any]:
 
     try:
         with SuitestClient(api_url, token=token, timeout=180.0) as client:
+            # --- project binding gate (before any upload/insert) ----------- #
+            binding: dict[str, Any] = {"status": "first_setup", "action": "will_create_by_slug"}
+            if project_id:
+                binding = {
+                    "status": "unverified",
+                    "action": "server_unreachable",
+                    "projectId": project_id,
+                }
+                try:
+                    resolved = client.resolve_project(
+                        project_id=project_id,
+                        project_slug=project_slug,
+                        project_name=project_name,
+                    )
+                except Exception:
+                    # Resolve endpoint unreachable/older server: proceed — the
+                    # publish itself still 404s a stale id without inserting.
+                    resolved = None
+                if resolved is not None:
+                    status = str(resolved.get("status", "missing"))
+                    if status == "valid":
+                        binding = {
+                            "status": "valid",
+                            "action": "reused_existing_project",
+                            "projectId": project_id,
+                        }
+                    elif status == "repaired":
+                        project_id = str(resolved.get("projectId", ""))
+                        binding = {
+                            "status": "repaired",
+                            "action": "rebound_by_" + str(resolved.get("matchedBy", "match")),
+                            "projectId": project_id,
+                        }
+                        if config_path:
+                            rewrite_project_id(Path(config_path), project_id)
+                    elif recreate:
+                        binding = {
+                            "status": "recreate_requested",
+                            "action": "will_recreate_by_slug",
+                        }
+                        project_id = ""  # server find-or-creates by slug below
+                    else:
+                        return _envelope(
+                            False,
+                            f"stale project binding: projectId '{project_id}' not found in "
+                            "the workspace and no unambiguous project matched — nothing "
+                            "was published",
+                            data={
+                                "projectBinding": {
+                                    "status": "missing",
+                                    "action": "fail",
+                                    "projectId": project_id,
+                                    "candidates": resolved.get("candidates", []),
+                                }
+                            },
+                            errors=[
+                                "fix publish.projectId (or the project_id argument), or "
+                                "re-run with recreate_project=true to create a new project"
+                            ],
+                        )
 
             def _up(path: str, mime: str) -> str:
                 try:
@@ -505,26 +572,41 @@ def blackbox_publish_results(**kwargs: Any) -> dict[str, Any]:
                 )
             imported = client.bulk_import_cases(
                 project_id=project_id,
-                project_slug=project_slug,
-                project_name=project_name,
+                # Slug fallback ONLY when no validated id — an explicit id must
+                # never silently degrade into a find-or-create.
+                project_slug="" if project_id else project_slug,
+                project_name="" if project_id else project_name,
                 suite_name=suite,
                 mode="frontend",
                 cases=cases_payload,
+                # Current generation = the suite's alive set; an empty payload
+                # (nothing generated) must not stale the whole suite.
+                mark_stale=bool(cases_payload),
             )
+            resolved_id = str(imported.get("projectId", "") or "") or project_id
             run = client.ingest_run(
-                project_id=project_id,
-                project_slug=project_slug,
-                project_name=project_name,
+                project_id=resolved_id,
+                project_slug="" if resolved_id else project_slug,
+                project_name="" if resolved_id else project_name,
                 suite_name=suite,
                 name=f"{suite} run",
                 results=results_payload,
             )
     except SuitestAPIError as exc:
         return _envelope(False, f"publish failed: {exc}", errors=[str(exc)])
+    # Slug-based publish minted (or found) the project — pin its id so the next
+    # blackbox publish is an explicit-id retest, never a re-create.
+    if config_path and resolved_id and binding["status"] in ("first_setup", "recreate_requested"):
+        rewrite_project_id(Path(config_path), resolved_id)
     return _envelope(
         True,
         f"published: {len(imported.get('imported', []))} case(s), run {run.get('runId')}",
-        data={"imported": imported, "run": run},
+        data={
+            "imported": imported,
+            "run": run,
+            "projectBinding": {**binding, "projectId": resolved_id},
+            "staleCases": imported.get("stale", []),
+        },
     )
 
 

package/python/suitest_lifecycle/cli.py

@@ -92,6 +92,12 @@ def main(argv: list[str] | None = None) -> int:
 
     test = sub.add_parser("test", help="Run the full config-driven lifecycle")
     test.add_argument("--config", default="suitest.config.json")
+    test.add_argument(
+        "--recreate-project",
+        action="store_true",
+        help="EXPLICITLY recreate the Suitest project when publish.projectId is "
+        "stale and repair finds no match (otherwise a stale binding fails the run)",
+    )
 
     sub.add_parser("mcp", help="Serve the stdio MCP server")
 
@@ -109,7 +115,10 @@ def main(argv: list[str] | None = None) -> int:
         from suitest_lifecycle.config import load_config
         from suitest_lifecycle.orchestrator import run_lifecycle
 
-        res = run_lifecycle(load_config(args.config))
+        cfg = load_config(args.config)
+        if args.recreate_project:
+            cfg.publish.recreate = True
+        res = run_lifecycle(cfg)
         print(res.summary)
         for step in res.steps:
             print(f"  - {step}")

package/python/suitest_lifecycle/config.py

@@ -76,6 +76,11 @@ class PublishConfig:
     workspace_id: str = ""
     project_id: str = ""
     suite_name: str = ""
+    # EXPLICIT recreate opt-in: when the configured projectId no longer exists
+    # and repair finds no match, a fresh project is created ONLY if this is set
+    # (config keys ``recreateProject``/``resetProjectBinding``, env
+    # SUITEST_RECREATE_PROJECT=1, or the MCP tool arg ``recreate_project``).
+    recreate: bool = False
 
 
 @dataclass
@@ -264,6 +269,8 @@ def load_config(path: str | Path) -> Config:
     publish = PublishConfig()
     pub_raw = raw.get("publish", {})
     if isinstance(pub_raw, dict):
+        import os
+
         publish = PublishConfig(
             enabled=bool(pub_raw.get("enabled", False)),
             api_url=str(pub_raw.get("apiUrl", "http://localhost:4000")).rstrip("/"),
@@ -271,6 +278,11 @@ def load_config(path: str | Path) -> Config:
             workspace_id=str(pub_raw.get("workspaceId", "")),
             project_id=str(pub_raw.get("projectId", "")),
             suite_name=str(pub_raw.get("suiteName", "")),
+            recreate=bool(
+                pub_raw.get("recreateProject", False)
+                or pub_raw.get("resetProjectBinding", False)
+                or os.environ.get("SUITEST_RECREATE_PROJECT", "") in ("1", "true")
+            ),
         )
 
     ids_raw = raw.get("testIds", [])

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
@@ -22,6 +25,10 @@ if TYPE_CHECKING:
 
 PROTOCOL_VERSION = "2024-11-05"
 
+# Run tools accept the explicit recreate opt-in (goal: recreate NEVER happens
+# implicitly — only via this flag or the publish.recreateProject config key).
+RECREATE_TOOLS = frozenset({"run_tests", "run_backend_tests", "run_frontend_tests"})
+
 _TOOL_DESCRIPTIONS = {
     "analyze_project": "Static-analyze the target project; list endpoints (backend) or pages (frontend).",
     "generate_test_cases": "Analyze, build a PRD + test plan, and export runnable test files.",
@@ -74,6 +81,14 @@ _BLACKBOX_INPUT_SCHEMA: dict[str, object] = {
             "type": "string",
             "description": "Suitest project id to publish into (blackbox_publish_results)",
         },
+        "recreate_project": {
+            "type": "boolean",
+            "description": (
+                "EXPLICIT opt-in: recreate the project when the configured/passed "
+                "project id no longer exists and repair finds no match "
+                "(blackbox_publish_results). Without it a stale binding fails the publish."
+            ),
+        },
         "prd_file": {
             "type": "string",
             "description": "Markdown PRD path — PRD-driven semantic plan via the workspace LLM (blackbox_generate_playwright_tests)",
@@ -90,18 +105,29 @@ def _tool_schema(name: str) -> dict[str, object]:
             "description": _TOOL_DESCRIPTIONS.get(name, name),
             "inputSchema": _BLACKBOX_INPUT_SCHEMA,
         }
+    properties: dict[str, object] = {
+        "config_path": {
+            "type": "string",
+            "description": "Path to suitest.config.json",
+            "default": "suitest.config.json",
+        }
+    }
+    if name in RECREATE_TOOLS:
+        properties["recreate_project"] = {
+            "type": "boolean",
+            "description": (
+                "EXPLICIT opt-in: recreate the project when the configured "
+                "publish.projectId no longer exists and repair finds no match. "
+                "Without this flag a stale binding FAILS the run (nothing is inserted)."
+            ),
+            "default": False,
+        }
     return {
         "name": name,
         "description": _TOOL_DESCRIPTIONS.get(name, name),
         "inputSchema": {
             "type": "object",
-            "properties": {
-                "config_path": {
-                    "type": "string",
-                    "description": "Path to suitest.config.json",
-                    "default": "suitest.config.json",
-                }
-            },
+            "properties": properties,
             "required": ["config_path"],
         },
     }
@@ -124,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.0"},
+                "serverInfo": {"name": "suitest-lifecycle", "version": "0.1.2"},
             },
         )
     if method in ("notifications/initialized", "initialized"):
@@ -144,6 +170,11 @@ def handle(message: dict[str, object]) -> dict[str, object] | None:
         try:
             if str(name) in KWARG_TOOLS:
                 envelope = tool(**arguments)
+            elif str(name) in RECREATE_TOOLS:
+                envelope = tool(
+                    str(arguments.get("config_path", "suitest.config.json")),
+                    bool(arguments.get("recreate_project", False)),
+                )
             else:
                 envelope = tool(str(arguments.get("config_path", "suitest.config.json")))
         except Exception as exc:  # defensive: never crash the server on a tool bug
@@ -166,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: