primitive 0.1.39__py3-none-any.whl → 0.1.41__py3-none-any.whl

primitive/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present Dylan Stein <dylan@primitive.tech>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.1.39"
+__version__ = "0.1.41"

primitive/agent/actions.py

@@ -1,18 +1,12 @@
 import sys
 import shutil
-from pathlib import Path
 from time import sleep
 from primitive.utils.actions import BaseAction
 from loguru import logger
 from primitive.__about__ import __version__
-import yaml
-from ..utils.yaml import generate_script_from_yaml
 from ..utils.cache import get_sources_cache
-
-try:
-    from yaml import CLoader as Loader
-except ImportError:
-    from yaml import Loader
+from .runner import AgentRunner
+from .uploader import Uploader
 
 
 class Agent(BaseAction):
@@ -26,6 +20,9 @@ class Agent(BaseAction):
         # Create cache dir if it doesnt exist
         cache_dir = get_sources_cache()
 
+        # Create uploader
+        uploader = Uploader(primitive=self.primitive)
+
         # self.primitive.hardware.update_hardware_system_info()
         try:
             self.primitive.hardware.check_in_http(is_available=True, is_online=True)
@@ -38,6 +35,9 @@ class Agent(BaseAction):
             active_reservation_pk = None
 
             while True:
+                logger.debug("Scanning for files to upload...")
+                uploader.scan()
+
                 hardware = self.primitive.hardware.get_own_hardware_details()
                 if hardware["activeReservation"]:
                     if (
@@ -119,81 +119,15 @@ class Agent(BaseAction):
                         job_run["jobSettings"]["rootDirectory"]
                     )
 
-                    cmd = ("make",)
-                    if containerArgs := job_run["jobSettings"]["containerArgs"]:
-                        cmd = tuple(containerArgs.split(" "))
-
-                    # Load config and generate bash script
-                    yaml_config_path = Path(source_dir / "primitive.yaml")
-                    run_script_path = None
-                    if yaml_config_path.exists() and yaml_config_path.is_file():
-                        yaml_config = yaml.load(
-                            open(yaml_config_path, "r"), Loader=Loader
-                        )
+                    runner = AgentRunner(
+                        self.primitive,
+                        source_dir=source_dir,
+                        job_id=job_run["id"],
+                        job_slug=job_run["job"]["slug"],
+                    )
 
-                        job_slug = job_run["job"]["slug"]
-                        if job_slug in yaml_config:
-                            run_script_path = generate_script_from_yaml(
-                                yaml_config,
-                                slug=job_slug,
-                                destination=source_dir,
-                            )
-                            cmd = (
-                                "/bin/bash",
-                                str(run_script_path.resolve()),
-                            )
-
-                    match job_run["job"]["slug"]:
-                        case "lint":
-                            logger.debug("Executing Lint Job")
-
-                            self.primitive.jobs.job_run_update(
-                                job_run["id"], status="request_in_progress"
-                            )
-
-                            result, message = self.primitive.lint.execute(
-                                source=source_dir
-                            )
-                            if result:
-                                conclusion = "success"
-                            else:
-                                conclusion = "failure"
-                            self.primitive.jobs.job_run_update(
-                                job_run["id"],
-                                status="request_completed",
-                                conclusion=conclusion,
-                                stdout=message,
-                            )
-
-                            logger.debug("Lint Job Completed")
-                        case "sim":
-                            logger.debug("Executing Sim Job")
-
-                            self.primitive.jobs.job_run_update(
-                                job_run["id"], status="request_in_progress"
-                            )
-
-                            result, message = self.primitive.sim.execute(
-                                source=source_dir, cmd=cmd
-                            )
-
-                            # Attempt artifact collection
-                            self.primitive.sim.collect_artifacts(
-                                source=source_dir, job_run_id=job_run["id"]
-                            )
-
-                            if result:
-                                conclusion = "success"
-                            else:
-                                conclusion = "failure"
-                            self.primitive.jobs.job_run_update(
-                                job_run["id"],
-                                status="request_completed",
-                                conclusion=conclusion,
-                                stdout=message,
-                            )
-
-                            logger.debug("Sim Job Completed")
+                    # Execute job
+                    runner.execute()
 
                     # Clean up
                     shutil.rmtree(path=downloaded_git_repository_dir)

