intuned-runtime 1.0.0__py3-none-any.whl

cli/commands/project/upgrade.py

@@ -0,0 +1,92 @@
+import os
+import subprocess
+from typing import List
+from typing import Tuple
+
+import arguably
+import git
+import git.cmd
+import semver
+
+
+@arguably.command  # type: ignore
+def project__upgrade():
+    """
+    Upgrade the project's Intuned runtime and Intuned SDK to the latest version.
+    """
+    runtime_version, sdk_version = resolve_packages_versions()
+    print(f"Upgrading to runtime version {runtime_version} and SDK version {sdk_version}")
+
+    # Upgrade runtime and SDK using poetry
+    repo_url = "git+ssh://git@github.com/intuned/python-packages.git"
+    cwd = os.getcwd()
+
+    try:
+        # Upgrade runtime
+        subprocess.run(
+            ["poetry", "add", f"{repo_url}@runtime-{runtime_version}#subdirectory=runtime"], check=True, cwd=cwd
+        )
+
+        # Upgrade SDK
+        subprocess.run(["poetry", "add", f"{repo_url}@sdk-{sdk_version}#subdirectory=sdk"], check=True, cwd=cwd)
+
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to upgrade packages: {e.stderr}") from e
+
+
+def get_latest_version(versions: List[str], prefix: str) -> str:
+    """
+    Get the latest version from a list of versioned tags.
+    Filters out dev versions and returns the highest semver version.
+    """
+    valid_versions: list[str] = []
+    for version in versions:
+        version_str = version.replace(f"{prefix}-", "")
+        try:
+            # Skip dev versions
+            if "dev" not in version_str:
+                semver.VersionInfo.parse(version_str)
+                valid_versions.append(version_str)
+        except ValueError:
+            continue
+
+    if not valid_versions:
+        raise ValueError(f"No valid versions found for {prefix}")
+
+    # Sort versions and get the latest
+    latest = str(max(map(semver.VersionInfo.parse, valid_versions)))
+    return latest
+
+
+def resolve_packages_versions() -> Tuple[str, str]:
+    """
+    Resolves the latest versions of runtime and SDK packages using git ls-remote.
+    Returns a tuple of (runtime_version, sdk_version)
+    """
+    try:
+        # Use GitPython to get remote tags
+        repo = git.cmd.Git()
+        refs = repo.ls_remote("--tags", "git@github.com:intuned/python-packages.git").split("\n")
+
+        # Parse the output which looks like:
+        # hash    refs/tags/runtime-1.0.1
+        # hash    refs/tags/sdk-0.1.1
+        tags: list[str] = []
+        for line in refs:
+            if not line.strip():
+                continue
+            _, ref = line.split(None, 1)
+            tag = ref.replace("refs/tags/", "")
+            tags.append(tag)
+
+        # Split into runtime and sdk versions
+        runtime_versions = [tag for tag in tags if tag.startswith("runtime-")]
+        sdk_versions = [tag for tag in tags if tag.startswith("sdk-")]
+
+        latest_runtime = get_latest_version(runtime_versions, "runtime")
+        latest_sdk = get_latest_version(sdk_versions, "sdk")
+
+        return latest_runtime, latest_sdk
+
+    except git.GitCommandError as e:
+        raise RuntimeError(f"Failed to fetch tags from git repository: {e.stderr}") from e

cli/commands/publish_packages.py

