intuned-runtime 1.0.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,45 @@
+import sys
+import traceback
+
+import arguably
+from dotenv import find_dotenv
+from dotenv import load_dotenv
+from more_termcolor import bold  # type: ignore
+from more_termcolor import red  # type: ignore
+
+from runtime.context.context import IntunedContext
+
+from . import commands
+
+
+def run():
+    dotenv = find_dotenv(usecwd=True)
+    if dotenv:
+        load_dotenv(dotenv, override=True)
+    try:
+        with IntunedContext():
+            arguably.run()
+    except ValueError as e:
+        print(bold(red(str(e))))
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print(bold(red("\n🛑 Aborted")))
+        sys.exit(1)
+    except Exception as e:
+        tb_list = traceback.extract_tb(e.__traceback__)
+
+        DEPTH_THRESHOLD = 4
+
+        if len(tb_list) > DEPTH_THRESHOLD:
+            relevant_frames = tb_list[DEPTH_THRESHOLD:]  # Show last 2 frames - adjust as needed
+            formatted_tb = "".join(traceback.format_list(relevant_frames))
+            print(f"Traceback (most recent call last):\n{formatted_tb}{type(e).__name__}: {str(e)}")
+        else:
+            # For shallow traces, show everything
+            print("".join(traceback.format_exception(type(e), e, e.__traceback__)))
+
+        print(red(bold(f"❌ An error occurred: {e}")))
+        sys.exit(1)
+
+
+__all__ = ["commands", "run"]

cli/commands/__init__.py

@@ -0,0 +1,25 @@
+from .ai_source import ai_source  # type: ignore
+from .ai_source import ai_source__deploy  # type: ignore
+from .browser import browser__save_state  # type: ignore
+from .init import init  # type: ignore
+from .project import project  # type: ignore
+from .project import project__run  # type: ignore
+from .project import project__type_check  # type: ignore
+from .project.auth_session import project__auth_session__check  # type: ignore
+from .project.auth_session import project__auth_session__create  # type: ignore
+from .project.auth_session import project__auth_session__load  # type: ignore
+from .publish_packages import publish_packages  # type: ignore
+
+__all__ = [
+    "project__run",
+    "publish_packages",
+    "init",
+    "project",
+    "ai_source__deploy",
+    "ai_source",
+    "project__auth_session__load",
+    "project__auth_session__create",
+    "project__auth_session__check",
+    "project__type_check",
+    "browser__save_state",
+]

cli/commands/ai_source/__init__.py

@@ -0,0 +1,4 @@
+from .ai_source import ai_source  # type: ignore
+from .deploy import ai_source__deploy  # type: ignore
+
+__all__ = ["ai_source", "ai_source__deploy"]

cli/commands/ai_source/ai_source.py

@@ -0,0 +1,10 @@
+import arguably
+
+
+@arguably.command  # type: ignore
+def ai_source():
+    """
+    Commands to run on AI source projects.
+    """
+
+    pass

cli/commands/ai_source/deploy.py

