insightfactory-cli 1.1.2.dev29__py3-none-any.whl → 1.1.2.dev31__py3-none-any.whl

if_cli/commands/mcp.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
 import importlib.util
+import platform
 import sys
 
 from if_cli.cli import Options, parse_args
 from if_cli.config import config_file, get_profile, list_factories, load_config, parse_factory_section
 from if_cli.http import parse_timeout_seconds
+from if_cli.router.log import log
 from if_cli.runtime import die
 
 MCP_OPTIONS: Options = {
@@ -75,6 +77,8 @@ def _stray_positional(rest: list[str]) -> str | None:
 
 
 def mcp_command(argv: list[str]) -> None:
+    log(f"starting on Python {platform.python_version()}")
+
     if "-h" in argv or "--help" in argv:
         sys.stdout.write(MCP_USAGE)
         return
@@ -146,7 +150,6 @@ def mcp_command(argv: list[str]) -> None:
     # import bug inside if_cli.router propagates instead of reading as a missing extra.
     if importlib.util.find_spec("mcp") is None:
         die(MISSING_MCP_EXTRA)
-    from if_cli.router.log import log
     from if_cli.router.server import build_router, run_server
 
     timeout = parse_timeout_seconds(values["timeout"], "--timeout")

if_cli/router/log.py

@@ -1,13 +1,20 @@
 from __future__ import annotations
 
 import sys
+import time
+
+# Captured at import: this module loads before the router does anything else
+# diagnosable, so it stands in for process start. Two `log()` lines can then
+# be subtracted to time the phase between them.
+_START = time.monotonic()
 
 
 def log(message: str) -> None:
-    """Write one diagnostic line to stderr.
+    """Write one timestamped diagnostic line to stderr.
 
     The router speaks MCP over stdout, so stderr is the only channel that can
     carry anything to the operator. This lives in its own module because both
     `server` and `upstream` write to it and `server` imports `upstream`.
     """
-    sys.stderr.write(f"[if-cli mcp] {message}\n")
+    elapsed_ms = round((time.monotonic() - _START) * 1000)
+    sys.stderr.write(f"[if-cli mcp] +{elapsed_ms}ms {message}\n")

if_cli/router/server.py

@@ -9,7 +9,7 @@ from typing import Any, TypeVar
 import anyio
 import mcp_types as types
 from mcp.server import Server
-from mcp.server.context import ServerRequestContext
+from mcp.server.context import CallNext, HandlerResult, ServerMiddleware, ServerRequestContext
 from mcp.server.stdio import stdio_server
 from mcp.shared.exceptions import MCPError
 
@@ -137,6 +137,7 @@ class Router:
 
     async def build_catalog(self) -> list[types.Tool]:
         """Build the merged catalogue. Safe to call again to pick up a new login."""
+        log(f"catalogue: building from {self.config.catalog_source}")
         catalogues = await self._catalogues()
         source = catalogues.get(self.config.catalog_source)
         if source is None:
@@ -536,6 +537,27 @@ def advertised_extensions(router: Router) -> dict[str, dict[str, Any]]:
     return {SKILLS_EXTENSION: {}} if router.config.skills else {}
 
 
+def _log_first_initialize() -> ServerMiddleware[Any]:
+    """Log once the router has answered a client's `initialize`.
+
+    Read against `prime_catalog`'s startup log lines, this tells an operator
+    apart a slow process (nothing logged yet), a slow factory (catalogue
+    build still running past this point), and a client that called before
+    the handshake (a tool call logged before this line ever appears).
+    """
+    logged = False
+
+    async def middleware(ctx: ServerRequestContext[Any, Any], call_next: CallNext) -> HandlerResult:
+        nonlocal logged
+        result = await call_next(ctx)
+        if not logged and ctx.method == "initialize":
+            logged = True
+            log("answered the first initialize")
+        return result
+
+    return middleware
+
+
 async def _serve(router: Router) -> None:
     server: Server[Any] = Server(
         SERVER_NAME,
@@ -553,6 +575,7 @@ async def _serve(router: Router) -> None:
     # the handshake rebuilds its capabilities from `server.extensions` once the
     # protocol version is known, and ignores the ones computed here.
     server.extensions = advertised_extensions(router)
+    server.middleware.append(_log_first_initialize())
     # Answer `initialize` immediately: the catalogue build runs as a background
     # task so one hung factory reads as a slow tools/list, not a failed
     # handshake (clients cap startup time).

if_cli/router/upstream.py

@@ -138,6 +138,22 @@ class ConnectUrlRecorder:
         return types.ElicitResult(action="decline")
 
 
+def _has_url_request(result: types.InputRequiredResult) -> bool:
+    """Whether any of the result's requests is the Databricks connect flow.
+
+    A request in any other mode (today, only `form`) gates a preview behind a
+    confirmation rather than asking for a trip to a browser, so its presence
+    alone never puts the result on the connect path. A URL-mode request does,
+    even one whose URL fails the origin check in `_connect_url` and so
+    contributes no link: the call still did not run, and the caller still
+    needs the existing refusal, not a result that reads as success.
+    """
+    return any(
+        isinstance(getattr(request, "params", None), types.ElicitRequestURLParams)
+        for request in (result.input_requests or {}).values()
+    )
+
+
 def _relayable_requests(result: types.InputRequiredResult, origin: str) -> tuple[list[str], str | None]:
     """The messages this router will repeat, and the first connect URL it will name.
 
@@ -279,7 +295,16 @@ class Upstream:
         result = await self._run(call, elicitation_callback=recorder)
         if isinstance(result, types.InputRequiredResult):
             lines, url = _relayable_requests(result, self.profile["host"])
-            return self._connect_refusal(lines, url)
+            if _has_url_request(result):
+                return self._connect_refusal(lines, url)
+            # Every mutating tool gates a `confirmed:false` call behind a form-mode
+            # elicitation once the router advertises elicitation at all (see
+            # `ConnectUrlRecorder`). That gate is a preview, not a connect flow: the
+            # factory's own answer to a client with no elicitation capability is a
+            # plain `pending_confirmation` result, and the router owes the caller
+            # the closest thing it can relay to that, not an error pointing at a
+            # web UI the caller was never asked to visit.
+            return self._preview_result(lines)
         if recorder.declined_url_request:
             # The older-revision path. The server elicited in band and carried on
             # once the router declined, so the connect page is in the recorder
@@ -290,6 +315,24 @@ class Upstream:
             return self._connect_refusal(_result_texts(result), recorder.url)
         return result
 
+    def _preview_result(self, lines: list[str]) -> types.CallToolResult:
+        """A form-mode approval gate, relayed as the ordinary result it is.
+
+        This loses the structured `pending_confirmation` JSON a client with no
+        elicitation capability would see (the `approvalId`, `preview`,
+        `impactedResources`): the router has only the elicitation's message
+        text to work with, not the tool's own result body, which the factory
+        never sends once it has decided to gate the call. The message still
+        carries what a caller needs, and the caller still proceeds the same
+        way, by calling again with `confirmed:true`.
+
+        Not an error: the call is still pending, exactly as it would be for a
+        client that never advertised elicitation, and marking this `is_error`
+        would make a normal preview indistinguishable from the connect refusal
+        it is not.
+        """
+        return types.CallToolResult(content=[types.TextContent(text="\n".join(lines))], is_error=False)
+
     def _connect_refusal(self, lines: list[str], url: str | None) -> types.CallToolResult:
         """Turn the factory's request for input into a refusal naming the page to visit.
 

{insightfactory_cli-1.1.2.dev29.dist-info → insightfactory_cli-1.1.2.dev31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: insightfactory-cli
-Version: 1.1.2.dev29
+Version: 1.1.2.dev31
 Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
 Project-URL: Homepage, https://insightfactory.ai
 Author-email: "insightfactory.ai Support" <support@insightfactory.ai>
@@ -265,6 +265,14 @@ uv tool install 'insightfactory-cli[mcp]'
 uvx --from 'insightfactory-cli[mcp]' if-cli mcp foundry
 ```
 
+The first `uvx` launch resolves and downloads the package from PyPI before it runs, which
+added roughly four to six seconds on top of the usual startup in local testing, against
+under two seconds once `uv`'s cache was warm. A client with a fixed handshake budget
+(Claude Code allows 30 seconds) usually has room for that, but a slow network can close
+the gap. Two ways to avoid paying it on every launch: `uv tool install 'insightfactory-cli[mcp]'`
+puts a real script on `PATH` with no resolve step, or run the same `uvx --from ...` command
+by hand once before pointing a client at it, which warms `uv`'s cache for the launches after.
+
 Add it to `.mcp.json`:
 
 ```json

{insightfactory_cli-1.1.2.dev29.dist-info → insightfactory_cli-1.1.2.dev31.dist-info}/RECORD

@@ -17,19 +17,19 @@ if_cli/commands/api.py,sha256=XeVhhD39Oho4xNbMJIGh1I6vi53on5EGGsAtsb_5TAg,9016
 if_cli/commands/config.py,sha256=1KAxjme897NIbXTGBw1rNJlXnFvhbEUf5MAli8A93ns,1724
 if_cli/commands/login.py,sha256=vxsYcRZWsaNEzekyN1zy4ROJO-OCGUpjaVUBhtbK1LY,3255
 if_cli/commands/logout.py,sha256=TW0P4_tXcTtiHHR73xVPHyhlbOWD1jBnkZsMImCiCBw,668
-if_cli/commands/mcp.py,sha256=SVF4egfA9RzjY5GHRlbk0mVi0HtmKfMh8v-SSYHjs98,7270
+if_cli/commands/mcp.py,sha256=iaSsqWkV1lnFjIw9y1pX1ORB1MdKiOVWgK23EDIsDB4,7342
 if_cli/commands/profiles.py,sha256=tgZP5sMqzbFHXlfvglL2plsGdU0M3joo3wvQKX45J1U,3950
 if_cli/commands/set_token.py,sha256=BVyv_QmByvllr04pE2sz8JFEscHbIgOC-7ZPg61PRoc,1886
 if_cli/commands/token.py,sha256=CyiXkyH7vxgH91-n-XJzeHnLI6mZJwO9Js5AHvfHaeM,1120
 if_cli/router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 if_cli/router/catalog.py,sha256=Er2ZbWTwDUVU-qBGCvyA0bIlFk3UYw_6sVUlYwBhMpI,4992
 if_cli/router/content.py,sha256=POL2n5NIY8yenQHJe8pUbTuTNpPSUSm0Y6Txbvehzhs,14487
-if_cli/router/log.py,sha256=YLWeHUb05HUnS3XHubCwy7oLZAUEGAiHcZysz_YMAAo,412
+if_cli/router/log.py,sha256=wtaqsFcD3hPJRu4jCJaDMSedj-43Y07ym62YgrOm1yM,740
 if_cli/router/policy.py,sha256=CclbjuOA5mwwoQiNDa17iQeN9eXRbfy11bS9JFd8gL4,2840
-if_cli/router/server.py,sha256=JZ-7xbNyDadSY1VVLHpSVTjfx6vxI_uumxFaD22Pl0Y,26449
-if_cli/router/upstream.py,sha256=2V78k6SXnOJ9Epc0tnhTuUPVBrYuW5vwflT-d3xKwVc,16122
-insightfactory_cli-1.1.2.dev29.dist-info/METADATA,sha256=4M5zoiKKqT52vOoEOrx42CE_TsGyFawx1-4CLa7v5JE,23695
-insightfactory_cli-1.1.2.dev29.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
-insightfactory_cli-1.1.2.dev29.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
-insightfactory_cli-1.1.2.dev29.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
-insightfactory_cli-1.1.2.dev29.dist-info/RECORD,,
+if_cli/router/server.py,sha256=yCjGAm-tnZBOTg5AfvojnLcKcZLEbQQeT9iqqX8XV5A,27397
+if_cli/router/upstream.py,sha256=Ga0OM918Y1CFyQFGs2wO0ocyjcMe1Wk0LvffOZOaE34,18559
+insightfactory_cli-1.1.2.dev31.dist-info/METADATA,sha256=LkShsicB2QHUEjaS9FmsW9T2dPlGIl92Ew-OMsSCg28,24331
+insightfactory_cli-1.1.2.dev31.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+insightfactory_cli-1.1.2.dev31.dist-info/entry_points.txt,sha256=UlX854D7f-7dBj5F0wGdakVy6vopvP9hA1BN-gv739w,44
+insightfactory_cli-1.1.2.dev31.dist-info/licenses/LICENSE,sha256=8eZ1YAABL398qESVJc_FlK1voYQ0GAh-R_rNBQK6QH8,234
+insightfactory_cli-1.1.2.dev31.dist-info/RECORD,,

{insightfactory_cli-1.1.2.dev29.dist-info → insightfactory_cli-1.1.2.dev31.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.3
+Generator: hatchling 1.32.4
 Root-Is-Purelib: true
 Tag: py3-none-any