@@ -0,0 +1,264 @@
+import functools
+import subprocess
+from os import environ
+from os import path
+
+import arguably
+import toml
+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 italic  # type: ignore
+from more_termcolor import underline  # type: ignore
+from more_termcolor import yellow  # type: ignore
+
+
+@arguably.command  # type: ignore
+def publish_packages(
+    *,
+    sdk: bool = False,
+    runtime: bool = False,
+    show_diff: bool = False,
+    update_template: bool = False,
+):
+    """
+    Publishes the SDK and Runtime packages to `python-packages` repository. Uses the version defined in the pyproject.toml file.
+    Args:
+        sdk (bool): Publish the SDK package.
+        runtime (bool): Publish the Runtime package.
+        show_diff (bool): Show the diff of the files that will be copied to the package repo. Configure your git difftool to use your preferred diff tool (VSCode recommended).
+        update_template (bool): [-u/--update-template] Update the template versions in the WebApp repo.
+    """
+
+    sdk_source_path = None
+    sdk_runtime_path = None
+
+    webapp_path = environ.get("WEBAPP_PATH")
+    if not webapp_path:
+        webapp_resolved_path = path.join(path.dirname(__file__), "..", "..", "..", "..")
+        if path.exists(path.join(webapp_resolved_path, ".git")):
+            webapp_path = webapp_resolved_path
+        else:
+            raise ValueError(
+                "WebApp repo could not be found. Maybe you are not running the globally-installed CLI. Set WEBAPP_PATH environment variable."
+            )
+    print(bold("WebApp path"), underline(cyan(path.abspath(webapp_path))))
+
+    sdk_source_path = path.join(webapp_path, "apps", "python-sdk")
+    sdk_runtime_path = path.join(webapp_path, "apps", "python-runtime")
+
+    if True not in [sdk, runtime]:
+        raise ValueError("You should select at least one package to release")
+
+    _release_package = functools.partial(release_package, webapp_path=webapp_path, show_diff=show_diff)
+
+    if sdk:
+        _release_package(
+            package_human_name="SDK",
+            package_name="intuned-sdk",
+            packages_repo_dirname="sdk",
+            package_source_path=sdk_source_path,
+        )
+
+    if runtime:
+        _release_package(
+            package_human_name="Runtime",
+            package_name="intuned-runtime",
+            packages_repo_dirname="runtime",
+            package_source_path=sdk_runtime_path,
+        )
+
+    runtime_version = check_package_version(sdk_runtime_path, "intuned-runtime")
+    sdk_version = check_package_version(sdk_source_path, "intuned-sdk")
+
+    # Only run template generation in production environment
+    if update_template:
+        update_template_version(webapp_path, runtime_version, sdk_version)
+        generate_authoring_template_files(webapp_path)
+    else:
+        print(bold(f"\n🔍 {yellow('Skipping authoring template generation - only runs in production environment')}"))
+
+
+def generate_authoring_template_files(webapp_path: str):
+    """
+    Generates the authoring template files by running the `yarn generate:build-authoring-template-files` command.
+    """
+    web_app_dir = path.join(webapp_path, "apps", "web")
+    if not path.exists(web_app_dir):
+        raise ValueError(f"Web app directory not found at {web_app_dir}")
+
+    print(bold("\n📝 Generating authoring template files..."))
+
+    # Run the command to generate the authoring template files
+    subprocess.run(
+        ["yarn", "generate:build-authoring-template-files"],
+        cwd=web_app_dir,
+        check=True,
+    )
+    print(bold(f"\n✨ {green('Authoring template files generated successfully!')}"))
+
+
+def update_template_version(webapp_path: str, runtime_version: str, sdk_version: str):
+    template_path = path.join(
+        webapp_path, "apps", "web", "packagerWorkerAssets", "packagerTemplates", "playwright_v1_python", "default"
+    )
+    pyproject_path = path.join(template_path, "pyproject.toml")
+    if not path.exists(pyproject_path):
+        raise ValueError(f"pyproject.toml not found at {pyproject_path}")
+
+    with open(pyproject_path) as f:
+        pyproject = toml.load(f)
+
+    # Update the runtime and sdk versions
+    pyproject["tool"]["poetry"]["dependencies"]["intuned-runtime"]["tag"] = f"runtime-{runtime_version}"
+    pyproject["tool"]["poetry"]["dependencies"]["intuned-sdk"]["tag"] = f"sdk-{sdk_version}"
+
+    with open(pyproject_path, "w") as f:
+        toml.dump(pyproject, f)
+
+    print(bold(f"\n✨ {green('Updated template versions successfully!')}"))
+
+
+def release_package(
+    *,
+    package_human_name: str,
+    package_name: str,
+    package_source_path: str | None,
+    webapp_path: str,
+    packages_repo_dirname: str,
+    show_diff: bool = False,
+):
+    print(bold(f"🚀 Releasing {green(package_human_name)}"))
+    if not package_source_path:
+        package_source_path_input = input(bold(f" Enter {green(package_human_name)} path:"))
+        package_source_path = package_source_path_input
+    else:
+        print(bold(f" {green(package_human_name)} Source Path"), underline(cyan(path.abspath(package_source_path))))
+    package_version = check_package_version(package_source_path, package_name)
+
+    print(bold(f" Using package version {green(package_version)} to release:"))
+
+    package_repo_path = path.join(webapp_path, "..", "python-packages", packages_repo_dirname)
+    if not path.exists(package_repo_path):
+        raise ValueError(
+            f"Package path does not exist. The {underline("python-packages")} repo is expected to be next to the {underline("WebApp")} (expected package at {underline(path.abspath(package_repo_path))})"
+        )
+
+    package_tag = f"{packages_repo_dirname}-{package_version}"
+
+    # Check if a tag with the sdk_version exists
+    result = subprocess.run(
+        ["git", "tag", "--list", package_tag], capture_output=True, text=True, cwd=package_repo_path
+    )
+    should_delete_tag = False
+    if package_tag in result.stdout.split():
+        raise ValueError(f"Tag {package_version} already exists. Please update the version in the pyproject.toml file.")
+
+    # fetch and pull main branch
+    print(bold("\n📡 Fetching main branch..."))
+    subprocess.run(["git", "fetch", "origin", "main"], cwd=package_repo_path, check=True)
+    print(bold("🔃 Pulling main branch..."))
+    subprocess.run(["git", "reset", "--hard", "origin/main"], cwd=package_repo_path, check=True)
+
+    # switch to main branch
+    print(bold("🔄 Switching to main branch..."))
+    subprocess.run(["git", "checkout", "main"], cwd=package_repo_path, check=True)
+
+    print(bold("📑 Writing source to repo path..."))
+    print(
+        yellow(
+            f"This will delete all files in {underline(path.realpath(package_repo_path))} and copy the source from {underline(path.realpath(package_source_path))}"
+        )
+    )
+    if input("Continue? (y, N) ").lower().strip() != "y":
+        raise ValueError("Publish cancelled")
+
+    # delete all files in the repo path except .git
+    subprocess.run(
+        [
+            "find",
+            package_repo_path,
+            "-mindepth",
+            "1",
+            "-maxdepth",
+            "1",
+            "-not",
+            "-name",
+            ".git",
+            "-exec",
+            "rm",
+            "-rf",
+            "{}",
+            "+",
+        ]
+    )
+    yes_process = subprocess.Popen(["yes"], stdout=subprocess.PIPE)
+    try:
+        subprocess.run(
+            ["cp", "-rf", f"{path.realpath(package_source_path)}/", path.realpath(package_repo_path)],
+            stdin=yes_process.stdout,
+            check=True,
+        )
+    finally:
+        yes_process.kill()
+
+    # Commit and push copied changes to main, force with lease
+    print(bold("\n📄 Committing changes..."))
+    subprocess.run(["git", "add", "."], cwd=package_repo_path, check=True)
+    subprocess.run(
+        ["git", "commit", "--allow-empty", "-m", f"Release {package_human_name} version {package_version}"],
+        cwd=package_repo_path,
+        check=True,
+    )
+
+    try:
+        if show_diff:
+            print(bold("\n🔍 Showing diff..."))
+            print(italic("Close the diff tool to continue. You will be prompted to confirm the release."))
+            subprocess.run(["git", "difftool", "HEAD^", "-t", "vscode", "-y"], cwd=package_repo_path, check=True)
+
+        if input("Push? (y, N) ").lower().strip() != "y":
+            raise ValueError("Publish cancelled")
+
+        print(bold("\n📝 Pushing changes..."))
+        subprocess.run(["git", "push", "origin", "main", "--force-with-lease"], cwd=package_repo_path, check=True)
+
+    except (KeyboardInterrupt, ValueError):
+        print(bold("Resetting commit..."))
+        # drop the current commit and go back to the previous state
+        subprocess.run(["git", "reset", "--hard", "HEAD^"], cwd=package_repo_path, check=True)
+        raise
+
+    # Create a tag with the version to the current HEAD and push it
+    print(bold(f"\n📝 Creating tag {green(package_tag)}..."))
+    if should_delete_tag:
+        subprocess.run(["git", "tag", "-d", package_tag], cwd=package_repo_path, check=True)
+    subprocess.run(["git", "tag", package_tag], cwd=package_repo_path, check=True)
+    subprocess.run(
+        ["git", "push", "origin", package_tag, *(["--force"] if should_delete_tag else [])],
+        cwd=package_repo_path,
+        check=True,
+    )
+
+    print(bold(f"\n✨ {green(package_human_name)} released successfully!\n\n"))
+
+
+def check_package_version(package_path: str, package_expected_name: str):
+    if not path.exists(package_path):
+        raise ValueError("Invalid package path")
+    pyproject_path = path.join(package_path, "pyproject.toml")
+    if not path.exists(pyproject_path):
+        raise ValueError("pyproject.toml not found in package path")
+    with open(pyproject_path) as f:
+        pyproject = toml.load(f)
+    if not pyproject:
+        raise ValueError("Invalid pyproject.toml")
+    if not pyproject.get("tool"):
+        raise ValueError("Invalid pyproject.toml")
+    if not pyproject["tool"].get("poetry"):
+        raise ValueError("Invalid pyproject.toml")
+    if pyproject["tool"]["poetry"].get("name") != package_expected_name:
+        raise ValueError(f"Invalid package name - expected {package_expected_name}")
+    if not pyproject["tool"]["poetry"].get("version"):
+        raise ValueError("Invalid package version")
+    return pyproject["tool"]["poetry"]["version"]

