intuned-runtime 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

intuned_cli/controller/deploy.py

@@ -11,8 +11,6 @@ from intuned_cli.utils.backend import get_base_url
 from intuned_cli.utils.console import console
 from intuned_cli.utils.error import CLIError
 
-supported_playwright_versions = ["1.46.0", "1.52.0"]
-
 project_deploy_timeout = 10 * 60
 project_deploy_check_period = 5
 
@@ -30,7 +28,7 @@ async def check_deploy_status(
     api_key: str,
 ):
     base_url = get_base_url()
-    url = f"{base_url}/api/v1/workspace/{workspace_id}/projects/create/{project_name}/result"
+    url = f"{base_url}/api/v1/workspace/{workspace_id}/projects/{project_name}/deploy/result"
 
     headers = {
         "x-api-key": api_key,
@@ -124,7 +122,7 @@ async def deploy_project(
                     if update_console_task:
                         update_console_task.cancel()
                     if console.is_terminal:
-                        print("\r", " " * 100)
+                        print("\r", " " * 100, file=console.file)
                     console.print("[green][bold]Project deployed successfully![/bold][/green]")
                     console.print(
                         f"[bold]You can check your project on the platform:[/bold] [cyan underline]{get_base_url()}/projects/{project_name}/details[/cyan underline]"
@@ -143,7 +141,7 @@ async def deploy_project(
                 )
             except Exception:
                 if console.is_terminal:
-                    print("\r", " " * 100)
+                    print("\r", " " * 100, file=console.file)
                 raise
     finally:
         if update_console_task:

intuned_cli/controller/save.py

@@ -6,7 +6,6 @@ from typing import Any
 
 import httpx
 import pathspec
-import toml
 from anyio import Path
 from dotenv.main import DotEnv
 from pydantic import BaseModel
@@ -16,6 +15,7 @@ from intuned_cli.types import DirectoryNode
 from intuned_cli.types import FileNode
 from intuned_cli.types import FileNodeContent
 from intuned_cli.types import FileSystemTree
+from intuned_cli.utils.api_helpers import get_intuned_settings_file
 from intuned_cli.utils.api_helpers import load_intuned_json
 from intuned_cli.utils.backend import get_base_url
 from intuned_cli.utils.console import console
@@ -26,8 +26,6 @@ from runtime.env import api_key_env_var_key
 from runtime.env import project_env_var_key
 from runtime.env import workspace_env_var_key
 
-supported_playwright_versions = ["1.46.0", "1.52.0"]
-
 
 class IntunedPyprojectToml(BaseModel):
     class _Tool(BaseModel):
@@ -47,21 +45,6 @@ async def validate_intuned_project():
     if not await pyproject_toml_path.exists():
         raise CLIError("pyproject.toml file is missing in the current directory.")
 
-    content = await pyproject_toml_path.read_text()
-    json_content = toml.loads(content)
-    try:
-        pyproject_toml = IntunedPyprojectToml.model_validate(json_content)
-    except Exception as e:
-        raise CLIError(f"Failed to parse pyproject.toml: {e}") from e
-
-    playwright_version = pyproject_toml.tool.poetry.dependencies.get("playwright")
-
-    if playwright_version not in supported_playwright_versions:
-        raise CLIError(
-            f"Unsupported Playwright version '{playwright_version}'. "
-            f"Supported versions are: {', '.join(supported_playwright_versions)}."
-        )
-
     intuned_json = await load_intuned_json()
 
     api_folder = cwd / "api"
@@ -123,70 +106,69 @@ async def get_file_tree_from_project(path: Path, *, exclude: list[str] | None =
     return results
 
 
-def mapFileTreeToIdeFileTree(file_tree: FileSystemTree):
+async def map_file_tree_to_ide_file_tree(file_tree: FileSystemTree):
     """
     Maps the file tree to IDE parameters format by processing parameters directory
     and converting it to ____testParameters structure.
     """
 
-    if not file_tree:
-        return
-
     parameters_node = file_tree.root.get("parameters")
-    if parameters_node is None:
-        return
+    if isinstance(parameters_node, DirectoryNode):
+        api_parameters_map: dict[str, list[dict[str, Any]]] = {}
+        cli_parameters = list(parameters_node.directory.root.keys())
+        test_parameters = DirectoryNode(directory=FileSystemTree(root={}))
 
-    if not isinstance(parameters_node, DirectoryNode):
-        return
-
-    api_parameters_map: dict[str, list[dict[str, Any]]] = {}
-    cli_parameters = list(parameters_node.directory.root.keys())
-    test_parameters = DirectoryNode(directory=FileSystemTree(root={}))
+        for parameter_key in cli_parameters:
+            # If parameter of type directory, discard it and continue
+            parameter = parameters_node.directory.root[parameter_key]
 
-    for parameter_key in cli_parameters:
-        # If parameter of type directory, discard it and continue
-        parameter = parameters_node.directory.root[parameter_key]
+            if isinstance(parameter, DirectoryNode):
+                continue
 
-        if isinstance(parameter, DirectoryNode):
-            continue
+            if not parameter.file.contents.strip():
+                continue
 
-        if not parameter.file.contents.strip():
-            continue
+            try:
+                parameter_payload = json.loads(parameter.file.contents)
+            except json.JSONDecodeError:
+                continue
 
-        try:
-            parameter_payload = json.loads(parameter.file.contents)
-        except json.JSONDecodeError:
-            continue
+            if "__api-name" not in parameter_payload:
+                continue
 
-        if "__api-name" not in parameter_payload:
-            continue
+            api = parameter_payload["__api-name"]
+            # Create parameter value by excluding __api-name
+            parameter_value = {k: v for k, v in parameter_payload.items() if k != "__api-name"}
 
-        api = parameter_payload["__api-name"]
-        # Create parameter value by excluding __api-name
-        parameter_value = {k: v for k, v in parameter_payload.items() if k != "__api-name"}
+            test_parameter: dict[str, Any] = {
+                "name": parameter_key.replace(".json", ""),
+                "lastUsed": False,
+                "id": str(uuid.uuid4()),
+                "value": json.dumps(parameter_value),
+            }
 
-        test_parameter: dict[str, Any] = {
-            "name": parameter_key.replace(".json", ""),
-            "lastUsed": False,
-            "id": str(uuid.uuid4()),
-            "value": json.dumps(parameter_value),
-        }
+            if api not in api_parameters_map:
+                api_parameters_map[api] = []
+            api_parameters_map[api].append(test_parameter)
 
-        if api not in api_parameters_map:
-            api_parameters_map[api] = []
-        api_parameters_map[api].append(test_parameter)
+        for api, parameters in api_parameters_map.items():
+            # By default, last one used is the last one in the map
+            if len(parameters) > 0:
+                parameters[-1]["lastUsed"] = True
 
-    for api, parameters in api_parameters_map.items():
-        # By default, last one used is the last one in the map
-        if len(parameters) > 0:
-            parameters[-1]["lastUsed"] = True
+            test_parameters.directory.root[f"{api}.json"] = FileNode(
+                file=FileNodeContent(contents=json.dumps(parameters, indent=2))
+            )
 
-        test_parameters.directory.root[f"{api}.json"] = FileNode(
-            file=FileNodeContent(contents=json.dumps(parameters, indent=2))
-        )
+        del file_tree.root["parameters"]
+        file_tree.root["____testParameters"] = test_parameters
 
-    del file_tree.root["parameters"]
-    file_tree.root["____testParameters"] = test_parameters
+    if file_tree.root.get("Intuned.json") is None:
+        settings_file = await get_intuned_settings_file()
+        text_content = await Path(settings_file.file_path).read_text()
+        parsed_content = settings_file.parse(text_content)
+        json_content = json.dumps(parsed_content, indent=2)
+        file_tree.root["Intuned.json"] = FileNode(file=FileNodeContent(contents=json_content))
 
 
 class SaveProjectResponse(BaseModel):
@@ -201,14 +183,13 @@ async def save_project(
 ):
     base_url = get_base_url()
     url = f"{base_url}/api/v1/workspace/{workspace_id}/projects/{project_name}"
-    print(f"calling {url}")
     headers = {
         api_key_header_name: api_key,
         "Content-Type": "application/json",
     }
     cwd = await Path().resolve()
     file_tree = await get_file_tree_from_project(cwd, exclude=exclusions)
-    mapFileTreeToIdeFileTree(file_tree)
+    await map_file_tree_to_ide_file_tree(file_tree)
 
     payload: dict[str, Any] = {
         "codeTree": file_tree.model_dump(mode="json"),

intuned_cli/types.py

@@ -1,3 +1,6 @@
+from typing import NotRequired
+from typing import TypedDict
+
 from pydantic import BaseModel
 from pydantic import RootModel
 
@@ -19,3 +22,14 @@ class FileNode(BaseModel):
 
 
 FileSystemTree.model_rebuild()
+
+
+class BaseExecuteCommandOptionsWithoutTrace(TypedDict):
+    headless: bool
+    timeout: float
+    proxy: NotRequired[str | None]
+    keep_browser_open: bool
+
+
+class BaseExecuteCommandOptions(BaseExecuteCommandOptionsWithoutTrace):
+    trace: bool

intuned_cli/utils/__test__/test_browser.py

@@ -0,0 +1,132 @@
+from dataclasses import dataclass
+from unittest.mock import AsyncMock
+from unittest.mock import MagicMock
+from unittest.mock import Mock
+from unittest.mock import patch
+
+import pytest
+import pytest_asyncio
+
+from intuned_cli.utils.browser import close_cli_browser
+from intuned_cli.utils.browser import get_cli_run_options
+from runtime.types.run_types import CDPRunOptions
+from runtime.types.run_types import StandaloneRunOptions
+
+
+@dataclass
+class BrowserMocks:
+    launch_chromium: AsyncMock
+
+
+@pytest_asyncio.fixture
+async def browser_mocks():
+    """Mock dependencies for execute_record_auth_session_cli tests."""
+
+    _mock_launch_chromium = patch("runtime.browser.launch_chromium.launch_chromium")
+    _mock_get_free_port = patch("runtime.run.playwright_context.get_random_free_port", new_callable=AsyncMock)
+
+    with (
+        _mock_launch_chromium as mock_launch_chromium,
+        _mock_get_free_port as _mock_get_free_port,
+    ):
+        mock_launch_chromium_return_value = Mock()
+
+        async def create_context_and_page():
+            return (MagicMock(), MagicMock())
+
+        mock_launch_chromium_return_value.__aenter__ = AsyncMock(side_effect=create_context_and_page)
+        mock_launch_chromium_return_value.__aexit__ = AsyncMock(return_value=None)
+        mock_launch_chromium.return_value = mock_launch_chromium_return_value
+
+        _mock_get_free_port.return_value = 1234
+
+        yield BrowserMocks(
+            launch_chromium=mock_launch_chromium,
+        )
+
+        await close_cli_browser()
+
+
+class TestBrowser:
+    @pytest.mark.asyncio
+    async def test_returns_standalone_options_if_keep_browser_open_is_false(self, browser_mocks: BrowserMocks):
+        from intuned_cli.utils.browser import get_cli_run_options
+
+        options = await get_cli_run_options(
+            keep_browser_open=False,
+            headless=False,
+        )
+        assert options.environment == "standalone"
+        assert type(options) is StandaloneRunOptions
+        assert options.headless is False
+
+    @pytest.mark.asyncio
+    async def test_launches_browser_and_returns_cdp_options_if_keep_browser_open_is_true(
+        self, browser_mocks: BrowserMocks
+    ):
+        options = await get_cli_run_options(
+            keep_browser_open=True,
+            headless=False,
+        )
+        assert options.environment == "cdp"
+        assert type(options) is CDPRunOptions
+        assert options.cdp_address == "http://localhost:1234"
+
+        browser_mocks.launch_chromium.assert_called_with(
+            headless=False,
+            cdp_port=1234,
+            proxy=None,
+        )
+
+    @pytest.mark.asyncio
+    async def test_keeps_context_open_until_new_context_if_keep_browser_open_is_true(self, browser_mocks: BrowserMocks):
+        options = await get_cli_run_options(
+            keep_browser_open=True,
+            headless=False,
+        )
+        assert options.environment == "cdp"
+        assert type(options) is CDPRunOptions
+        assert options.cdp_address == "http://localhost:1234"
+
+        from intuned_cli.utils.browser import _current_browser_context  # type: ignore
+
+        first_context = _current_browser_context
+        assert first_context is not None
+
+        assert browser_mocks.launch_chromium.call_count == 1
+
+        options = await get_cli_run_options(
+            keep_browser_open=True,
+            headless=False,
+        )
+
+        from intuned_cli.utils.browser import _current_browser_context  # type: ignore
+
+        second_context = _current_browser_context
+        assert second_context is not None
+        assert first_context != second_context
+        assert browser_mocks.launch_chromium.call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_keeps_context_open_until_explicitly_closed_if_keep_browser_open_is_true(
+        self, browser_mocks: BrowserMocks
+    ):
+        options = await get_cli_run_options(
+            keep_browser_open=True,
+            headless=False,
+        )
+        assert options.environment == "cdp"
+        assert type(options) is CDPRunOptions
+        assert options.cdp_address == "http://localhost:1234"
+
+        from intuned_cli.utils.browser import _current_browser_context  # type: ignore
+
+        assert _current_browser_context is not None
+
+        assert browser_mocks.launch_chromium.call_count == 1
+
+        await close_cli_browser()
+
+        from intuned_cli.utils.browser import _current_browser_context  # type: ignore
+
+        assert _current_browser_context is None

intuned_cli/utils/__test__/test_traces.py

@@ -0,0 +1,27 @@
+from unittest.mock import Mock
+from unittest.mock import patch
+
+from intuned_cli.utils.traces import cli_trace
+from runtime.types.run_types import TracingDisabled
+from runtime.types.run_types import TracingEnabled
+
+
+def get_mock_console():
+    """Create a mock console that tracks calls."""
+    mock_console = Mock()
+    mock_console.print = Mock()
+    return mock_console
+
+
+@patch("intuned_cli.controller.authsession.console", get_mock_console())
+class TestTraces:
+    def test_gives_disabled_tracing_if_id_is_none(self):
+        tracing = cli_trace(None).__enter__()
+        assert tracing.enabled is False
+        assert type(tracing) is TracingDisabled
+
+    def test_gives_enabled_tracing_if_id_is_provided(self):
+        tracing = cli_trace("some_id").__enter__()
+        assert tracing.enabled is True
+        assert type(tracing) is TracingEnabled
+        assert "some_id" in tracing.file_path

intuned_cli/utils/api_helpers.py

@@ -1,7 +1,15 @@
+import json
+from typing import Any
+from typing import Callable
+from typing import get_args
 from typing import Literal
 from typing import overload
 
+import toml
+import yaml
 from anyio import Path
+from jsonc_parser.parser import JsoncParser  # type: ignore
+from pydantic import BaseModel
 
 from intuned_cli.utils.error import CLIError
 from runtime.types import IntunedJson
@@ -23,10 +31,51 @@ async def assert_api_file_exists(dirname: Literal["api", "auth-sessions"], api_n
 
 
 async def load_intuned_json() -> IntunedJson:
-    intuned_json_path = Path("Intuned.json")
-    if not await intuned_json_path.exists():
-        raise CLIError("Intuned.json file is missing in the current directory.")
+    intuned_settings_file = await get_intuned_settings_file()
+
+    intuned_settings_content = await Path(intuned_settings_file.file_path).read_text()
+
+    parsed_content = intuned_settings_file.parse(intuned_settings_content)
+
     try:
-        return IntunedJson.model_validate_json(await intuned_json_path.read_text())
+        return IntunedJson.model_validate(parsed_content)
     except Exception as e:
-        raise CLIError(f"Failed to parse Intuned.json: {e}") from e
+        raise CLIError(f"Failed to parse {intuned_settings_file.name}: {e}") from e
+
+
+IntunedSettingsFileName = Literal["Intuned.json", "Intuned.jsonc", "Intuned.yaml", "Intuned.yml", "Intuned.toml"]
+
+intuned_file_names: list[IntunedSettingsFileName] = list(get_args(IntunedSettingsFileName))
+
+
+class IntunedSettingsFile(BaseModel):
+    name: IntunedSettingsFileName
+    file_path: str
+    parse: Callable[[str], Any]
+
+
+intuned_settings_parsers: dict[IntunedSettingsFileName, Callable[[str], Any]] = {
+    "Intuned.json": json.loads,
+    "Intuned.jsonc": lambda content: JsoncParser.parse_str(content),  # type: ignore
+    "Intuned.yaml": yaml.safe_load,
+    "Intuned.yml": yaml.safe_load,
+    "Intuned.toml": toml.loads,
+}
+
+
+async def get_intuned_settings_file() -> IntunedSettingsFile:
+    for file_name in intuned_file_names:
+        path = Path(file_name)
+        if await path.exists():
+            return IntunedSettingsFile(
+                name=file_name,
+                file_path=str(path),
+                parse=intuned_settings_parsers[file_name],
+            )
+    raise CLIError(
+        "No Intuned settings file found in the current directory. Expected one of: " + ", ".join(intuned_file_names)
+    )
+
+
+async def get_intuned_settings_file_name() -> str:
+    return (await get_intuned_settings_file()).name

intuned_cli/utils/auth_session_helpers.py

@@ -1,10 +1,13 @@
 import json
 from typing import Any
+from typing import Literal
 
 from anyio import Path
 
+from intuned_cli.utils.api_helpers import get_intuned_settings_file_name
 from intuned_cli.utils.api_helpers import load_intuned_json
 from intuned_cli.utils.error import CLIError
+from runtime.types.settings_types import IntunedJsonEnabledAuthSessions
 
 
 class CLIAssertionError(CLIError):
@@ -12,17 +15,30 @@ class CLIAssertionError(CLIError):
 
 
 async def is_auth_enabled() -> bool:
-    """
-    Check if the auth session is enabled in Intuned.json.
-    Returns True if enabled, False otherwise.
-    """
     intuned_json = await load_intuned_json()
     return intuned_json.auth_sessions.enabled
 
 
-async def assert_auth_enabled():
+async def assert_auth_enabled(*, auth_type: Literal["API", "MANUAL"] | None = None):
     if not await is_auth_enabled():
-        raise CLIAssertionError("Auth session is not enabled, enable it in Intuned.json to use it")
+        raise CLIAssertionError(
+            f"Auth session is not enabled, enable it in {await get_intuned_settings_file_name()} to use it"
+        )
+    if auth_type is None:
+        return
+    intuned_json = await load_intuned_json()
+    if (
+        type(intuned_json.auth_sessions) is IntunedJsonEnabledAuthSessions
+        and intuned_json.auth_sessions.type != auth_type
+    ):
+        if auth_type == "API":
+            raise CLIAssertionError(
+                f"Auth session type is not credentials-based in {await get_intuned_settings_file_name()}. Set it to 'API' to run this command."
+            )
+
+        raise CLIAssertionError(
+            f"Auth session type is not recorder-based in {await get_intuned_settings_file_name()}. Set it to 'MANUAL' to run this command."
+        )
 
 
 async def assert_auth_consistent(auth_session_id: str | None = None):
@@ -32,7 +48,9 @@ async def assert_auth_consistent(auth_session_id: str | None = None):
             "Auth session is enabled, but no auth session is provided. Please provide an auth session ID."
         )
     if not _is_auth_enabled and auth_session_id is not None:
-        raise CLIAssertionError("Auth session is not enabled, enable it in Intuned.json to use it")
+        raise CLIAssertionError(
+            f"Auth session is not enabled, enable it in {await get_intuned_settings_file_name()} to use it"
+        )
 
 
 async def load_parameters(parameters: str) -> dict[str, Any]:
@@ -55,3 +73,20 @@ async def load_parameters(parameters: str) -> dict[str, Any]:
         raise CLIError(f"Invalid JSON format: {e}") from e
     except Exception as e:
         raise CLIError(f"Failed to load parameters: {e}") from e
+
+
+async def get_auth_session_recorder_parameters() -> tuple[str, str]:
+    intuned_json = await load_intuned_json()
+    auth_session_settings = intuned_json.auth_sessions
+    if type(auth_session_settings) is not IntunedJsonEnabledAuthSessions:
+        raise CLIError(f"Auth sessions are not enabled in {await get_intuned_settings_file_name()}")
+    if auth_session_settings.type != "MANUAL":
+        raise CLIError(f"Auth session type is not recorder-based in {await get_intuned_settings_file_name()}")
+    start_url = auth_session_settings.start_url
+    finish_url = auth_session_settings.finish_url
+    if not start_url or not finish_url:
+        raise CLIError(
+            f"Auth session type is recorder-based but start_url or finish_url is not set in {await get_intuned_settings_file_name()}"
+        )
+
+    return start_url, finish_url

intuned_cli/utils/backend.py

@@ -1,5 +1,6 @@
 import os
 
+from intuned_cli.utils.api_helpers import get_intuned_settings_file_name
 from intuned_cli.utils.error import CLIError
 from runtime.types import IntunedJson
 
@@ -21,7 +22,9 @@ async def get_intuned_api_auth_credentials(
     api_key = api_key or os.environ.get("INTUNED_API_KEY")
 
     if not workspace_id:
-        raise CLIError("Workspace ID is required. Please provide it via command line options or Intuned.json")
+        raise CLIError(
+            f"Workspace ID is required. Please provide it via command line options or {await get_intuned_settings_file_name()}."
+        )
 
     if not api_key:
         raise CLIError(

intuned_cli/utils/browser.py

@@ -0,0 +1,63 @@
+from typing import Any
+from typing import AsyncContextManager
+from typing import TYPE_CHECKING
+
+from runtime.types.run_types import CDPRunOptions
+from runtime.types.run_types import ProxyConfig
+from runtime.types.run_types import StandaloneRunOptions
+
+if TYPE_CHECKING:
+    from playwright.async_api import BrowserContext
+
+_current_browser_context_manager: AsyncContextManager[Any] | None = None
+_current_browser_context: "BrowserContext | None" = None
+
+
+async def get_cli_run_options(
+    headless: bool = False,
+    proxy: ProxyConfig | None = None,
+    keep_browser_open: bool = False,
+):
+    global _current_browser_context_manager, _current_browser_context
+    if not keep_browser_open:
+        return StandaloneRunOptions(
+            headless=headless,
+            proxy=proxy,
+        )
+    from playwright.async_api import ProxySettings
+
+    from runtime.browser.launch_chromium import launch_chromium
+    from runtime.run.playwright_context import get_random_free_port
+
+    await close_cli_browser()
+    port = await get_random_free_port()
+    acm = launch_chromium(
+        headless=headless,
+        cdp_port=port,
+        proxy=ProxySettings(
+            **proxy.model_dump(by_alias=True),
+        )
+        if proxy
+        else None,
+    )
+
+    _current_browser_context_manager = acm
+    _current_browser_context, _ = await _current_browser_context_manager.__aenter__()
+
+    return CDPRunOptions(
+        cdp_address=f"http://localhost:{port}",
+    )
+
+
+def is_cli_browser_launched():
+    global _current_browser_context_manager
+    return _current_browser_context_manager is not None and _current_browser_context is not None
+
+
+async def close_cli_browser():
+    global _current_browser_context_manager, _current_browser_context
+    if _current_browser_context_manager is not None:
+        await _current_browser_context_manager.__aexit__(None, None, None)
+        _current_browser_context_manager = None
+    if _current_browser_context is not None:
+        _current_browser_context = None

intuned_cli/utils/error.py

@@ -29,3 +29,17 @@ def log_automation_error(e: RunApiError):
         console.print(f"[red]{''.join(stack_trace)}[/red]")
     else:
         console.print(f"[red]{e}[/red]")
+
+
+class CLIExit(BaseException):
+    """Exception to signal CLI exit with a specific code."""
+
+    def __init__(self, code: int):
+        """
+        Initialize the CLIExit.
+
+        Args:
+            code (int): The exit code.
+        """
+        super().__init__()
+        self.code = code

intuned_cli/utils/exclusions.py

@@ -34,6 +34,7 @@ exclusions = [
     "README.md",
     "output/**",
     "tmp/**",
+    "traces/**",
 ]
 
 # For compatibility with import style similar to 'export default exclusions'

intuned_cli/utils/help.py

@@ -0,0 +1,9 @@
+import arguably
+
+from intuned_cli.utils.error import CLIExit
+
+
+def print_help_and_exit():
+    if arguably.is_target():
+        arguably._context.context._current_parser.print_help()  # type: ignore
+        raise CLIExit(0)