@@ -0,0 +1,64 @@
+import json
+
+import arguably
+from more_termcolor import bold  # type: ignore
+from more_termcolor import cyan  # type: ignore
+from more_termcolor import green  # type: ignore
+from more_termcolor import red  # type: ignore
+
+from cli.utils.code_tree import convert_project_to_code_tree
+
+from ...utils.ai_source_project import AiSourceInfo
+from ...utils.ai_source_project import deploy_ai_source
+
+
+@arguably.command  # type: ignore
+def ai_source__deploy(
+    *,
+    ai_source_info_str: str,
+    ai_source_info_path: str,
+    yes_to_all: bool = False,
+):
+    """
+    Commands to run on AI source projects.
+
+    Args:
+        ai_source_info_str (str): [--ai-source-info] JSON string containing the AI source project information.
+        ai_source_info_path (str): Path to the JSON file containing the AI source project information. Defaults to <current directory>/ai_source.json.
+        yes_to_all (bool): [-y/--yes] Skip confirmation prompts.
+    """
+
+    if ai_source_info_str and ai_source_info_path:
+        raise ValueError("Only one of ai_source_info or ai_source_info_path should be provided.")
+
+    if not (ai_source_info_str or ai_source_info_path):
+        ai_source_info_path = "ai_source.json"
+
+    try:
+        if ai_source_info_str:
+            ai_source_info_json = json.loads(ai_source_info_str)
+        else:
+            with open(ai_source_info_path) as f:
+                ai_source_info_json = json.load(f)
+        ai_source_info = AiSourceInfo(**ai_source_info_json)
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid JSON in ai_source_info: {e}") from e
+    except FileNotFoundError as e:
+        raise ValueError("AI source info file not found") from e
+    except OSError as e:
+        raise ValueError("Error reading AI source info file") from e
+    except TypeError as e:
+        raise ValueError("AI source info is invalid:", str(e)) from e
+
+    wait_for_confirm = not yes_to_all
+
+    code_tree = convert_project_to_code_tree(".", wait_for_confirm=wait_for_confirm)
+
+    success = deploy_ai_source(code_tree, ai_source_info)
+
+    if success:
+        print(
+            f"🚀 AI source deployment triggered for {bold(green(ai_source_info.id))} ({bold(green(ai_source_info.version_id))}). Check progress at {cyan(f"{ai_source_info.environment_url}/__internal-ai-sources/{ai_source_info.id}?version_id={ai_source_info.version_id}")}"
+        )
+    else:
+        print(red(bold("Deployment failed")))

cli/commands/browser/__init__.py

@@ -0,0 +1,3 @@
+from .save_state import browser__save_state  # type: ignore
+
+__all__ = ["browser__save_state"]

cli/commands/browser/save_state.py

@@ -0,0 +1,32 @@
+import json
+import os
+
+import arguably
+
+from runtime.browser import launch_chromium
+from runtime.browser.storage_state import get_storage_state
+
+
+@arguably.command  # type: ignore
+async def browser__save_state(
+    *,
+    cdp_address: str,
+    output_path: str,
+):
+    """
+    Load an auth session to a browser.
+
+    Args:
+        cdp_address (str): The CDP address of the browser to save the state from.
+        output_path (str): Path to save browser state to.
+    """
+
+    async with launch_chromium(
+        cdp_address=cdp_address,
+    ) as (context, _):
+        storage_state = await get_storage_state(context)
+
+        path = os.path.join(os.getcwd(), output_path)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as f:
+            json.dump(storage_state.model_dump(by_alias=True), f, indent=2)

cli/commands/init.py

