uipath-dev 0.0.1__py3-none-any.whl

uipath/dev/__init__.py

@@ -0,0 +1,329 @@
+"""UiPath Dev Terminal Application."""
+
+import asyncio
+import json
+import traceback
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+
+import pyperclip  # type: ignore[import-untyped]
+from pydantic import BaseModel
+from rich.traceback import Traceback
+from textual import on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Horizontal
+from textual.widgets import Button, Footer, Input, ListView, RichLog
+from uipath.core.tracing import UiPathTraceManager
+from uipath.runtime import (
+    UiPathExecuteOptions,
+    UiPathExecutionRuntime,
+    UiPathRuntimeFactory,
+    UiPathRuntimeStatus,
+)
+from uipath.runtime.errors import UiPathErrorContract, UiPathRuntimeError
+
+from uipath.dev.components.details import RunDetailsPanel
+from uipath.dev.components.history import RunHistoryPanel
+from uipath.dev.components.new import NewRunPanel
+from uipath.dev.models.execution import ExecutionRun
+from uipath.dev.models.messages import LogMessage, TraceMessage
+
+from ._utils._exporter import RunContextExporter
+from ._utils._logger import patch_textual_stderr
+
+
+class UiPathDeveloperConsole(App[Any]):
+    """UiPath debugging terminal interface."""
+
+    TITLE = "UiPath Debugging Terminal"
+    SUB_TITLE = "Interactive debugging interface for UiPath Python projects"
+    CSS_PATH = Path(__file__).parent / "_styles" / "terminal.tcss"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("n", "new_run", "New"),
+        Binding("r", "execute_run", "Run"),
+        Binding("c", "copy", "Copy"),
+        Binding("h", "clear_history", "Clear History"),
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(
+        self,
+        runtime_factory: UiPathRuntimeFactory[Any],
+        trace_manager: UiPathTraceManager,
+        **kwargs,
+    ):
+        """Initialize the UiPath Dev Terminal App."""
+        self._stderr_write_fd: int = patch_textual_stderr(self._add_subprocess_log)
+
+        super().__init__(**kwargs)
+
+        self.initial_entrypoint: str = "main.py"
+        self.initial_input: str = '{\n  "message": "Hello World"\n}'
+        self.runs: dict[str, ExecutionRun] = {}
+        self.runtime_factory = runtime_factory
+        self.trace_manager = trace_manager
+        self.trace_manager.add_span_exporter(
+            RunContextExporter(
+                on_trace=self._handle_trace_message,
+                on_log=self._handle_log_message,
+            ),
+            batch=False,
+        )
+
+    def compose(self) -> ComposeResult:
+        """Compose the UI layout."""
+        with Horizontal():
+            # Left sidebar - run history
+            with Container(classes="run-history"):
+                yield RunHistoryPanel(id="history-panel")
+
+            # Main content area
+            with Container(classes="main-content"):
+                # New run panel (initially visible)
+                yield NewRunPanel(
+                    id="new-run-panel",
+                    classes="new-run-panel",
+                )
+
+                # Run details panel (initially hidden)
+                yield RunDetailsPanel(id="details-panel", classes="hidden")
+
+        yield Footer()
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events."""
+        if event.button.id == "new-run-btn":
+            await self.action_new_run()
+        elif event.button.id == "execute-btn":
+            await self.action_execute_run()
+        elif event.button.id == "cancel-btn":
+            await self.action_cancel()
+
+    async def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Handle run selection from history."""
+        if event.list_view.id == "run-list" and event.item:
+            run_id = getattr(event.item, "run_id", None)
+            if run_id:
+                history_panel = self.query_one("#history-panel", RunHistoryPanel)
+                run = history_panel.get_run_by_id(run_id)
+                if run:
+                    self._show_run_details(run)
+
+    @on(Input.Submitted, "#chat-input")
+    async def handle_chat_input(self, event: Input.Submitted) -> None:
+        """Handle user submitting text into the chat."""
+        user_text = event.value.strip()
+        if not user_text:
+            return
+
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        if details_panel and details_panel.current_run:
+            status = details_panel.current_run.status
+            if status == "running":
+                self.app.notify(
+                    "Wait for agent response...", timeout=1.5, severity="warning"
+                )
+                return
+            if details_panel.current_run.status == "suspended":
+                details_panel.current_run.resume_data = {"message": user_text}
+            asyncio.create_task(self._execute_runtime(details_panel.current_run))
+            event.input.clear()
+
+    async def action_new_run(self) -> None:
+        """Show new run panel."""
+        new_panel = self.query_one("#new-run-panel")
+        details_panel = self.query_one("#details-panel")
+
+        new_panel.remove_class("hidden")
+        details_panel.add_class("hidden")
+
+    async def action_cancel(self) -> None:
+        """Cancel and return to new run view."""
+        await self.action_new_run()
+
+    async def action_execute_run(self) -> None:
+        """Execute a new run with UiPath runtime."""
+        new_run_panel = self.query_one("#new-run-panel", NewRunPanel)
+        entrypoint, input_data, conversational = new_run_panel.get_input_values()
+
+        if not entrypoint:
+            return
+
+        input: dict[str, Any] = {}
+        try:
+            input = json.loads(input_data)
+        except json.JSONDecodeError:
+            return
+
+        run = ExecutionRun(entrypoint, input, conversational)
+
+        self.runs[run.id] = run
+
+        self._add_run_in_history(run)
+
+        self._show_run_details(run)
+
+        if not run.conversational:
+            asyncio.create_task(self._execute_runtime(run))
+        else:
+            self._focus_chat_input()
+
+    async def action_clear_history(self) -> None:
+        """Clear run history."""
+        history_panel = self.query_one("#history-panel", RunHistoryPanel)
+        history_panel.clear_runs()
+        await self.action_new_run()
+
+    def action_copy(self) -> None:
+        """Copy content of currently focused RichLog to clipboard and notify."""
+        focused = self.app.focused
+        if isinstance(focused, RichLog):
+            clipboard_text = "\n".join(line.text for line in focused.lines)
+            pyperclip.copy(clipboard_text)
+            self.app.notify("Copied to clipboard!", timeout=1.5)
+        else:
+            self.app.notify("Nothing to copy here.", timeout=1.5, severity="warning")
+
+    async def _execute_runtime(self, run: ExecutionRun):
+        """Execute the script using UiPath runtime."""
+        try:
+            execution_input: Optional[dict[str, Any]] = {}
+            execution_options: UiPathExecuteOptions = UiPathExecuteOptions()
+            if run.status == "suspended":
+                execution_input = run.resume_data
+                execution_options.resume = True
+                self._add_info_log(run, f"Resuming execution: {run.entrypoint}")
+            else:
+                execution_input = run.input_data
+                self._add_info_log(run, f"Starting execution: {run.entrypoint}")
+
+            run.status = "running"
+            run.start_time = datetime.now()
+
+            runtime = self.runtime_factory.new_runtime(entrypoint=run.entrypoint)
+            execution_runtime = UiPathExecutionRuntime(
+                delegate=runtime, trace_manager=self.trace_manager, execution_id=run.id
+            )
+            result = await execution_runtime.execute(execution_input, execution_options)
+
+            if result is not None:
+                if (
+                    result.status == UiPathRuntimeStatus.SUSPENDED.value
+                    and result.resume
+                ):
+                    run.status = "suspended"
+                else:
+                    if result.output is None:
+                        run.output_data = {}
+                    elif isinstance(result.output, BaseModel):
+                        run.output_data = result.output.model_dump()
+                    else:
+                        run.output_data = result.output
+                    run.status = "completed"
+                if run.output_data:
+                    self._add_info_log(run, f"Execution result: {run.output_data}")
+
+            self._add_info_log(run, "✅ Execution completed successfully")
+            run.end_time = datetime.now()
+
+        except UiPathRuntimeError as e:
+            self._add_error_log(run)
+            run.status = "failed"
+            run.end_time = datetime.now()
+            run.error = e.error_info
+
+        except Exception as e:
+            self._add_error_log(run)
+            run.status = "failed"
+            run.end_time = datetime.now()
+            run.error = UiPathErrorContract(
+                code="Unknown", title=str(e), detail=traceback.format_exc()
+            )
+
+        self._update_run_in_history(run)
+        self._update_run_details(run)
+
+    def _show_run_details(self, run: ExecutionRun):
+        """Show details panel for a specific run."""
+        # Hide new run panel, show details panel
+        new_panel = self.query_one("#new-run-panel")
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+
+        new_panel.add_class("hidden")
+        details_panel.remove_class("hidden")
+
+        # Populate the details panel with run data
+        details_panel.update_run(run)
+
+    def _focus_chat_input(self):
+        """Focus the chat input box."""
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        details_panel.switch_tab("chat-tab")
+        chat_input = details_panel.query_one("#chat-input", Input)
+        chat_input.focus()
+
+    def _add_run_in_history(self, run: ExecutionRun):
+        """Add run to history panel."""
+        history_panel = self.query_one("#history-panel", RunHistoryPanel)
+        history_panel.add_run(run)
+
+    def _update_run_in_history(self, run: ExecutionRun):
+        """Update run display in history panel."""
+        history_panel = self.query_one("#history-panel", RunHistoryPanel)
+        history_panel.update_run(run)
+
+    def _update_run_details(self, run: ExecutionRun):
+        """Update the displayed run information."""
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        details_panel.update_run_details(run)
+
+    def _handle_trace_message(self, trace_msg: TraceMessage):
+        """Handle trace message from exporter."""
+        run = self.runs[trace_msg.run_id]
+        for i, existing_trace in enumerate(run.traces):
+            if existing_trace.span_id == trace_msg.span_id:
+                run.traces[i] = trace_msg
+                break
+        else:
+            run.traces.append(trace_msg)
+
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        details_panel.add_trace(trace_msg)
+
+    def _handle_log_message(self, log_msg: LogMessage):
+        """Handle log message from exporter."""
+        self.runs[log_msg.run_id].logs.append(log_msg)
+        details_panel = self.query_one("#details-panel", RunDetailsPanel)
+        details_panel.add_log(log_msg)
+
+    def _add_info_log(self, run: ExecutionRun, message: str):
+        """Add info log to run."""
+        timestamp = datetime.now()
+        log_msg = LogMessage(run.id, "INFO", message, timestamp)
+        self._handle_log_message(log_msg)
+
+    def _add_error_log(self, run: ExecutionRun):
+        """Add error log to run."""
+        timestamp = datetime.now()
+        tb = Traceback(
+            show_locals=False,
+            max_frames=4,
+        )
+        log_msg = LogMessage(run.id, "ERROR", tb, timestamp)
+        self._handle_log_message(log_msg)
+
+    def _add_subprocess_log(self, level: str, message: str) -> None:
+        """Handle a stderr line coming from subprocesses."""
+
+        def add_log() -> None:
+            details_panel = self.query_one("#details-panel", RunDetailsPanel)
+            run = getattr(details_panel, "current_run", None)
+            if run:
+                log_msg = LogMessage(run.id, level, message, datetime.now())
+                self._handle_log_message(log_msg)
+
+        self.call_from_thread(add_log)