cli/logger.py

@@ -0,0 +1,19 @@
+import logging
+
+
+class SimpleLogger:
+    def __init__(self, enabled: bool = True) -> None:
+        self.enabled: bool = enabled
+        self.logger: logging.Logger = logging.getLogger("simple_logger")
+        self.logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        self.logger.addHandler(handler)
+        self.logger.propagate = False
+
+    def log(self, message: str) -> None:
+        if self.enabled:
+            self.logger.debug(message)
+
+
+default_logger: SimpleLogger = SimpleLogger(enabled=True)

cli/utils/ai_source_project.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Any
+
+from requests import post
+
+from .code_tree import FileSystemTree
+
+
+@dataclass
+class AiSourceInfo:
+    workspace_id: str
+    api_key: str
+    id: str
+    version_id: str
+    environment_url: str | None
+
+    @classmethod
+    def from_json(cls, json_data: dict[str, Any]):
+        return cls(**json_data)
+
+
+def deploy_ai_source(code_tree: FileSystemTree, ai_source_info: AiSourceInfo):
+    result = post(
+        f"{ai_source_info.environment_url}/api/v1/workspace/{ai_source_info.workspace_id}/ai-source/{ai_source_info.id}/version/{ai_source_info.version_id}/deploy",
+        headers={"Content-Type": "application/json", "x-api-key": ai_source_info.api_key},
+        json={"codeTree": code_tree},
+    )
+
+    if not result.ok:
+        print(result.text)
+    return result.ok

cli/utils/code_tree.py

@@ -0,0 +1,83 @@
+import os
+from datetime import datetime
+from typing import Dict
+from typing import Union
+
+from more_termcolor import bold  # type: ignore
+from more_termcolor import cyan  # type: ignore
+from more_termcolor import yellow  # type: ignore
+from pathspec import PathSpec
+from pathspec.patterns.gitwildmatch import GitWildMatchPattern
+from typing_extensions import TypedDict
+
+
+class FileContents(TypedDict):
+    contents: str
+
+
+class FileNode(TypedDict):
+    file: FileContents
+
+
+class DirectoryNode(TypedDict):
+    directory: "FileSystemTree"
+
+
+FileSystemTree = Dict[str, Union[DirectoryNode, FileNode]]
+
+
+def convert_project_to_code_tree(project_path: str, wait_for_confirm: bool = True) -> FileSystemTree:
+    ignore: list[str] | None = None
+    cwd = os.path.normpath(project_path)
+    while ignore is None and cwd != "/":
+        gitignore_path = os.path.join(cwd, ".gitignore")
+        if os.path.exists(gitignore_path):
+            with open(gitignore_path) as gitignore_file:
+                ignore = gitignore_file.read().splitlines()
+                print(f"Found .gitignore file: {bold(cyan(gitignore_path))}")
+        else:
+            cwd = os.path.abspath(os.path.dirname(cwd))
+    if ignore is None:
+        print(yellow(".gitignore file not found. Deploying all files."))
+        ignore = []
+
+    ignore_spec = PathSpec.from_lines(GitWildMatchPattern, ignore)
+
+    files_to_deploy_text = "\n  ".join(["", *ignore_spec.match_tree(project_path, negate=True), ""])
+    print("The following files will be deployed:", files_to_deploy_text)
+    if wait_for_confirm and input("Continue? (y/N): ").lower().strip() != "y":
+        raise ValueError("Deployment cancelled")
+
+    def read_directory(path: str) -> FileSystemTree:
+        tree: FileSystemTree = {}
+        files_or_dirs = os.listdir(path)
+
+        for item in files_or_dirs:
+            item_path = os.path.join(path, item)
+            if ignore_spec.match_file(item_path):
+                continue
+            if os.path.isfile(item_path):
+                try:
+                    with open(item_path) as file:
+                        content = file.read()
+                    tree[item] = {"file": {"contents": content}}
+                except:
+                    pass
+            elif os.path.isdir(item_path):
+                tree[item] = {"directory": read_directory(item_path)}
+        return tree
+
+    tree: FileSystemTree = read_directory(project_path)
+    return tree
+
+
+def get_project_name(path: str):
+    path = os.path.abspath(path)
+    while path != "/":
+        dirname = os.path.basename(path)
+        try:
+            datetime.strptime(dirname, "%Y-%m-%d_%H:%M")
+            path = os.path.dirname(path)
+        except ValueError:
+            return dirname
+    raise ValueError("Could not find project name")

cli/utils/run_apis.py

@@ -0,0 +1,147 @@
+import builtins
+import json
+import os
+import sys
+import traceback
+from collections import Counter
+from functools import wraps
+from typing import Any
+from typing import Literal
+from typing import NotRequired
+from typing import TypedDict
+
+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 italic  # type: ignore
+from more_termcolor import yellow  # type: ignore
+
+from runtime.context.context import IntunedContext
+from runtime.errors.run_api_errors import RunApiError
+from runtime.run import run_api
+from runtime.types import Payload
+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
+
+
+class _RunInput(TypedDict):
+    api: str
+    parameters: dict[str, Any]
+    headless: bool
+
+
+class _RunSuccessOutput(TypedDict):
+    success: Literal[True]
+    result: Any
+    extended_payloads: NotRequired[list[Payload]]
+
+
+class _RunErrorOutput(TypedDict):
+    success: Literal[False]
+    error: list[str]
+
+
+_RunOutput = _RunSuccessOutput | _RunErrorOutput
+
+
+class RunResultData(TypedDict):
+    input: _RunInput
+    output: _RunOutput
+
+
+async def run_api_for_cli(
+    initial_api_to_run: Payload,
+    headless: bool = True,
+    cdp_address: str | None = None,
+    *,
+    auth: Auth | None = None,
+    print_output: bool = True,
+    auth_session_parameters: dict[str, Any] | None = None,
+) -> RunResultData:
+    sys.path.append(os.path.join(os.getcwd()))
+
+    @wraps(builtins.print)
+    def print(*args: ..., **kwargs: ...):
+        if print_output:
+            return builtins.print(*args, **kwargs)
+
+    to_run: Payload | None = initial_api_to_run
+    extended_payloads: list[Payload] = []
+    try:
+        IntunedContext.current().extend_timeout = extend_timeout
+        if auth_session_parameters:
+
+            async def get_auth_session_parameters() -> dict[str, Any]:
+                return auth_session_parameters
+
+            IntunedContext.current().get_auth_session_parameters = get_auth_session_parameters
+        print(bold(f"\n🏃 Running {green(to_run["api"])}"))
+        run_input: _RunInput = {
+            "api": to_run["api"],
+            "parameters": to_run["parameters"],
+            "headless": headless,
+        }
+        try:
+            result = await run_api(
+                RunApiParameters(
+                    automation_function=AutomationFunction(
+                        name=f"api/{to_run["api"]}",
+                        params=to_run["parameters"] or {},
+                    ),
+                    run_options=CDPRunOptions(
+                        cdp_address=cdp_address,
+                    )
+                    if cdp_address is not None
+                    else StandaloneRunOptions(
+                        headless=headless,
+                    ),
+                    auth=auth,
+                ),
+            )
+
+            result_to_print = result.result
+            if result_to_print is None:
+                result_to_print = italic("None")
+            elif result_to_print == "":
+                result_to_print = italic("Empty string")
+            else:
+                result_to_print = bold(str(json.dumps(result_to_print, indent=2)))
+            print(f"{bold("📦 Result: ")}{green(result_to_print)}")
+            extended_payloads = [
+                {"api": p.api_name, "parameters": p.parameters} for p in (result.payload_to_append or [])
+            ]
+            extended_payload_name_counter = Counter([p["api"] for p in extended_payloads])
+            if sum(extended_payload_name_counter.values()) > 0:
+                print(
+                    bold("➕ Extended payloads:"),
+                    ", ".join([f"{cyan(k)}: {v}" for k, v in extended_payload_name_counter.items()]),
+                )
+            _run_output: _RunOutput = {
+                "success": True,
+                "result": result.result,
+                "extended_payloads": extended_payloads,
+            }
+
+        except RunApiError as e:
+            print("❗️", yellow(e))
+            _run_output: _RunOutput = {
+                "success": False,
+                "error": traceback.format_exc().split("\n"),
+            }
+        return {
+            "input": run_input,
+            "output": _run_output,
+        }
+
+    except Exception:
+        traceback.print_exc()
+        raise
+    finally:
+        sys.path.remove(os.path.join(os.getcwd()))
+
+
+async def extend_timeout():
+    print(green(italic("⏱️ Extending timeout")))

