primitive 0.2.46__tar.gz → 0.2.48__tar.gz

{primitive-0.2.46 → primitive-0.2.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: primitive
-Version: 0.2.46
+Version: 0.2.48
 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.2.46 → primitive-0.2.48}/src/primitive/__about__.py

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

{primitive-0.2.46 → primitive-0.2.48}/src/primitive/agent/runner.py

@@ -1,6 +1,5 @@
 import asyncio
 import os
-import re
 import shutil
 import typing
 from enum import Enum, IntEnum
@@ -13,7 +12,6 @@ from loguru import logger
 from primitive.utils.cache import get_artifacts_cache, get_logs_cache, get_sources_cache
 from primitive.utils.logging import fmt, log_context
 from primitive.utils.psutil import kill_process_and_children
-from primitive.utils.shell import env_to_dict
 
 try:
     from yaml import CLoader as Loader
@@ -23,13 +21,7 @@ except ImportError:
 if typing.TYPE_CHECKING:
     import primitive.client
 
-CHUNK_SIZE = 64 * 1024
-ENV_VAR_LOOKUP_START = "_ENV_VAR_LOOKUP_START"
-START_DELIMITER_SIZE = len(bytes(ENV_VAR_LOOKUP_START, encoding="utf-8"))
-ENV_VAR_LOOKUP_END = "_ENV_VAR_LOOKUP_END"
-END_DELIMITER_SIZE = len(bytes(ENV_VAR_LOOKUP_END, encoding="utf-8"))
-
-assert CHUNK_SIZE > START_DELIMITER_SIZE + END_DELIMITER_SIZE
+BUFFER_SIZE = 4096
 
 
 class Task(TypedDict):
@@ -69,7 +61,6 @@ class Runner:
         self.job_run = job_run
         self.job_settings = job_run["jobSettings"]
         self.config = None
-        self.source_dir: Path | None = None
         self.initial_env = {}
         self.modified_env = {}
         self.file_logger = None
@@ -140,6 +131,11 @@ class Runner:
             self.job_run["gitCommit"]["repoFullName"]
         )
 
+        if "VIRTUAL_ENV" in self.initial_env:
+            del self.initial_env["VIRTUAL_ENV"]
+        if "SHELL" in self.initial_env:
+            self.initial_env["SHELL"] = "/bin/bash"
+
     @log_context(label="execute")
     def execute_job_run(self) -> None:
         self.modified_env = {**self.initial_env}
@@ -253,13 +249,11 @@ class Runner:
             # Adding an additional echo and utilizing stdbuf to force line buffering
             # This ensures that the environment variables and starting delimiter are
             # always in a new chunk, vastly simplifying our parsing logic
-            args = [
-                "/bin/bash",
-                "-c",
-                f"{cmd} && echo -n '{ENV_VAR_LOOKUP_START}' && env && echo -n '{ENV_VAR_LOOKUP_END}'",
-            ]
+            args = ["/bin/bash", "-c", cmd]
 