uipath/dev/_demo/mock_runtime.py

@@ -0,0 +1,64 @@
+"""Minimal demo script to run UiPathDevTerminal with mock runtimes."""
+
+import asyncio
+from typing import Any, Optional
+
+from uipath.runtime import (
+    UiPathBaseRuntime,
+    UiPathExecuteOptions,
+    UiPathRuntimeFactory,
+    UiPathRuntimeResult,
+    UiPathRuntimeStatus,
+)
+from uipath.runtime.schema import UiPathRuntimeSchema
+
+
+class MockRuntime(UiPathBaseRuntime):
+    """A simple mock runtime that echoes its input."""
+
+    async def get_schema(self) -> UiPathRuntimeSchema:
+        return UiPathRuntimeSchema(
+            filePath="default",
+            uniqueId="mock-runtime",
+            type="agent",
+            input={
+                "type": "object",
+                "properties": {"message": {"type": "string"}},
+                "required": ["message"],
+            },
+            output={
+                "type": "object",
+                "properties": {"result": {"type": "string"}},
+                "required": ["result"],
+            },
+        )
+
+    async def execute(
+        self,
+        input: Optional[dict[str, Any]] = None,
+        options: Optional[UiPathExecuteOptions] = None,
+    ) -> UiPathRuntimeResult:
+        payload = input or {}
+        # Simulate some async work
+        await asyncio.sleep(0.2)
+        return UiPathRuntimeResult(
+            output={"result": f"Mock runtime got: {payload!r}"},
+            status=UiPathRuntimeStatus.SUCCESSFUL,
+        )
+
+    async def cleanup(self) -> None:
+        # Nothing to clean up in this mock
+        pass
+
+
+# 2) Mock runtime factory
+class MockRuntimeFactory(UiPathRuntimeFactory[MockRuntime]):
+    """Runtime factory compatible with UiPathDevTerminal expectations."""
+
+    # This is the method the Textual app calls here:
+    #   runtime = self.runtime_factory.new_runtime(entrypoint=run.entrypoint)
+    def new_runtime(self, entrypoint: str) -> MockRuntime:
+        return MockRuntime()
+
+    def discover_runtimes(self) -> list[MockRuntime]:
+        return []