cli/utils/unix_socket.py

@@ -0,0 +1,55 @@
+import asyncio
+import json
+import socket
+import struct
+from typing import Any
+
+
+class JSONUnixSocket:
+    LENGTH_HEADER_LENGTH = 4
+
+    def __init__(self, sock: socket.socket):
+        self.socket = sock
+
+    async def send_json(self, data: Any):
+        # Convert data to JSON string and encode to bytes
+        data_to_send = json.dumps(data).encode()
+        # Calculate length
+        length = len(data_to_send)
+        # Pack length as 4-byte big-endian unsigned int
+        length_header = struct.pack(">I", length)
+        # Send length header followed by data
+        return await asyncio.to_thread(self.socket.sendall, length_header + data_to_send)
+
+    async def receive_json(self):
+        buffer = bytearray()
+
+        while True:
+            try:
+                # First, ensure we have the length header
+                while len(buffer) < self.LENGTH_HEADER_LENGTH:
+                    chunk = await asyncio.to_thread(self.socket.recv, 4096)
+                    if not chunk:
+                        return
+                    buffer.extend(chunk)
+
+                # Read the message length
+                length = struct.unpack(">I", buffer[: self.LENGTH_HEADER_LENGTH])[0]
+                total_length = length + self.LENGTH_HEADER_LENGTH
+
+                # Read the full message
+                while len(buffer) < total_length:
+                    chunk = await asyncio.to_thread(self.socket.recv, 4096)
+                    if not chunk:
+                        return
+                    buffer.extend(chunk)
+
+                # Extract the JSON data
+                data = buffer[self.LENGTH_HEADER_LENGTH : total_length]
+                # Remove processed data from buffer
+                buffer = buffer[total_length:]
+                # Parse and yield the JSON data
+                yield json.loads(data.decode())
+
+            except OSError:
+                break