@@ -0,0 +1,127 @@
+import json
+import os
+from typing import Any
+
+import arguably
+import toml
+from more_termcolor import bold  # type: ignore
+from more_termcolor import green  # type: ignore
+
+from ..utils.code_tree import get_project_name
+
+
+@arguably.command  # type: ignore
+def init(
+    *,
+    yes_to_all: bool = False,
+    no_to_all: bool = False,
+    project_name: str | None,
+):
+    """
+    Initializes current app, creating pyproject.toml and Intuned.json files. Will ask for confirmation before overwriting existing files.
+
+    Args:
+        yes_to_all (bool): [-y/--yes] Answer yes to all confirmation prompts
+        no_to_all (bool): [-n/--no] Answer no to any confirmation prompts
+        project_name (str | None): Name of the project. Will automatically resolve if not provided.
+
+    Returns:
+        None
+    """
+
+    if yes_to_all and no_to_all:
+        raise ValueError("Cannot specify both --yes and --no")
+
+    def should_write_file(file: str) -> bool:
+        if not os.path.exists(file):
+            return True
+        if no_to_all:
+            return False
+        elif yes_to_all:
+            print(bold(f"Overwriting {green(file)}"))
+            return True
+        return input(f"Overwrite {green(file)}? (y/N) ").lower().strip() == "y"
+
+    project_name = project_name or get_project_name(".")
+    print(bold("Initializing"), green(project_name))
+
+    def print_created(file: str) -> None:
+        print(bold("📦 Created"), green(file))
+
+    pyproject_name = "pyproject.toml"
+    if should_write_file(pyproject_name):
+        with open(pyproject_name, "w") as f:
+            toml.dump(_get_pyproject(project_name), f)
+        print_created(pyproject_name)
+
+    intuned_json_name = "Intuned.json"
+    if should_write_file(intuned_json_name):
+        with open(intuned_json_name, "w") as f:
+            json.dump(_get_intuned_json(project_name), f, indent=2)
+        print_created(intuned_json_name)
+
+    readme_name = "README.md"
+    if should_write_file(readme_name):
+        with open(readme_name, "w") as f:
+            f.write(_get_readme(project_name))
+        print_created(readme_name)
+
+    print(bold("✨ Done!"))
+
+
+def _get_pyproject(project_name: str) -> dict[str, Any]:
+    return {
+        "build-system": {"requires": ["poetry-core>=1.2.0"], "build-backend": "poetry.core.masonry.api"},
+        "tool": {
+            "poetry": {
+                "package-mode": False,
+                "name": project_name,
+                "version": "0.0.1",
+                "description": f"Project {project_name}",
+                "authors": ["Intuned <service@intunedhq.com>"],
+                "readme": "README.md",
+                "dependencies": {
+                    "python": ">=3.12,<3.13",
+                    "intuned-runtime": {
+                        "git": "ssh://git@github.com/Intuned/python-packages.git",
+                        "tag": "runtime-latest",
+                        "subdirectory": "runtime",
+                    },
+                    "intuned-sdk": {
+                        "git": "ssh://git@github.com/Intuned/python-packages.git",
+                        "tag": "sdk-latest",
+                        "subdirectory": "sdk",
+                    },
+                },
+            }
+        },
+    }
+
+
+def _get_intuned_json(_project_name: str) -> dict[str, Any]:
+    return {
+        "authSessions": {"enabled": False},
+        "scale": {"machineCount": 1, "softLimit": 1, "hardLimit": 5, "memory": 2048, "cpus": 6},
+        "proxy": {"enabled": False},
+    }
+
+
+def _get_readme(project_name: str) -> str:
+    return (
+        f"# `{project_name}` Intuned Automation Project\n"
+        f"\n"
+        f"\n"
+        f"## Getting started\n"
+        f"- Install dependencies: `poetry install`\n"
+        f"- Activate virtual environment: `poetry shell`\n"
+        f"- Project commands: `intuned project --help`\n"
+        f"  - Run the project:\n"
+        f"    - Sample mode: `intuned project run`\n"
+        f"    - Full mode: `intuned project run --mode full`\n"
+        f"    - Single mode: `intuned project run --mode single`\n"
+        f"  - Deploy the project: `intuned project deploy`\n"
+        f"  - Use `--help` for full details on each command.\n"
+        f"\n"
+        f"## SDK\n"
+        f"- If you want to use a specific version of the SDK, make sure to change the tag from `sdk-latest` to `sdk-<version>` in **pyproject.toml**.\n"
+    )

cli/commands/project/__init__.py

@@ -0,0 +1,20 @@
+from .auth_session import project__auth_session__check  # type: ignore
+from .auth_session import project__auth_session__create  # type: ignore
+from .auth_session import project__auth_session__load  # type: ignore
+from .project import project  # type: ignore
+from .run import project__run  # type: ignore
+from .run_interface import project__run_interface  # type: ignore
+from .type_check import project__type_check  # type: ignore
+from .upgrade import project__upgrade  # type: ignore
+
+__all__ = [
+    "run",
+    "project__run",
+    "project__type_check",
+    "project",
+    "project__auth_session__load",
+    "project__auth_session__create",
+    "project__auth_session__check",
+    "project__upgrade",
+    "project__run_interface",
+]

cli/commands/project/auth_session/__init__.py

@@ -0,0 +1,5 @@
+from .check import project__auth_session__check  # type: ignore
+from .create import project__auth_session__create  # type: ignore
+from .load import project__auth_session__load  # type: ignore
+
+__all__ = ["project__auth_session__check", "project__auth_session__create", "project__auth_session__load"]

cli/commands/project/auth_session/check.py

@@ -0,0 +1,118 @@
+import json
+import os
+from typing import Any
+
+import arguably
+import pydantic  # type: ignore
+from more_termcolor import bold  # type: ignore
+from more_termcolor import green  # type: ignore
+from more_termcolor import red  # type: ignore
+from tenacity import retry
+from tenacity import retry_if_not_result
+from tenacity import RetryError
+from tenacity import stop_after_attempt
+
+from runtime.context.context import IntunedContext
+from runtime.errors.run_api_errors import RunApiError
+from runtime.run.intuned_settings import load_intuned_settings
+from runtime.run.run_api import import_function_from_api_dir
+from runtime.run.run_api import run_api
+from runtime.types.run_types import Auth
+from runtime.types.run_types import AutomationFunction
+from runtime.types.run_types import CDPRunOptions
+from runtime.types.run_types import RunApiParameters
+from runtime.types.run_types import StandaloneRunOptions
+from runtime.types.run_types import StateSession
+from runtime.types.run_types import StorageState
+from runtime.types.run_types import TracingDisabled
+
+
+@arguably.command  # type: ignore
+async def project__auth_session__check(
+    *,
+    no_headless: bool = False,
+    cdp_address: str | None = None,
+    auth_session_path: str,
+    auth_session_parameters: str | None = None,
+):
+    """
+    Check the auth session.
+
+    Args:
+        cdp_address (str): The CDP address of the browser to load the auth session to.
+        auth_session_path (str): Path to the auth session file.
+        no_headless (bool): Whether to run the browser in headless mode.
+        auth_session_parameters (str | None): JSON string with auth session parameters.
+    """
+    intuned_settings = await load_intuned_settings()
+    if not intuned_settings.auth_sessions.enabled:
+        raise Exception("Auth sessions are not enabled")
+
+    if not os.path.exists(auth_session_path):
+        raise Exception("Auth session file does not exist")
+
+    with open(auth_session_path) as f:
+        try:
+            auth_session = StorageState(**json.load(f))
+        except (json.JSONDecodeError, TypeError) as e:
+            raise Exception("Auth session file is not a valid JSON file") from e
+        except pydantic.ValidationError as e:
+            raise Exception(f"Auth session file is not valid: {e}") from e
+
+    retry_configs = retry(stop=stop_after_attempt(2), retry=retry_if_not_result(lambda result: result is True))
+
+    def import_function(file_path: str, function_name: str | None = None):
+        return import_function_from_api_dir(
+            file_path=file_path,
+            automation_function_name=function_name,
+            base_dir=os.path.join(os.getcwd()),
+        )
+
+    async def get_auth_session_parameters() -> dict[str, Any]:
+        assert auth_session_parameters is not None
+        try:
+            return json.loads(auth_session_parameters)
+        except json.JSONDecodeError as e:
+            raise Exception("Auth session parameters are not a valid JSON string") from e
+
+    if auth_session_parameters is not None:
+        IntunedContext.current().get_auth_session_parameters = get_auth_session_parameters
+
+    try:
+
+        async def check_fn():
+            result = await run_api(
+                RunApiParameters(
+                    automation_function=AutomationFunction(
+                        name="auth-sessions/check",
+                        params=None,
+                    ),
+                    tracing=TracingDisabled(),
+                    run_options=CDPRunOptions(
+                        cdp_address=cdp_address,
+                    )
+                    if cdp_address is not None
+                    else StandaloneRunOptions(headless=not no_headless),
+                    auth=Auth(
+                        run_check=False,
+                        session=StateSession(
+                            state=auth_session,
+                        ),
+                    ),
+                ),
+                import_function=import_function,
+            )
+            check_result = result.result
+            return check_result is True
+
+        check_fn_with_retries = retry_configs(check_fn)
+        try:
+            result = await check_fn_with_retries()
+        except RetryError:
+            result = False
+        success = type(result) is bool and result
+        print(bold("Check result is"), bold(red(result)) if not success else bold(green(result)))
+        if not success:
+            raise Exception("Auth session check failed")
+    except RunApiError as e:
+        raise Exception(f"Error running auth session check: {e}") from e

cli/commands/project/auth_session/create.py

@@ -0,0 +1,96 @@
+import json
+import os
+from typing import Any
+
+import arguably
+
+from runtime.context.context import IntunedContext
+from runtime.errors.run_api_errors import RunApiError
+from runtime.run.intuned_settings import load_intuned_settings
+from runtime.run.run_api import import_function_from_api_dir
+from runtime.run.run_api import run_api
+from runtime.types.run_types import AutomationFunction
+from runtime.types.run_types import CDPRunOptions
+from runtime.types.run_types import RunApiParameters
+from runtime.types.run_types import StandaloneRunOptions
+from runtime.types.run_types import TracingDisabled
+
+
+@arguably.command  # type: ignore
+async def project__auth_session__create(
+    *,
+    no_headless: bool = False,
+    cdp_address: str | None = None,
+    input_file: str | None = None,
+    input_json: str | None = None,
+    output_path: str | None = None,
+):
+    """
+    Run auth session create
+
+    Args:
+        cdp_address (str): Browser CDP address
+        input_file (str | None, optional): Auth session create input file path.
+        input_json (str | None, optional): Auth session create input JSON string.
+        output_path (str | None, optional): Path to save the auth session. If not provided, the auth session will not be saved.
+    """
+
+    input_data = None
+    if input_file:
+        with open(input_file) as f:
+            input_data = json.load(f)
+    elif input_json:
+        input_data = json.loads(input_json)
+
+    # Load the intuned settings
+    intuned_settings = await load_intuned_settings()
+    if not intuned_settings.auth_sessions.enabled:
+        raise Exception("Auth sessions are not enabled")
+
+    def import_function(file_path: str, function_name: str | None = None):
+        return import_function_from_api_dir(
+            file_path=file_path,
+            automation_function_name=function_name,
+            base_dir=os.path.join(os.getcwd()),
+        )
+
+    async def get_auth_session_parameters() -> dict[str, Any]:
+        return input_data or dict[str, Any]()
+
+    IntunedContext.current().get_auth_session_parameters = get_auth_session_parameters
+    try:
+        result = await run_api(
+            RunApiParameters(
+                automation_function=AutomationFunction(
+                    name="auth-sessions/create",
+                    params=input_data,
+                ),
+                tracing=TracingDisabled(),
+                run_options=CDPRunOptions(
+                    cdp_address=cdp_address,
+                )
+                if cdp_address is not None
+                else StandaloneRunOptions(
+                    headless=not no_headless,
+                ),
+                retrieve_session=True,
+            ),
+            import_function=import_function,
+        )
+        session = result.session
+        if not session:
+            raise Exception("Could not capture auth session")
+    except RunApiError as e:
+        raise Exception(f"Error running auth session create: {e}") from e
+
+    if not output_path:
+        print("Output path not set, discarding auth session")
+        return
+
+    full_output_path = (
+        os.path.abspath(output_path) if os.path.isabs(output_path) else os.path.join(os.getcwd(), output_path)
+    )
+
+    os.makedirs(os.path.dirname(full_output_path), exist_ok=True)
+    with open(full_output_path, "w") as f:
+        json.dump(session.model_dump(by_alias=True), f, indent=2)

cli/commands/project/auth_session/load.py

@@ -0,0 +1,39 @@
+import json
+import os
+
+import arguably
+
+from runtime.browser import launch_chromium
+from runtime.browser.storage_state import set_storage_state
+from runtime.run.intuned_settings import load_intuned_settings
+from runtime.types.run_types import StorageState
+
+
+@arguably.command  # type: ignore
+async def project__auth_session__load(
+    *,
+    cdp_address: str,
+    auth_session_path: str,
+):
+    """
+    Load an auth session to a browser.
+
+    Args:
+        cdp_address (str): The CDP address of the browser to load the auth session to.
+        auth_session_path (str): Path to the auth session file.
+    """
+    intuned_settings = await load_intuned_settings()
+    if not intuned_settings.auth_sessions.enabled:
+        raise Exception("Auth sessions are not enabled")
+
+    async with launch_chromium(
+        cdp_address=cdp_address,
+    ) as (context, _):
+        auth_session_path = os.path.join(os.getcwd(), auth_session_path)
+        if not os.path.exists(auth_session_path):
+            raise Exception("Auth session file does not exist")
+
+        with open(auth_session_path) as f:
+            auth_session = StorageState(**json.load(f))
+
+        await set_storage_state(context, auth_session)

cli/commands/project/project.py

@@ -0,0 +1,10 @@
+import arguably
+
+
+@arguably.command  # type: ignore
+def project():
+    """
+    Commands to run on automation projects.
+    """
+
+    pass