primitive/agent/process.py

@@ -0,0 +1,84 @@
+from subprocess import Popen, PIPE
+import threading
+import shlex
+from loguru import logger
+
+
+class Process:
+    def __init__(
+        self,
+        cmd,
+        workdir: str = ".",
+    ):
+        self.cmd = shlex.split(cmd)
+        self.workdir = workdir
+        self.process = None
+        self.stdout_thread = None
+        self.stderr_thread = None
+        self._errors = 0
+
+    def start(self):
+        # Start the process
+        self.process = Popen(
+            self.cmd, cwd=self.workdir, stdout=PIPE, stderr=PIPE, text=True
+        )
+
+        # Function to read and log output from a pipe
+        def log_output(pipe, level):
+            for line in iter(pipe.readline, ""):
+                if line:
+                    logger.log(level, line.rstrip())
+                    if level == "ERROR":
+                        self._errors += 1
+
+            pipe.close()
+
+        # Create threads for stdout and stderr
+        self.stdout_thread = threading.Thread(
+            target=log_output, args=(self.process.stdout, "INFO")
+        )
+        self.stderr_thread = threading.Thread(
+            target=log_output, args=(self.process.stderr, "ERROR")
+        )
+
+        # Start the threads
+        self.stdout_thread.start()
+        self.stderr_thread.start()
+
+    def wait(self):
+        if self.process:
+            # Wait for the process to complete
+            self.process.wait()
+            # Wait for the threads to finish reading output
+            self.stdout_thread.join()
+            self.stderr_thread.join()
+
+    def run(self):
+        """Start and wait for the process."""
+        self.start()
+        self.wait()
+
+    def is_running(self):
+        """Check if the process is still running."""
+        return self.process and self.process.poll() is None
+
+    def finish(self):
+        """Make sure that logging finishes"""
+        self.stderr_thread.join()
+        self.stderr_thread.join()
+
+        return self.process.poll()
+
+    def terminate(self):
+        """Terminate the process."""
+        if self.process:
+            self.process.terminate()
+
+    def kill(self):
+        """Kill the process."""
+        if self.process:
+            self.process.kill()
+
+    @property
+    def errors(self) -> int:
+        return self._errors

primitive/agent/runner.py

@@ -0,0 +1,160 @@
+import yaml
+import sys
+import typing
+from time import sleep
+from typing import TypedDict, Iterable, List
+from pathlib import Path, PurePath
+from loguru import logger
+from .process import Process
+from ..utils.cache import get_artifacts_cache
+from ..utils.files import find_files_for_extension
+
+try:
+    from yaml import CLoader as Loader
+except ImportError:
+    from yaml import Loader
+
+if typing.TYPE_CHECKING:
+    import primitive.client
+
+
+class Artifact(TypedDict):
+    name: str
+    extension: str
+
+
+class JobStep(TypedDict):
+    name: str
+    workdir: str
+    artifacts: List[Artifact]
+    cmd: str
+
+
+class JobDescription(TypedDict):
+    name: str
+    steps: List[JobStep]
+
+
+class AgentRunner:
+    def __init__(
+        self,
+        primitive: "primitive.client.Primitive",
+        source_dir: Path,
+        job_id: str,
+        job_slug: str,
+        max_log_size: int = 10 * 1024 * 1024,
+    ) -> None:
+        self.primitive = primitive
+        self.source_dir = source_dir
+        self.job_id = job_id
+        self.job_slug = job_slug
+        self.max_log_size = max_log_size
+        self.artifacts_dir = get_artifacts_cache(self.job_id)
+
+        logger.enable("primitive")
+        self.logger_handle = logger.add(
+            Path(self.artifacts_dir / "runner_{time}.log"),
+            rotation=self.max_log_size,  # Rotate when the log file reaches 10MB
+        )
+
+        logger.info(f"Scanning directory for job {self.job_slug}")
+
+        # Look for job based on slug
+        yaml_file = Path(self.source_dir / ".primitive" / f"{self.job_slug}.yaml")
+        yml_file = Path(self.source_dir / ".primitive" / f"{self.job_slug}.yml")
+
+        if yaml_file.exists() and yml_file.exists():
+            logger.error(
+                f"Found two job descriptions with the same slug: {self.job_slug}"
+            )
+            sys.exit(1)
+
+        if yaml_file.exists():
+            self.job = yaml.load(open(yaml_file, "r"), Loader=Loader)
+        elif yml_file.exists():
+            self.job = yaml.load(open(yml_file, "r"), Loader=Loader)
+        else:
+            logger.error(
+                f"No job description with matching slug '{self.job_slug}' found"
+            )
+            sys.exit(1)
+
+        logger.info(f"Found job description for {self.job_slug}")
+
+    def name(self) -> str:
+        return self.job["name"]
+
+    def steps(self) -> Iterable[JobStep]:
+        for step in self.job["steps"]:
+            yield step
+
+    def execute(self) -> None:
+        logger.info(f"Executing {self.job_slug} job")
+        self.primitive.jobs.job_run_update(self.job_id, status="request_in_progress")
+
+        conclusion = None
+        total_errors = 0
+        for step in self.steps():
+            logger.info(f"Beginning step {step["name"]}")
+
+            # Define step proc
+            proc = Process(step["cmd"], workdir=Path(self.source_dir / step["workdir"]))
+
+            # Try to start
+            try:
+                proc.start()
+            except Exception as e:
+                logger.error(f"Error while attempting to run command {e}")
+                conclusion = "failure"
+                break
+
+            # Check for updates to status while running
+            while proc.is_running():
+                status = self.primitive.jobs.get_job_status(self.job_id)
+
+                logger.info(f"Step status: {status}")
+
+                sleep(5)
+
+            result = proc.finish()
+            total_errors += proc.errors
+
+            # Collect artifacts
+            self.collect_artifacts(step)
+
+            # Check if we have a good result
+            if not result:
+                conclusion = "failure"
+                break
+
+        if not conclusion and total_errors == 0:
+            conclusion = "success"
+        else:
+            conclusion = "failure"
+
+        self.primitive.jobs.job_run_update(
+            self.job_id, status="request_completed", conclusion=conclusion
+        )
+
+        logger.info(f"Completed {self.job_slug} job")
+        logger.remove(self.logger_handle)
+
+    def collect_artifacts(self, step: JobStep) -> None:
+        # str(PurePath(file_path).relative_to(Path(source))
+
+        # Search each artifact type
+        for artifact in step["artifacts"]:
+            files = find_files_for_extension(self.source_dir, artifact["extension"])
+
+            for file in files:
+                # Find path relative to source_dir
+                relative_path = PurePath(file).relative_to(self.source_dir)
+
+                # Construct destination to preserve directory structure
+                destination = Path(self.artifacts_dir / relative_path)
+
+                # Create directories if they don't exist
+                destination.parent.mkdir(parents=True, exist_ok=True)
+
+                # Move file
+                file.rename(destination)

primitive/agent/uploader.py

@@ -0,0 +1,46 @@
+import typing
+import shutil
+from pathlib import Path, PurePath
+from ..utils.cache import get_artifacts_cache
+
+if typing.TYPE_CHECKING:
+    import primitive.client
+
+
+class Uploader:
+    def __init__(
+        self,
+        primitive: "primitive.client.Primitive",
+    ):
+        self.primitive = primitive
+
+    def upload_file(self, path: Path, prefix: str) -> str:
+        file_upload_response = self.primitive.files.file_upload(path, key_prefix=prefix)
+        return file_upload_response.json()["data"]["fileUpload"]["id"]
+
+    def scan(self) -> None:
+        # Scan artifacts directory
+        artifacts_dir = get_artifacts_cache()
+
+        subdirs = [
+            job_cache for job_cache in artifacts_dir.iterdir() if job_cache.is_dir()
+        ]
+
+        for job_cache in subdirs:
+            job_run_id = job_cache.name
+            files = [file for file in job_cache.rglob("*") if file.is_file()]
+
+            file_ids = []
+            for file in files:
+                file_ids.append(
+                    self.upload_file(
+                        file,
+                        prefix=str(PurePath(file).relative_to(job_cache.parent).parent),
+                    )
+                )
+
+            # Update job run
+            self.primitive.jobs.job_run_update(id=job_run_id, file_ids=file_ids)
+
+            # Clean up job cache
+            shutil.rmtree(path=job_cache)

primitive/auth/actions.py

@@ -1,12 +1,13 @@
 from gql import gql
 
 from ..utils.config import read_config_file, update_config_file
-
+from ..utils.auth import guard
 
 from primitive.utils.actions import BaseAction
 
 
 class Auth(BaseAction):
+    @guard
     def whoami(self):
         query = gql(
             """

primitive/client.py

@@ -1,7 +1,6 @@
 import sys
 from .auth.actions import Auth
 from .projects.actions import Projects
-from .graphql.sdk import create_session
 from .utils.config import read_config_file
 from .files.actions import Files
 from .sim.actions import Sim
@@ -28,6 +27,7 @@ class Primitive:
         transport: str = None,
     ) -> None:
         self.host = host
+        self.session = None
         self.DEBUG = DEBUG
         self.JSON = JSON
 
@@ -42,20 +42,16 @@ class Primitive:
                 diagnose=True,
             )
 
-        host = self.host
-        fingerprint = None
+        # Generate full or partial host config
         if not token and not transport:
-            self.get_host_config()
-            token = self.host_config.get("token")
-            transport = self.host_config.get("transport")
-            fingerprint = self.host_config.get("fingerprint")
+            # Attempt to build host config from file
+            try:
+                self.get_host_config()
+            except KeyError:
+                self.host_config = {}
         else:
             self.host_config = {"username": "", "token": token, "transport": transport}
 
-        self.session = create_session(
-            host=self.host, token=token, transport=transport, fingerprint=fingerprint
-        )
-
         self.auth: Auth = Auth(self)
         self.organizations: Organizations = Organizations(self)
         self.projects: Projects = Projects(self)

primitive/files/actions.py

@@ -1,12 +1,13 @@
 from pathlib import Path
 from gql import gql
 from primitive.graphql.sdk import create_requests_session
-
+from ..utils.auth import guard
 
 from primitive.utils.actions import BaseAction
 
 
 class Files(BaseAction):
+    @guard
     def trace_create(
         self,
         file_id: str,
@@ -41,6 +42,7 @@ class Files(BaseAction):
         result = self.primitive.session.execute(mutation, variable_values=variables)
         return result
 
+    @guard
     def file_upload(self, path: Path, is_public: bool = False, key_prefix: str = ""):
         file_path = str(path.resolve())
         if path.exists() is False:

primitive/git/actions.py

@@ -1,10 +1,12 @@
 from pathlib import Path
 from primitive.utils.actions import BaseAction
+from ..utils.auth import guard
 from loguru import logger
 import os
 
 
 class Git(BaseAction):
+    @guard
     def get_github_access_token(self) -> str:
         query = """
 query githubAppToken{

primitive/hardware/actions.py

@@ -11,6 +11,7 @@ from primitive.utils.memory_size import MemorySize
 from gql import gql
 from aiohttp import client_exceptions
 from ..utils.config import update_config_file
+from ..utils.auth import guard
 
 import typing
 
@@ -265,6 +266,7 @@ class Hardware(BaseAction):
         system_info["gpu_config"] = self._get_gpu_config()
         return system_info
 
+    @guard
     def register(self):
         system_info = self.get_system_info()
         mutation = gql(
@@ -310,6 +312,7 @@ class Hardware(BaseAction):
         self.check_in_http(is_healthy=True)
         return True
 
+    @guard
     def update_hardware_system_info(self):
         """
         Updates hardware system information and returns the GraphQL response.
@@ -366,6 +369,7 @@ class Hardware(BaseAction):
 
         return result
 
+    @guard
     def check_in_http(
         self,
         is_healthy: bool = True,
@@ -454,6 +458,7 @@ class Hardware(BaseAction):
             logger.error(message)
             raise exception
 
+    @guard
     def get_hardware_list(self, fingerprint: Optional[str] = None):
         query = gql(
             """

primitive/jobs/actions.py

@@ -3,9 +3,11 @@ from gql import gql
 
 
 from primitive.utils.actions import BaseAction
+from ..utils.auth import guard
 
 
 class Jobs(BaseAction):
+    @guard
     def get_jobs(
         self,
         organization_id: Optional[str] = None,
@@ -117,7 +119,6 @@ fragment JobRunFragment on JobRun {
   startedAt
   status
   conclusion
-  stdout
   job {
     id
     pk
@@ -196,6 +197,7 @@ query jobRuns(
         result = self.primitive.session.execute(query, variable_values=variables)
         return result
 
+    @guard
     def get_job_run(self, id: str):
         query = gql(
             """
@@ -208,7 +210,6 @@ query jobRuns(
                 startedAt
                 status
                 conclusion
-                stdout
                 job {
                     id
                     pk
@@ -239,12 +240,12 @@ query jobRuns(
         result = self.primitive.session.execute(query, variable_values=variables)
         return result
 
+    @guard
     def job_run_update(
         self,
         id: str,
         status: str = None,
         conclusion: str = None,
-        stdout: str = None,
         file_ids: Optional[List[str]] = [],
     ):
         mutation = gql(
@@ -267,12 +268,11 @@ query jobRuns(
             input["conclusion"] = conclusion
         if file_ids and len(file_ids) > 0:
             input["files"] = file_ids
-        if stdout:
-            input["stdout"] = stdout
         variables = {"input": input}
         result = self.primitive.session.execute(mutation, variable_values=variables)
         return result
 
+    @guard
     def github_access_token_for_job_run(self, job_run_id: str):
         query = gql(
             """
@@ -309,3 +309,23 @@ query ghAppTokenForJobRun($jobRunId: GlobalID!) {
             raise ValueError("job_slug or job_id is required")
 
         self.get_jobs(slug=job_slug)
+
+    @guard
+    def get_job_status(self, id: str):
+        query = gql(
+            """
+            fragment JobRunFragment on JobRun {
+                id
+                status
+            }
+
+            query jobRun($id: GlobalID!) {
+                jobRun(id: $id) {
+                    ...JobRunFragment
+                }
+            }
+            """
+        )
+        variables = {"id": id}
+        result = self.primitive.session.execute(query, variable_values=variables)
+        return result

primitive/organizations/actions.py

@@ -3,9 +3,11 @@ from gql import gql
 
 
 from primitive.utils.actions import BaseAction
+from ..utils.auth import guard
 
 
 class Organizations(BaseAction):
+    @guard
     def get_organizations(
         self,
         organization_id: Optional[str] = None,

primitive/projects/actions.py

@@ -2,9 +2,11 @@ from gql import gql
 
 from typing import Optional
 from primitive.utils.actions import BaseAction
+from ..utils.auth import guard
 
 
 class Projects(BaseAction):
+    @guard
     def get_projects(
         self,
         organization_id: Optional[str] = None,

primitive/utils/auth.py

@@ -0,0 +1,27 @@
+from ..graphql.sdk import create_session
+import sys
+
+
+def guard(func):
+    def wrapper(self, *args, **kwargs):
+        if self.primitive.session is None:
+            token = self.primitive.host_config.get("token")
+            transport = self.primitive.host_config.get("transport")
+            fingerprint = self.primitive.host_config.get("fingerprint")
+
+            if not token or not transport:
+                print(
+                    "CLI is not configured. Run primitive config to add an auth token."
+                )
+                sys.exit(1)
+
+            self.primitive.session = create_session(
+                host=self.primitive.host,
+                token=token,
+                transport=transport,
+                fingerprint=fingerprint,
+            )
+
+        return func(self, *args, **kwargs)
+
+    return wrapper

primitive/utils/cache.py

@@ -30,6 +30,20 @@ def get_sources_cache() -> Path:
     return sources_dir
 
 
+def get_artifacts_cache(cache_id: str = None) -> Path:
+    cache_dir = get_cache_dir()
+
+    artifacts_dir = cache_dir / "artifacts"
+
+    if cache_id:
+        artifacts_dir = artifacts_dir / cache_id
+
+    if not artifacts_dir.exists():
+        artifacts_dir.mkdir(parents=True, exist_ok=True)
+
+    return artifacts_dir
+
+
 def get_deps_cache() -> Path:
     cache_dir = get_cache_dir()
 

{primitive-0.1.39.dist-info → primitive-0.1.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: primitive
-Version: 0.1.39
+Version: 0.1.41
 Project-URL: Documentation, https://github.com//primitivecorp/primitive-cli#readme
 Project-URL: Issues, https://github.com//primitivecorp/primitive-cli/issues
 Project-URL: Source, https://github.com//primitivecorp/primitive-cli

{primitive-0.1.39.dist-info → primitive-0.1.41.dist-info}/RECORD

@@ -1,39 +1,43 @@
-primitive/__about__.py,sha256=_BMdl-E4C928TL5DMNPwXGZXZshwzVn9FoCKsCYkjoM,130
+primitive/__about__.py,sha256=PsY-PpGOI_DmkKtzrfzfMfczkk5f26JZN38IjwLvkE8,130
 primitive/__init__.py,sha256=bwKdgggKNVssJFVPfKSxqFMz4IxSr54WWbmiZqTMPNI,106
 primitive/cli.py,sha256=VQPSewC6ouGdEG9W1gllawGJTydpOY0Lzg7LURXcqQg,2374
-primitive/client.py,sha256=SFPG4H2wJao8euGdnYp-l7dk_fDpWeVn2aT2WNJUAqo,2370
-primitive/agent/actions.py,sha256=cxavCfRG76KJ6M-FVwg3htMbJLz16gUjy30h-vsJ7A0,8468
+primitive/client.py,sha256=vSJkifx450czuLvu0f2o-viSCC0p2f1UicA-2P5cJAw,2188
+primitive/agent/actions.py,sha256=d_garPm3rl5uMEu-g681yMYEnBqfUDeEPeeKl_VEd64,5489
 primitive/agent/commands.py,sha256=-dVDilELfkGfbZB7qfEPs77Dm1oT62qJj4tsIk4KoxI,254
+primitive/agent/process.py,sha256=hYjjZL1DoUUVDJmORewYfLhWptLX_4e47DVW1i0PrKw,2252
+primitive/agent/runner.py,sha256=w_HlIUTIwRsXJCsZT4u5P5XsapXRn8hLOQ1SAGSQzFw,4797
+primitive/agent/uploader.py,sha256=ngbynmQzxKVNMp7VWkTWW7vZIN_rnnRzYC6OAL21n1k,1378
 primitive/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/auth/actions.py,sha256=N2bGcwXNsB89pzs66gF9A5_WzUScY5fhfOyWixqo2y8,1054
+primitive/auth/actions.py,sha256=2vZEC3LLAXj6eBBmt_2OEDEcBIb3uLkkNjgbZTIaQsY,1095
 primitive/auth/commands.py,sha256=JahUq0E2e7Xa-FX1WEUv7TgM6ieDvNH4VwRRtxAW7HE,2340
 primitive/daemons/actions.py,sha256=Nt3yNtbBhen0jK4sRsH_N7AP3UBuyL48VaUhtC7wYq8,2015
 primitive/daemons/commands.py,sha256=-Muh-6ib4uAVtPn_67AcMrDwuCwYlCnRQozCi2Xurmk,1726
 primitive/daemons/launch_agents.py,sha256=qovt32gwpjGDd82z_SY5EGCUjaUyNA49pZFajZsw3eE,4796
 primitive/daemons/launch_service.py,sha256=FPB9qKEjhllRfEpct0ng2L9lpIaGJbQwn1JdFT8uBA8,5600
-primitive/files/actions.py,sha256=f4JN3QFB2WXw-0JpnE-4-movnqtvXIpCrGd_9pdkeW4,2624
+primitive/files/actions.py,sha256=2X1_rq8A7X1Nf0q9xyAI9ziMkow_VKARPfdnsAoZh9w,2676
 primitive/files/commands.py,sha256=DDizo3xJnU3KLUBTMeeM72viVpnJinLwxs84tmqKhqo,810
 primitive/git/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/git/actions.py,sha256=fepcl5529w_hsaC6fBw9f-QHeyqNjGXz8HI5ebzbZMs,1386
+primitive/git/actions.py,sha256=OTuGRXfjop9u1LtNaBen87mEU6ROeoa_MDgBbB2l6ig,1428
 primitive/git/commands.py,sha256=64B2STTOn0dwVDmJHqEwekmIqKMfSyBBFwKg29Wt8Aw,1230
 primitive/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/graphql/sdk.py,sha256=BhCGmDtc4sNnH8CxbQSJyFwOZ-ZSqMtjsxMB3JRBhPw,1456
-primitive/hardware/actions.py,sha256=JJXEeW35QzVGcLN4ym5gYZwY71hxLzM1GYPXWaObEts,18893
+primitive/hardware/actions.py,sha256=QwVElFCrGbA27qagapHRxVpf0vkpKu6bNcqCQyYpQkY,18968
 primitive/hardware/commands.py,sha256=QE7LLeFdfOqlvz3JwdwJJRZAY3fHI1zB9kYmmDajpq0,1477
-primitive/jobs/actions.py,sha256=LpUJN-GOiDSehQANfV_F86eRRKPZ2ew9skKdnlalXU4,7734
+primitive/jobs/actions.py,sha256=xg5-ALJEAtculnUIp-avYYJ5hONkl9fWFL83orAs6IQ,8194
 primitive/jobs/commands.py,sha256=MxPCkBEYW_eLNqgCRYeyj7ZcLOFAWfpVZlqDR2Y_S0o,830
 primitive/lint/actions.py,sha256=tWsrht1dowGprcZjEUtjCJzozEQmh9sv2_C2__YHIOI,2825
 primitive/lint/commands.py,sha256=3CZvkOEMpJspJWmaQzA5bpPKx0_VCijQIXA9l-eTnZE,487
-primitive/organizations/actions.py,sha256=e0V4E1UK1IcBJsWWH6alHYUmArhzPrBqZ8WkHPIcLq0,2268
+primitive/organizations/actions.py,sha256=fNVR0qx9opzMpzGn6lHBy5BqLhIwid1ZepxdtpelZwo,2310
 primitive/organizations/commands.py,sha256=_dwgVEJCqMa5VgB_7P1wLPFc0AuT1p9dtyR9JRr4kpw,487
 primitive/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/projects/actions.py,sha256=xhebDUMN9DXWvngWJyJkiijghbZwffy-JIPSsOg8agE,2061
+primitive/projects/actions.py,sha256=wkQRMbMWRca0wnMKv6Cqh4t6BRCwIorS5ZpS7rMlSbU,2103
 primitive/projects/commands.py,sha256=Fqqgpi4cm6zOgkHK--0F0hiiIj32BmgZ-h1MydmWwdE,464
 primitive/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/sim/actions.py,sha256=MkhiAH5QvF2jbnpgWL29HeSrTYiSW0UJpql2wZ4q18w,4900
 primitive/sim/commands.py,sha256=8PaOfL1MO6qxTn7mNVRnBU1X2wa3gk_mlbAhBW6MnI0,591
 primitive/utils/actions.py,sha256=HOFrmM3-0A_A3NS84MqrZ6JmQEiiPSoDqEeuu6b_qfQ,196
-primitive/utils/cache.py,sha256=rzMhqDnP8QIzRidF7iyYA5rBGRLEu0tjX0POX0E1xFw,975
+primitive/utils/auth.py,sha256=TtJKTR6tLmNrtWbOjJI-KJh4ZSJ1uG7ApE9GcY63m00,836
+primitive/utils/cache.py,sha256=hDVpEL2TePrWOH6q7Me_Oi-DH_viFrRxrVta-z4wBhM,1295
 primitive/utils/config.py,sha256=DlFM5Nglo22WPtbpZSVtH7NX-PTMaKYlcrUE7GPRG4c,1058
 primitive/utils/files.py,sha256=Yv__bQes3YIlzhOT9kVxtYhoA5CmUjPSvphl9PZ41k4,867
 primitive/utils/git.py,sha256=1qNOu8X-33CavmrD580BmrFhD_WVO9PGWHUUboXJR_g,663
@@ -41,9 +45,8 @@ primitive/utils/memory_size.py,sha256=4xfha21kW82nFvOTtDFx9Jk2ZQoEhkfXii-PGNTpIU
 primitive/utils/printer.py,sha256=f1XUpqi5dkTL3GWvYRUGlSwtj2IxU1q745T4Fxo7Tn4,370
 primitive/utils/shell.py,sha256=-7UjQaBqSGHzEEyX8pNjeYFFP0P3lVnDV0OkgPz1qHU,1050
 primitive/utils/verible.py,sha256=r7c_hfqvL0UicMmIzK3Cy_BfZI1ZpcfBeLqKEWFWqJo,2252
-primitive/utils/yaml.py,sha256=4UP_9MXHoNb9_SCeUDm9xqYg9sHltqpVhNgsY6GNfb8,527
-primitive-0.1.39.dist-info/METADATA,sha256=kANNdscAcTCkcY2ZAAnLS-ovI3wQwUhAEIvUZu9gYtc,3782
-primitive-0.1.39.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-primitive-0.1.39.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
-primitive-0.1.39.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
-primitive-0.1.39.dist-info/RECORD,,
+primitive-0.1.41.dist-info/METADATA,sha256=GKvfSp-prhQ5_ZpKOR2_NOcBy587P_PdJLGUVi8N89U,3782
+primitive-0.1.41.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+primitive-0.1.41.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
+primitive-0.1.41.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
+primitive-0.1.41.dist-info/RECORD,,

primitive/utils/yaml.py

@@ -1,23 +0,0 @@
-from pathlib import Path
-
-
-def generate_script_from_yaml(yaml_config: dict, slug: str, destination: Path) -> None:
-    commands_blocks = []
-    if steps := yaml_config[slug]["steps"]:
-        for step in steps:
-            commands_blocks.append(step["run"])
-
-    script = f"""
-#!/bin/bash
-
-{"".join(commands_blocks)}
-    """
-
-    output_path = Path(destination / "run.sh")
-    with open(output_path, "w") as f:
-        f.write(script)
-
-    # Apply execute file permissions
-    output_path.chmod(0o744)
-
-    return output_path