-            logger.info(f"Executing command {i + 1}/{len(commands)}: {cmd}")
+            logger.info(
+                f"Executing command {i + 1}/{len(commands)}: {cmd} at {self.source_dir / task.get('workdir', '')}"
+            )
 
             process = await asyncio.create_subprocess_exec(
                 *args,
@@ -281,13 +275,9 @@ class Runner:
                 kill_process_and_children(pid=process.pid)
                 return False
 
-            stdout_failed, stderr_failed = await asyncio.gather(
-                self.log_cmd(
-                    process=process, stream=process.stdout, tags=task.get("tags", {})
-                ),
-                self.log_cmd(
-                    process=process, stream=process.stderr, tags=task.get("tags", {})
-                ),
+            await asyncio.gather(
+                self.log_cmd(stream=process.stdout, level=LogLevel.INFO),
+                self.log_cmd(stream=process.stderr, level=LogLevel.ERROR),
             )
 
             returncode = await process.wait()
@@ -301,106 +291,26 @@ class Runner:
                     f"Task {task['label']} failed on '{cmd}' with return code {returncode}"
                 )
                 return True
-            elif stdout_failed or stderr_failed:
-                logger.error(f"Task {task['label']} failed on '{cmd}'")
-                return True
 
         logger.success(f"Completed {task['label']} task")
         return False
 
-    async def log_cmd(self, process, stream, tags: Dict = {}) -> bool:
-        failure_detected = False
-        parse_environment = False
-        last_chunk_buffer = b""
-        environment_buffer = b""
-        while chunk := await stream.read(CHUNK_SIZE):
-            if parse_environment:
-                environment_buffer += chunk
-                continue
-
-            # First, look for start delimiter in chunk
-            full_chunk = last_chunk_buffer + chunk
-            last_chunk_buffer = b""
-            start_index = full_chunk.find(bytes(ENV_VAR_LOOKUP_START, encoding="utf-8"))
-
-            if start_index != -1:
-                environment_buffer = full_chunk[start_index + START_DELIMITER_SIZE :]
-                processed_lines = await self.read_chunk(full_chunk[:start_index])
-                parse_environment = True
-            else:
-                processed_lines = await self.read_chunk(full_chunk)
-
-                while (
-                    len(last_chunk_buffer) < START_DELIMITER_SIZE
-                    and len(processed_lines) > 0
-                ):
-                    last_chunk_buffer += bytes(
-                        processed_lines.pop() + "\n", encoding="utf-8"
-                    )
-
-            # Handle logging
-            parse_logs = self.job_settings["parseLogs"]
-            parse_stderr = self.job_settings["parseStderr"]
-
-            for line in processed_lines:
-                level = LogLevel.INFO
-                tag = None
-                if (parse_logs and "error" in line.lower()) or (
-                    parse_stderr and stream is process.stderr
-                ):
-                    level = LogLevel.ERROR
-                elif parse_logs and "warning" in line.lower():
-                    level = LogLevel.WARNING
-
-                # If we already detected a failure, skip checking
-                if not failure_detected:
-                    failure_detected = (
-                        level == LogLevel.ERROR
-                        and self.job_settings["failureLevel"] >= FailureLevel.ERROR
-                    ) or (
-                        level == LogLevel.WARNING
-                        and self.job_settings["failureLevel"] >= FailureLevel.WARNING
-                    )
-
-                # Tag on the first matching regex in the list
-                for tag_key, regex in tags.items():
-                    pattern = re.compile(regex)
-                    if pattern.match(line):
-                        tag = tag_key
-                        break
-
-                logger.bind(tag=tag).log(level.value, line)
-
-        start_index = environment_buffer.find(
-            bytes(ENV_VAR_LOOKUP_END, encoding="utf-8")
-        )
-        if parse_environment and start_index == -1:
-            logger.error("Environment variable buffer did not contain end delimiter")
-            failure_detected = True
-            return failure_detected
-
-        environment_buffer = environment_buffer[:start_index]
-        new_env_vars = env_to_dict(environment_buffer)
-        if len(new_env_vars.keys()) > 0:
-            self.modified_env = {**self.modified_env, **new_env_vars}
-        return failure_detected
-
-    async def read_chunk(self, chunk: bytes) -> List[str]:
-        """Converts a chunk of bytes into proper lines."""
-        lines = []
-        current_line = ""
-        for char in chunk.decode():
-            if char in ("\n", "\r"):
-                lines.append(current_line)
-                current_line = ""
-            else:
-                current_line += char
-
-        # Handle extra characters in the buffer
-        if len(current_line) > 0:
-            lines.append(current_line)
-
-        return [line for line in lines if len(line) > 0]
+    async def log_cmd(
+        self,
+        stream: asyncio.StreamReader | None,
+        level: LogLevel,
+    ):
+        buffer = bytearray()
+        while stream and not stream.at_eof():
+            chunk = await stream.read(BUFFER_SIZE)
+            if not chunk:
+                break
+            buffer += chunk
+            while b"\n" in buffer:
+                line, _, buffer = buffer.partition(b"\n")
+                logger.log(level.value, line.decode(errors="replace"))
+        if buffer:
+            logger.log(level.value, buffer.decode(errors="replace"))
 
     @log_context(label="cleanup")
     def cleanup(self) -> None: