uipath-dev 0.0.1__py3-none-any.whl

uipath/dev/components/history.py

@@ -0,0 +1,110 @@
+"""Panel for displaying execution run history."""
+
+from typing import List, Optional
+
+from textual.app import ComposeResult
+from textual.containers import Container, Vertical
+from textual.widgets import (
+    Button,
+    ListItem,
+    ListView,
+    Static,
+    TabbedContent,
+    TabPane,
+)
+
+from uipath.dev.models.execution import ExecutionRun
+
+
+class RunHistoryPanel(Container):
+    """Left panel showing execution run history."""
+
+    def __init__(self, **kwargs):
+        """Initialize RunHistoryPanel."""
+        super().__init__(**kwargs)
+        self.runs: List[ExecutionRun] = []
+        self.selected_run: Optional[ExecutionRun] = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the UI layout."""
+        with TabbedContent():
+            with TabPane("History", id="history-tab"):
+                with Vertical():
+                    yield ListView(id="run-list", classes="run-list")
+                    yield Button(
+                        "+ New",
+                        id="new-run-btn",
+                        variant="primary",
+                        classes="new-run-btn",
+                    )
+
+    def on_mount(self) -> None:
+        """Set up periodic refresh on mount."""
+        # Update only running items every 5 seconds
+        self.set_interval(5.0, self._refresh_running_items)
+
+    def add_run(self, run: ExecutionRun):
+        """Add a new run to history."""
+        self.runs.insert(0, run)  # Add to top
+        self.refresh_list()
+
+    def update_run(self, run: ExecutionRun):
+        """Update an existing run."""
+        self.refresh_list()
+
+    def refresh_list(self):
+        """Refresh the run list display."""
+        run_list = self.query_one("#run-list", ListView)
+        run_list.clear()
+
+        for run in self.runs:
+            item = ListItem(
+                Static(run.display_name), classes=f"run-item run-{run.status}"
+            )
+            # Store run id directly on the ListItem
+            item.run_id = run.id  # type: ignore[attr-defined]
+            run_list.append(item)
+
+    def get_run_by_id(self, run_id: str) -> Optional[ExecutionRun]:
+        """Get run by id."""
+        for run in self.runs:
+            if run.id == run_id:
+                return run
+        return None
+
+    def clear_runs(self):
+        """Clear all runs from history."""
+        self.runs.clear()
+        self.refresh_list()
+
+    def _refresh_running_items(self) -> None:
+        """Refresh display names for running items only."""
+        if not any(run.status == "running" for run in self.runs):
+            return None
+
+        try:
+            run_list = self.query_one("#run-list", ListView)
+        except Exception:
+            return None
+
+        # Take a snapshot of items to avoid mid-iteration changes
+        items_snapshot = list(run_list.children)
+
+        for item in items_snapshot:
+            if not hasattr(item, "run_id"):
+                continue
+
+            run = self.get_run_by_id(item.run_id)
+            if not run or run.status != "running":
+                continue
+
+            # Check if item still exists in the list (wasn't removed)
+            if item not in run_list.children:
+                continue
+
+            try:
+                static = item.query_one(Static)
+                static.update(run.display_name)
+            except Exception:
+                # Item structure changed or was removed
+                continue

uipath/dev/components/json_input.py

@@ -0,0 +1,27 @@
+"""TextArea component that validates JSON input."""
+
+import json
+
+from textual.widgets import TextArea
+
+
+class JsonInput(TextArea):
+    """TextArea that validates JSON on change."""
+
+    def validate_json(self) -> bool:
+        """Validate the current text as JSON."""
+        text = self.text.strip()
+        if not text:
+            self.remove_class("invalid")
+            return True
+        try:
+            json.loads(text)
+            self.remove_class("invalid")
+            return True
+        except json.JSONDecodeError:
+            self.add_class("invalid")
+            return False
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        """Validate JSON when the text changes."""
+        self.validate_json()

uipath/dev/components/new.py

@@ -0,0 +1,142 @@
+"""Panel for creating new runs with entrypoint selection and JSON input."""
+
+import json
+import os
+from typing import Any, Tuple, cast
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widgets import Button, Select, TabbedContent, TabPane, TextArea
+
+from uipath.dev.components.json_input import JsonInput
+
+
+def mock_json_from_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """Generate a mock JSON object based on a given JSON schema."""
+    props: dict[str, Any] = schema.get("properties", {})
+    required = schema.get("required", [])
+    mock = {}
+    for key, info in props.items():
+        if "default" in info:
+            mock[key] = info["default"]
+            continue
+        t = info.get("type")
+        if t == "string":
+            mock[key] = f"example_{key}" if key in required else ""
+        elif t == "integer":
+            mock[key] = 0 if key in required else None
+        elif t == "boolean":
+            mock[key] = True if key in required else False
+        elif t == "array":
+            item_schema = info.get("items", {"type": "string"})
+            mock[key] = [mock_json_from_schema(item_schema)]
+        elif t == "object":
+            mock[key] = mock_json_from_schema(info)
+        else:
+            mock[key] = None
+    return mock
+
+
+class NewRunPanel(Container):
+    """Panel for creating new runs with a Select entrypoint selector."""
+
+    selected_entrypoint = reactive("")
+
+    def __init__(self, **kwargs):
+        """Initialize NewRunPanel with entrypoints from uipath.json."""
+        super().__init__(**kwargs)
+        json_path = os.path.join(os.getcwd(), "uipath.json")
+        data: dict[str, Any] = {}
+        if os.path.exists(json_path):
+            with open(json_path, "r") as f:
+                data = json.load(f)
+
+        self.entrypoints = data.get("entryPoints", [{"filePath": "default"}])
+        self.entrypoint_paths = [ep["filePath"] for ep in self.entrypoints]
+        self.conversational = False
+        self.selected_entrypoint = (
+            self.entrypoint_paths[0] if self.entrypoint_paths else ""
+        )
+        ep: dict[str, Any] = next(
+            (
+                ep
+                for ep in self.entrypoints
+                if ep["filePath"] == self.selected_entrypoint
+            ),
+            {},
+        )
+        self.initial_input = json.dumps(
+            mock_json_from_schema(ep.get("input", {})), indent=2
+        )
+
+    def compose(self) -> ComposeResult:
+        """Compose the UI layout."""
+        with TabbedContent():
+            with TabPane("New run", id="new-tab"):
+                with Vertical():
+                    options = [(path, path) for path in self.entrypoint_paths]
+                    yield Select(
+                        options,
+                        id="entrypoint-select",
+                        value=self.selected_entrypoint,
+                        allow_blank=False,
+                    )
+
+                    yield JsonInput(
+                        text=self.initial_input,
+                        language="json",
+                        id="json-input",
+                        classes="input-field json-input",
+                    )
+
+                    with Horizontal(classes="run-actions"):
+                        yield Button(
+                            "▶ Run",
+                            id="execute-btn",
+                            variant="primary",
+                            classes="action-btn",
+                        )
+
+    async def on_select_changed(self, event: Select.Changed) -> None:
+        """Update JSON input when user selects an entrypoint."""
+        self.selected_entrypoint = cast(str, event.value)
+
+        ep: dict[str, Any] = next(
+            (
+                ep
+                for ep in self.entrypoints
+                if ep["filePath"] == self.selected_entrypoint
+            ),
+            {},
+        )
+        json_input = self.query_one("#json-input", TextArea)
+        json_input.text = json.dumps(
+            mock_json_from_schema(ep.get("input", {})), indent=2
+        )
+
+    def get_input_values(self) -> Tuple[str, str, bool]:
+        """Get the selected entrypoint and JSON input values."""
+        json_input = self.query_one("#json-input", TextArea)
+        return self.selected_entrypoint, json_input.text.strip(), self.conversational
+
+    def reset_form(self):
+        """Reset selection and JSON input to defaults."""
+        self.selected_entrypoint = (
+            self.entrypoint_paths[0] if self.entrypoint_paths else ""
+        )
+        select = self.query_one("#entrypoint-select", Select)
+        select.value = self.selected_entrypoint
+
+        ep: dict[str, Any] = next(
+            (
+                ep
+                for ep in self.entrypoints
+                if ep["filePath"] == self.selected_entrypoint
+            ),
+            {},
+        )
+        json_input = self.query_one("#json-input", TextArea)
+        json_input.text = json.dumps(
+            mock_json_from_schema(ep.get("input", {})), indent=2
+        )

uipath/dev/models/execution.py

@@ -0,0 +1,80 @@
+"""Models for representing execution runs and their data."""
+
+import os
+from datetime import datetime
+from typing import Any, Optional, Union
+from uuid import uuid4
+
+from rich.text import Text
+from uipath.runtime.errors import UiPathErrorContract
+
+from uipath.dev.models.messages import LogMessage, TraceMessage
+
+
+class ExecutionRun:
+    """Represents a single execution run."""
+
+    def __init__(
+        self,
+        entrypoint: str,
+        input_data: Union[dict[str, Any]],
+        conversational: bool = False,
+    ):
+        """Initialize an ExecutionRun instance."""
+        self.id = str(uuid4())[:8]
+        self.entrypoint = entrypoint
+        self.input_data = input_data
+        self.conversational = conversational
+        self.resume_data: Optional[dict[str, Any]] = None
+        self.output_data: Optional[dict[str, Any]] = None
+        self.start_time = datetime.now()
+        self.end_time: Optional[datetime] = None
+        self.status = "pending"  # pending, running, completed, failed, suspended
+        self.traces: list[TraceMessage] = []
+        self.logs: list[LogMessage] = []
+        self.error: Optional[UiPathErrorContract] = None
+
+    @property
+    def duration(self) -> str:
+        """Get the duration of the run as a formatted string."""
+        if self.end_time:
+            delta = self.end_time - self.start_time
+            return f"{delta.total_seconds():.1f}s"
+        elif self.start_time:
+            delta = datetime.now() - self.start_time
+            return f"{delta.total_seconds():.1f}s"
+        return "0.0s"
+
+    @property
+    def display_name(self) -> Text:
+        """Get a rich Text representation of the run for display."""
+        status_colors = {
+            "pending": "grey50",
+            "running": "yellow",
+            "suspended": "cyan",
+            "completed": "green",
+            "failed": "red",
+        }
+
+        status_icon = {
+            "pending": "●",
+            "running": "▶",
+            "suspended": "⏸",
+            "completed": "✔",
+            "failed": "✖",
+        }.get(self.status, "?")
+
+        script_name = (
+            os.path.basename(self.entrypoint) if self.entrypoint else "untitled"
+        )
+        truncated_script = script_name[:8]
+        time_str = self.start_time.strftime("%H:%M:%S")
+        duration_str = self.duration[:6]
+
+        text = Text()
+        text.append(f"{status_icon:<2} ", style=status_colors.get(self.status, "white"))
+        text.append(f"{truncated_script:<8} ")
+        text.append(f"({time_str:<8}) ")
+        text.append(f"[{duration_str:<6}]")
+
+        return text

uipath/dev/models/messages.py

@@ -0,0 +1,53 @@
+"""Messages used for inter-component communication in the UiPath Developer Console."""
+
+from datetime import datetime
+from typing import Any, Optional, Union
+
+from rich.console import RenderableType
+from textual.message import Message
+
+
+class LogMessage(Message):
+    """Message sent when a new log entry is created."""
+
+    def __init__(
+        self,
+        run_id: str,
+        level: str,
+        message: Union[str, RenderableType],
+        timestamp: Optional[datetime] = None,
+    ):
+        """Initialize a LogMessage instance."""
+        self.run_id = run_id
+        self.level = level
+        self.message = message
+        self.timestamp = timestamp or datetime.now()
+        super().__init__()
+
+
+class TraceMessage(Message):
+    """Message sent when a new trace entry is created."""
+
+    def __init__(
+        self,
+        run_id: str,
+        span_name: str,
+        span_id: str,
+        parent_span_id: Optional[str] = None,
+        trace_id: Optional[str] = None,
+        status: str = "running",
+        duration_ms: Optional[float] = None,
+        timestamp: Optional[datetime] = None,
+        attributes: Optional[dict[str, Any]] = None,
+    ):
+        """Initialize a TraceMessage instance."""
+        self.run_id = run_id
+        self.span_name = span_name
+        self.span_id = span_id
+        self.parent_span_id = parent_span_id
+        self.trace_id = trace_id
+        self.status = status
+        self.duration_ms = duration_ms
+        self.timestamp = timestamp or datetime.now()
+        self.attributes = attributes or {}
+        super().__init__()

uipath_dev-0.0.1.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: uipath-dev
+Version: 0.0.1
+Summary: UiPath Dev Terminal
+Project-URL: Homepage, https://uipath.com
+Project-URL: Repository, https://github.com/UiPath/uipath-dev-python
+Project-URL: Documentation, https://uipath.github.io/uipath-python/
+Maintainer-email: Cristian Pufu <cristian.pufu@uipath.com>
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: textual>=6.5.0
+Requires-Dist: uipath-runtime>=0.0.4
+Description-Content-Type: text/markdown
+
+# UiPath Developer Console
+
+The **UiPath Developer Console** is an interactive terminal application for building, testing, and debugging UiPath Python runtimes, agents, and automation scripts.
+
+## Overview
+
+The Developer Console provides a local environment for developers who are building or experimenting with Python-based UiPath runtimes.
+It integrates with the [`uipath-runtime`](https://pypi.org/project/uipath-runtime/) SDK to execute agents and visualize their behavior in real time using the [`textual`](https://github.com/Textualize/textual) framework.
+
+This tool is designed for:
+- Developers building **UiPath agents** or **custom runtime integrations**
+- Python engineers testing **standalone automation scripts** before deployment
+- Contributors exploring **runtime orchestration** and **execution traces**
+
+## Features
+
+- Run and inspect Python runtimes interactively
+- View structured logs, output, and OpenTelemetry traces
+- Export and review execution history
+
+## Installation
+
+```bash
+uv add uipath-dev
+```
+
+## Development
+
+Launch the Developer Console with mocked data:
+
+```bash
+uv run uipath-dev
+```
+
+To run tests:
+
+```bash
+pytest
+```

uipath_dev-0.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+uipath/dev/__init__.py,sha256=TfVX-yiAQ7t6l8_vzRsxzBFzooqE-Hf6KTzCErD-L6c,12492
+uipath/dev/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uipath/dev/_demo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uipath/dev/_demo/mock_runtime.py,sha256=xhnA88yjddqnNMiV_bACO_gAUdsdv-U_Iplb8c73h1M,1950
+uipath/dev/_demo/run_dev_console.py,sha256=J7uEjKYkR9-hDs55rVUEyMLIdrwVDV6R96cxXgP1yXE,390
+uipath/dev/_styles/terminal.tcss,sha256=ktVpKwXIXw2VZp8KIZD6fO9i9NTGvts_icCTxMdzEiY,3240
+uipath/dev/_utils/_exporter.py,sha256=4jElOckC6dQh9qF-ArMnOBPXMMr9foG7uxmi8eyOLEU,4151
+uipath/dev/_utils/_logger.py,sha256=7OByjJAWPEdOHfd6n6OSpsSX2OxK_I47HrGspAR2f-s,2950
+uipath/dev/components/details.py,sha256=MExZBuiyjfEB530KSf8L6KeRUD15m9fbQptl00K5pm0,16483
+uipath/dev/components/history.py,sha256=rCO5Gmnp9LZbVVWt8h8Mf0dyJktpTzTLa4U-xnF5iUI,3422
+uipath/dev/components/json_input.py,sha256=vyvIi1m0yRLUBpXmwwM4InZ1taFJfmTy2Jx0vB_6Gvo,745
+uipath/dev/components/new.py,sha256=QXc9SeEAeJ9M9pjCNLgD-6mY4N4-tWYfqP5oU6TNWlU,5128
+uipath/dev/models/execution.py,sha256=KvODGsSTuWkYZ8zGW0_a_OreL-ByqqEq5tp291-Pz-Q,2606
+uipath/dev/models/messages.py,sha256=3NxTpXrLaOpt7fJd0GJwLL6V_hUQS9_pM97L5zk-Qr8,1580
+uipath_dev-0.0.1.dist-info/METADATA,sha256=hILtVjEM8z-5X3_XgHs5eRipUgxWqXNw4EDKpFfUtTY,1917
+uipath_dev-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_dev-0.0.1.dist-info/entry_points.txt,sha256=xuRnlpKV3M6HE-47nOrLF_Y61OouvNen_8msafnuIb8,69
+uipath_dev-0.0.1.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath_dev-0.0.1.dist-info/RECORD,,

uipath_dev-0.0.1.dist-info/WHEEL

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

uipath_dev-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uipath-dev = uipath.dev._demo.run_dev_console:main

uipath_dev-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright 2025 UiPath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.