uipath/dev/_demo/run_dev_console.py

@@ -0,0 +1,15 @@
+from uipath.core.tracing import UiPathTraceManager
+
+from uipath.dev import UiPathDeveloperConsole
+from uipath.dev._demo.mock_runtime import MockRuntimeFactory
+
+
+def main():
+    trace_manager = UiPathTraceManager()
+    factory = MockRuntimeFactory()
+    app = UiPathDeveloperConsole(runtime_factory=factory, trace_manager=trace_manager)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

uipath/dev/_styles/terminal.tcss

@@ -0,0 +1,261 @@
+Screen {
+    layout: horizontal;
+}
+
+.run-history {
+    width: 30%;
+    min-width: 25;
+    padding-right: 1;
+}
+
+.run-list {
+    height: 1fr;
+    margin-bottom: 1;
+}
+
+.run-item {
+    padding: 0 1;
+}
+
+.run-running {
+    border-left: solid #ffaa00;
+    color: #ffaa00;
+}
+
+.run-suspended {
+    border-left: solid #00FFFF;
+    color: #e0e0e0;
+}
+
+.run-pending {
+    border-left: solid grey;
+    color: #e0e0e0;
+}
+
+.run-completed {
+    border-left: solid #00ff88;
+    color: #e0e0e0;
+}
+
+.run-failed {
+    border-left: solid #ff4444;
+    color: #ff4444;
+}
+
+.new-run-btn {
+    width: 100%;
+    margin-bottom: 1;
+    border: none;
+    text-style: bold;
+}
+.main-content {
+    width: 70%;
+    padding-left: 1;
+}
+
+.new-run-title {
+    text-style: bold;
+    padding: 0 1;
+    height: 1;
+    margin-bottom: 0;
+}
+
+.new-run-panel {
+    height: 100%;
+}
+
+.field-label {
+    text-style: bold;
+}
+
+.run-actions {
+    dock: bottom;
+    height: auto;
+    align: left middle;
+}
+
+.action-btn {
+    margin-right: 2;
+    min-width: 8;
+    border: none;
+    text-style: bold;
+}
+
+.details-content {
+    height: 1fr;
+}
+
+.traces-section,
+.logs-section {
+    width: 50%;
+    height: 100%;
+}
+
+.traces-section {
+    width: 50%;
+}
+
+.logs-section {
+    width: 50%;
+}
+
+.detail-log {
+    height: 1fr;
+    padding: 1;
+    padding-top: 0;
+}
+
+.status-running {
+    background: #ffaa00;
+    color: #000000;
+    border: solid #ffaa00;
+}
+
+.status-success {
+    background: #00ff88;
+    color: #000000;
+    border: solid #00ff88;
+}
+
+.status-error {
+    background: #ff4444;
+    color: #ffffff;
+    border: solid #ff4444;
+}
+
+.hidden {
+    display: none;
+}
+
+Footer {
+    margin-top:1;
+    height: auto;
+    dock: bottom;
+}
+
+TabbedContent {
+    height: 100%;
+}
+
+TabPane {
+    height: 100%;
+    padding: 0;
+}
+
+.traces-content {
+    height: 100%;
+}
+
+.spans-tree-section {
+    width: 40%;
+    height: 100%;
+    padding-right: 1;
+}
+
+.span-details-section {
+    width: 60%;
+    height: 100%;
+    padding-left: 1;
+}
+
+.spans-tree {
+    height: 100%;
+    padding: 1;
+    padding-top: 0;
+}
+
+Label {
+    margin: 1 1;
+    width: 100%;
+    height: 100%;
+    border: tall $primary;
+    content-align: center middle;
+}
+
+ContentSwitcher {
+    height: 1fr;
+}
+
+SpanDetailsDisplay {
+    height: 100%;
+}
+
+#span-details-display {
+    height: 100%;
+}
+
+#span-details {
+    height: 100%;
+}
+
+.new-run-panel {
+    height: 100%;
+}
+
+.new-run-title {
+    text-style: bold;
+    padding: 0 1;
+    height: 2;
+    content-align: left middle;
+}
+
+.field-label {
+    text-style: bold;
+    margin: 1 0;
+}
+
+.script-input {
+    height: 3;
+}
+
+.json-input {
+    margin-top: 1;
+    height: auto;
+}
+
+.run-actions {
+    height: auto;
+    padding: 1;
+}
+
+.action-btn {
+    min-width: 10;
+    padding: 0 2;
+    text-style: bold;
+    border: none;
+}
+
+TextArea.invalid {
+    border: tall red;
+}
+
+
+Prompt {
+    border: wide $primary-background;
+    background: $surface;
+    color: $text;
+    margin-right: 8;
+    margin-left: 1;
+    padding: 1 1 0 1;
+}
+Response, Tool {
+    border: wide $primary-background;
+    background: $surface;
+    color: $text;
+    margin: 1;
+    margin-left: 8;
+    padding: 1 1 0 1;
+}
+
+#chat-container{
+    background: $surface;
+}
+
+#chat-input{
+    dock: bottom;
+    margin: 1;
+}
+
+Checkbox{
+    margin-top: 1;
+}