feat: add mcp server, cli agent terminal, explorer canvas highlighting

- add stdio mcp server (uipath-dev-mcp) exposing run api as mcp tools
  so cli agents can execute runs server-side with real-time websocket
  events and graph visualization
- add cli agent terminal with pty support and clipboard handling
- add explorer canvas execution highlighting during runs
- broadcast run/state events to all ws clients (not just subscribers)
- remove in-house coding agent implementation and openai dependency
- bump version to 0.0.74

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: cristipufu

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-dev"
-version = "0.0.73"
+version = "0.0.74"
 description = "UiPath Developer Console"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
@@ -11,8 +11,9 @@ dependencies = [
   "fastapi>=0.128.8",
   "uvicorn[standard]>=0.40.0",
   "uipath>=2.10.0, <2.11.0",
-  "openai",
   "aiosqlite>=0.20.0",
+  "pywinpty>=2.0.0; sys_platform == 'win32'",
+  "mcp[cli]>=1.0.0",
 ]
 classifiers = [
   "Intended Audience :: Developers",
@@ -34,6 +35,7 @@ Documentation = "https://uipath.github.io/uipath-python/"
 [project.scripts]
 uipath-dev = "uipath.dev.__mock__:main"
 uipath-dev-server = "uipath.dev.__mock_server__:main"
+uipath-dev-mcp = "uipath.dev.mcp:main"
 
 [build-system]
 requires = ["hatchling"]

src/uipath/dev/mcp/__init__.py

@@ -0,0 +1,196 @@
+"""UiPath Dev MCP Server — exposes dev server run tools via stdio."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+import httpx
+import websockets
+from mcp.server.fastmcp import Context, FastMCP
+
+mcp = FastMCP(
+    "uipath-dev",
+    instructions=(
+        "This MCP server is the ONLY way to run, test, or execute agents, "
+        "functions, and projects. Do NOT use shell commands like "
+        "`uipath run`, `langgraph dev`, `python -m`, or any subprocess. "
+        "Always use the tools provided here instead."
+    ),
+)
+
+
+def _base_url() -> str:
+    port = os.environ.get("UIPATH_DEV_SERVER_PORT", "8080")
+    host = os.environ.get("UIPATH_DEV_SERVER_HOST", "localhost")
+    return f"http://{host}:{port}"
+
+
+def _ws_url() -> str:
+    port = os.environ.get("UIPATH_DEV_SERVER_PORT", "8080")
+    host = os.environ.get("UIPATH_DEV_SERVER_HOST", "localhost")
+    return f"ws://{host}:{port}/ws"
+
+
+def _api_url(path: str) -> str:
+    return f"{_base_url()}/api{path}"
+
+
+async def _report_tool_call(tool: str, args: dict[str, Any] | None = None) -> None:
+    """Notify the dev server that an MCP tool was invoked."""
+    try:
+        async with httpx.AsyncClient() as client:
+            await client.post(
+                _api_url("/mcp/events"),
+                json={"tool": tool, "args": args or {}},
+                timeout=5,
+            )
+    except Exception:
+        pass  # Best-effort — don't fail the tool if reporting fails
+
+
+@mcp.tool()
+async def list_entrypoints() -> list[dict[str, Any]]:
+    """List all runnable agents, functions, and projects.
+
+    Call this first to discover what is available to run.
+    Use the returned names with get_entrypoint_schema or run_entrypoint.
+    """
+    await _report_tool_call("list_entrypoints")
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(_api_url("/entrypoints"), timeout=10)
+        resp.raise_for_status()
+        return resp.json()
+
+
+@mcp.tool()
+async def get_entrypoint_schema(entrypoint: str) -> dict[str, Any]:
+    """Get the input/output schema for an entrypoint.
+
+    Args:
+        entrypoint: Name of the entrypoint (from list_entrypoints).
+
+    Returns the JSON schema describing the entrypoint's expected
+    input and output. Use this to construct input_data for run_entrypoint.
+    """
+    await _report_tool_call("get_entrypoint_schema", {"entrypoint": entrypoint})
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(
+            _api_url(f"/entrypoints/{entrypoint}/schema"),
+            timeout=30,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+
+@mcp.tool()
+async def run_entrypoint(
+    entrypoint: str,
+    ctx: Context,  # type: ignore[type-arg]
+    input_data: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Run an agent, function, or project.
+
+    This is the ONLY correct way to execute code in this project — never
+    use shell commands.
+
+    Args:
+        entrypoint: Name of the entrypoint (from list_entrypoints).
+        input_data: Input data matching the entrypoint's input schema.
+            Use get_entrypoint_schema to see what fields are expected.
+            Defaults to empty dict if not provided.
+
+    Executes on the dev server with real-time graph visualization in the
+    browser. Streams progress as nodes execute, then returns the result.
+    """
+    await _report_tool_call(
+        "run_entrypoint", {"entrypoint": entrypoint, "input_data": input_data}
+    )
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(
+            _api_url("/runs"),
+            json={
+                "entrypoint": entrypoint,
+                "input_data": input_data or {},
+                "mode": "run",
+            },
+            timeout=10,
+        )
+        resp.raise_for_status()
+        run: dict[str, Any] = resp.json()
+        run_id = run["id"]
+
+    await ctx.log("info", f"Run {run_id} created — streaming updates...")
+
+    # Connect to WebSocket and subscribe to run events
+    terminal_statuses = {"completed", "failed", "suspended"}
+    final_status = None
+
+    async with websockets.connect(_ws_url()) as ws:
+        # Subscribe to this run's events
+        await ws.send(json.dumps({"type": "subscribe", "payload": {"run_id": run_id}}))
+
+        async for raw in ws:
+            msg = json.loads(raw)
+            msg_type = msg.get("type", "")
+            payload = msg.get("payload", {})
+
+            if msg_type == "run.updated" and payload.get("id") == run_id:
+                status = payload.get("status", "")
+                await ctx.report_progress(
+                    progress=1 if status in terminal_statuses else 0,
+                    total=1,
+                    message=f"Run status: {status}",
+                )
+                if status in terminal_statuses:
+                    final_status = status
+                    break
+
+            elif msg_type == "state" and payload.get("run_id") == run_id:
+                node = payload.get("node_name", "")
+                phase = payload.get("phase", "")
+                if phase == "started":
+                    await ctx.log("info", f"Node '{node}' started")
+                elif phase == "completed":
+                    await ctx.log("info", f"Node '{node}' completed")
+
+            elif msg_type == "log" and payload.get("run_id") == run_id:
+                level = payload.get("level", "info").lower()
+                message = payload.get("message", "")
+                await ctx.log(level, message)
+
+    # Fetch final run result
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(_api_url(f"/runs/{run_id}"), timeout=10)
+        resp.raise_for_status()
+        result: dict[str, Any] = resp.json()
+
+    if final_status == "failed":
+        error = result.get("error", {})
+        await ctx.log("error", f"Run failed: {error.get('detail', 'unknown error')}")
+    else:
+        await ctx.log("info", f"Run {final_status}: {run_id}")
+
+    return result
+
+
+@mcp.tool()
+async def get_run_status(run_id: str) -> dict[str, Any]:
+    """Get current status and details of a run.
+
+    Args:
+        run_id: The run ID returned by run_entrypoint.
+
+    Returns full run details including status, output, traces, and logs.
+    """
+    await _report_tool_call("get_run_status", {"run_id": run_id})
+    async with httpx.AsyncClient() as client:
+        resp = await client.get(_api_url(f"/runs/{run_id}"), timeout=10)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def main() -> None:
+    """Entry point for the uipath-dev-mcp CLI command."""
+    mcp.run(transport="stdio")

src/uipath/dev/server/__init__.py

@@ -27,10 +27,9 @@
 from uipath.dev.models.eval_data import EvalItemResult, EvalRunState
 from uipath.dev.models.execution import ExecutionRun
 from uipath.dev.server.debug_bridge import WebDebugBridge
-from uipath.dev.services.agent import AgentService
+from uipath.dev.services.cli_agent import CliAgentService
 from uipath.dev.services.eval_service import EvalService
 from uipath.dev.services.run_service import RunService
-from uipath.dev.services.skill_service import SkillService
 
 logger = logging.getLogger(__name__)
 
@@ -98,11 +97,11 @@ def __init__(
             on_eval_run_completed=self._on_eval_run_completed,
         )
 
-        self.skill_service = SkillService()
-
-        self.agent_service = AgentService(
-            skill_service=self.skill_service,
-            on_event=self._on_agent_event,
+        self.cli_agent_service = CliAgentService(
+            on_output=self._on_cli_agent_output,
+            on_exit=self._on_cli_agent_exit,
+            server_port=self.port,
+            server_host=self.host,
         )
 
     def create_app(self) -> Any:
@@ -140,12 +139,17 @@ async def run_async(self) -> None:
             log_level="warning",
         )
         server = uvicorn.Server(config)
-        await server.serve()
+        try:
+            await server.serve()
+        finally:
+            await self.shutdown()
 
     async def shutdown(self) -> None:
         """Clean up resources before shutting down."""
         logger.info("Shutting down server resources...")
         self._stop_watcher()
+        # Stop any active CLI agent PTY sessions
+        await self.cli_agent_service.stop_all_sessions()
         # Close any active WebSocket connections
         await self.connection_manager.disconnect_all()
         # Give threads time to finish
@@ -319,61 +323,16 @@ def _on_eval_run_completed(self, run: EvalRunState) -> None:
         """Broadcast eval run completed to all connected clients."""
         self.connection_manager.broadcast_eval_run_completed(run)
 
-    def _on_agent_event(self, event: Any) -> None:
-        """Route agent events to the appropriate broadcast method."""
-        from uipath.dev.services.agent import (
-            ErrorOccurred,
-            PlanUpdated,
-            StatusChanged,
-            TextDelta,
-            TextGenerated,
-            ThinkingGenerated,
-            TokenUsageUpdated,
-            ToolApprovalRequired,
-            ToolCompleted,
-            ToolStarted,
-            UserQuestionAsked,
-        )
+    def _on_cli_agent_output(self, session_id: str, data: bytes) -> None:
+        """Broadcast CLI agent PTY output as base64."""
+        import base64
+
+        encoded = base64.b64encode(data).decode("ascii")
+        self.connection_manager.broadcast_cli_agent_output(session_id, encoded)
 
-        cm = self.connection_manager
-        match event:
-            case StatusChanged(session_id=sid, status=status):
-                cm.broadcast_agent_status(sid, status)
-            case TextGenerated(session_id=sid, content=content, done=done):
-                cm.broadcast_agent_text(sid, content, done)
-            case TextDelta(session_id=sid, delta=delta):
-                cm.broadcast_agent_text_delta(sid, delta)
-            case ThinkingGenerated(session_id=sid, content=content):
-                cm.broadcast_agent_thinking(sid, content)
-            case PlanUpdated(session_id=sid, items=items):
-                cm.broadcast_agent_plan(sid, items)
-            case ToolStarted(session_id=sid, tool_call_id=tcid, tool=tool, args=args):
-                cm.broadcast_agent_tool_use(sid, tcid, tool, args)
-            case ToolCompleted(
-                session_id=sid,
-                tool_call_id=tcid,
-                tool=tool,
-                result=result,
-                is_error=is_error,
-            ):
-                cm.broadcast_agent_tool_result(sid, tcid, tool, result, is_error)
-            case ToolApprovalRequired(
-                session_id=sid, tool_call_id=tcid, tool=tool, args=args
-            ):
-                cm.broadcast_agent_tool_approval(sid, tcid, tool, args)
-            case UserQuestionAsked(
-                session_id=sid, question_id=qid, question=q, options=opts
-            ):
-                cm.broadcast_agent_question(sid, qid, q, opts)
-            case ErrorOccurred(session_id=sid, message=message):
-                cm.broadcast_agent_error(sid, message)
-            case TokenUsageUpdated(
-                session_id=sid,
-                prompt_tokens=pt,
-                completion_tokens=ct,
-                total_session_tokens=total,
-            ):
-                cm.broadcast_agent_token_usage(sid, pt, ct, total)
+    def _on_cli_agent_exit(self, session_id: str, exit_code: int) -> None:
+        """Broadcast CLI agent process exit."""
+        self.connection_manager.broadcast_cli_agent_exit(session_id, exit_code)
 
     @staticmethod
     def _find_free_port(host: str, start_port: int, max_attempts: int = 100) -> int:

src/uipath/dev/server/app.py

@@ -150,7 +150,6 @@ async def _config():
         return {"auth_enabled": auth_enabled, **_user_project}
 
     # Register routes
-    from uipath.dev.server.routes.agent import router as agent_router
     from uipath.dev.server.routes.entrypoints import router as entrypoints_router
     from uipath.dev.server.routes.evals import router as evals_router
     from uipath.dev.server.routes.evaluators import router as evaluators_router
@@ -198,9 +197,16 @@ def _on_reload_done(t: asyncio.Task[None]) -> None:
     app.include_router(reload_router, prefix="/api")
     app.include_router(evaluators_router, prefix="/api")
     app.include_router(evals_router, prefix="/api")
-    app.include_router(agent_router, prefix="/api")
     app.include_router(files_router, prefix="/api")
 
+    from uipath.dev.server.routes.cli_agent import router as cli_agent_router
+
+    app.include_router(cli_agent_router, prefix="/api")
+
+    from uipath.dev.server.routes.mcp import router as mcp_router
+
+    app.include_router(mcp_router, prefix="/api")
+
     from uipath.dev.server.routes.statedb import router as statedb_router
 
     app.include_router(statedb_router, prefix="/api")