answer42 0.5.6__tar.gz → 0.5.7__tar.gz

{answer42-0.5.6 → answer42-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: answer42
-Version: 0.5.6
+Version: 0.5.7
 Summary: Answer42 — The Answer to Life, Universe, and 1C — UI Driver. MCP-powered 1C:Enterprise UI automation: click, fill, navigate, test, and introspect managed forms through the test-client API
 Author: Marvin (AI Assistant), 42Clouds, and contributors
 Author-email: "Kosolapov Stanislav (proDOOMman)" <prodoomman@gmail.com>

{answer42-0.5.6 → answer42-0.5.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "answer42"
-version = "0.5.6"
+version = "0.5.7"
 description = "Answer42 — The Answer to Life, Universe, and 1C — UI Driver. MCP-powered 1C:Enterprise UI automation: click, fill, navigate, test, and introspect managed forms through the test-client API"
 readme = "README.md"
 requires-python = ">=3.11"

{answer42-0.5.6 → answer42-0.5.7}/src/mcp_1c/credentials.py

@@ -110,6 +110,31 @@ class CredentialsStore:
 
         return None
 
+    def matching_entries(
+        self,
+        base_url: str,
+        account_id: str | None = None,
+    ) -> list[dict[str, object]]:
+        """Return every exact and wildcard credential candidate for a URL.
+
+        Exact URL entries precede wildcard entries so callers can try the most
+        specific mapping first without discarding other matching wildcards.
+        """
+        url = str(base_url or "").strip().rstrip("/")
+        if not url:
+            return []
+        entries = self._account_entries(account_id)
+        exact = [
+            dict(entry) for entry in entries
+            if str(entry.get("url", "")).rstrip("/") == url
+        ]
+        wildcard = [
+            dict(entry) for entry in entries
+            if self._has_wildcards(str(entry.get("url", "")))
+            and fnmatch.fnmatch(url, str(entry.get("url", "")).rstrip("/"))
+        ]
+        return exact + wildcard
+
     def list_entries(
         self,
         account_id: str | None = None,

{answer42-0.5.6 → answer42-0.5.7}/src/mcp_1c/server.py

@@ -4646,17 +4646,26 @@ async def start_session(
     start_monotonic = time.perf_counter()
     stage_monotonic = start_monotonic
     timings: dict[str, float] = {}
+    supplied_username = username
+    supplied_password = password
 
     def mark_stage(name: str) -> None:
         nonlocal stage_monotonic
         now = time.perf_counter()
         timings[f"{name}_seconds"] = round(now - stage_monotonic, 3)
         stage_monotonic = now
-    credential_ref = _resolve_credential_reference(base_url)
+    input_looks_like_url = bool(re.match(r"^[A-Za-z][A-Za-z0-9+.-]*://", str(base_url or "")))
+    # A URL without explicitly supplied credentials is resolved by the web
+    # probe below.  It must try every exact/wildcard candidate and retain the
+    # one that authenticated, rather than preselecting the first match here.
+    credential_ref = (
+        None
+        if input_looks_like_url and not username and not password
+        else _resolve_credential_reference(base_url)
+    )
     credential_account_id = _current_account_id()
     saved_credentials_used = False
     saved_credentials_unverified = False
-    input_looks_like_url = bool(re.match(r"^[A-Za-z][A-Za-z0-9+.-]*://", str(base_url or "")))
     if credential_ref is not None:
         # For saved titles/aliases, replace title -> real URL.  For URL/wildcard matches,
         # keep the original requested URL; using the wildcard pattern itself as /WS value
@@ -4685,11 +4694,19 @@ async def start_session(
         base_url = ""
     web_runtime_probe: dict[str, Any] = {"attempted": False, "status": "not_applicable"}
     if base_url and initial_connection_mode == "ws":
-        web_runtime_probe = await _probe_web_runtime_before_start(base_url, username, password)
+        web_runtime_probe = await _probe_web_runtime_before_start(base_url, supplied_username, supplied_password)
         if web_runtime_probe.get("authentication_failed"):
             # No local 1C runtime/process has been started yet. Do not hide a
             # confirmed publication login rejection behind a later timeout.
             raise ValueError(str(web_runtime_probe.get("message") or "1C web authentication failed"))
+        selected_credential_index = web_runtime_probe.pop("_selected_credential_index", None)
+        if selected_credential_index is not None and not supplied_username and not supplied_password:
+            candidates = _credentials_store().matching_entries(base_url, account_id=credential_account_id)
+            selected = candidates[int(selected_credential_index)]
+            username = str(selected["username"])
+            password = str(selected["password"])
+            saved_credentials_used = True
+            saved_credentials_unverified = not bool(selected.get("verified", False))
     inferred_summary_rag_config = "" if summary_rag_config else _summary_rag_config_from_42clouds_url(base_url)
     effective_summary_rag_config = summary_rag_config or inferred_summary_rag_config
     resolved_version = version or None
@@ -5371,25 +5388,46 @@ async def _probe_web_runtime_before_start(
     """
     if not _is_web_base_url(base_url):
         return {"attempted": False, "status": "not_web_publication"}
-    if not username or not password:
-        return {"attempted": False, "status": "credentials_not_provided"}
-    try:
-        result = await asyncio.to_thread(probe_web_runtime, base_url, username, password)
-        return {"attempted": True, "status": "ok", "runtime": result}
-    except WebRuntimeAuthenticationError as exc:
-        return {
-            "attempted": True,
-            "status": "authentication_failed",
-            "authentication_failed": True,
-            "message": str(exc),
-        }
-    except (WebRuntimeProbeError, requests.RequestException) as exc:
-        logging.info("Web runtime probe skipped for %s: %s", _normalize_base_url(base_url), exc)
+    candidates: list[tuple[str, str, str, int | None]] = []
+    if username or password:
+        candidates.append((username, password, "explicit", None))
+    elif _CREDENTIAL_STORE_ENABLED:
+        for index, entry in enumerate(_credentials_store().matching_entries(base_url, account_id=_current_account_id())):
+            candidates.append((entry["username"], entry["password"], "saved", index))
+    if not candidates:
+        candidates.append(("", "", "empty", None))
+
+    authentication_messages: list[str] = []
+    unavailable_messages: list[str] = []
+    for candidate_username, candidate_password, source, index in candidates:
+        try:
+            result = await asyncio.to_thread(probe_web_runtime, base_url, candidate_username, candidate_password)
+            response: dict[str, Any] = {
+                "attempted": True,
+                "status": "ok",
+                "runtime": result,
+                "credentials_source": source,
+            }
+            if index is not None:
+                response["_selected_credential_index"] = index
+            return response
+        except WebRuntimeAuthenticationError as exc:
+            authentication_messages.append(str(exc))
+        except (WebRuntimeProbeError, requests.RequestException) as exc:
+            logging.info("Web runtime probe skipped for %s: %s", _normalize_base_url(base_url), exc)
+            unavailable_messages.append(str(exc))
+    if unavailable_messages:
         return {
             "attempted": True,
             "status": "unavailable",
-            "message": str(exc),
+            "message": unavailable_messages[-1],
         }
+    return {
+        "attempted": True,
+        "status": "authentication_failed",
+        "authentication_failed": True,
+        "message": authentication_messages[-1] if authentication_messages else "1C web authentication failed",
+    }
 
 
 def _users_url_for_base_url(base_url: str) -> str:

{answer42-0.5.6 → answer42-0.5.7}/src/mcp_1c/webclient_probe.py

@@ -196,6 +196,13 @@ def _login(
         key_size = reply[0]
         encrypted_login_key = reply[1 : 1 + key_size]
         login_key = _decrypt(encrypted_login_key, proof_key, _INNER_IV)
+    except WebRuntimeProbeError as exc:
+        # Some 1C web publications signal an invalid password only through a
+        # malformed encrypted proof instead of an HTTP 401/403. Treat it as an
+        # authentication rejection so callers can try the next stored match.
+        if "invalid password-proof CRC" in str(exc):
+            raise WebRuntimeAuthenticationError("1C web authentication failed: incorrect user or password") from exc
+        raise
     except (IndexError, KeyError, ValueError, TypeError) as exc:
         raise WebRuntimeProbeError("1C web authentication returned an unsupported password-proof response") from exc