marin-shellbox 0.2.152.dev37849924057__tar.gz → 0.2.153.dev37866254792__tar.gz

{marin_shellbox-0.2.152.dev37849924057 → marin_shellbox-0.2.153.dev37866254792}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: marin-shellbox
-Version: 0.2.152.dev37849924057
+Version: 0.2.153.dev37866254792
 Summary: Shell execution machines with local and remote backends
 Requires-Python: >=3.12
 Requires-Dist: bubblewrap-bin==0.11.0; sys_platform == 'linux'
@@ -10,7 +10,7 @@ Requires-Dist: daytona==0.200.2; extra == 'daytona'
 Requires-Dist: marin-rigging>=0.2.0; extra == 'daytona'
 Provides-Extra: gvisor
 Provides-Extra: iris
-Requires-Dist: marin-iris==0.2.152.dev37849924057; extra == 'iris'
+Requires-Dist: marin-iris==0.2.153.dev37866254792; extra == 'iris'
 Provides-Extra: qemu
 Requires-Dist: quicksand-qemu<0.6,>=0.5.12; extra == 'qemu'
 Provides-Extra: shellsim

{marin_shellbox-0.2.152.dev37849924057 → marin_shellbox-0.2.153.dev37866254792}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "marin-shellbox"
-version = "0.2.152.dev37849924057"
+version = "0.2.153.dev37866254792"
 description = "Shell execution machines with local and remote backends"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -16,7 +16,7 @@ shellsim = ["shellsim>=0.1.29,<0.2", "marin-rigging>=0.2.0"]
 gvisor = []
 daytona = ["daytona==0.200.2", "marin-rigging>=0.2.0"]
 iris = [
-    "marin-iris==0.2.152.dev37849924057",
+    "marin-iris==0.2.153.dev37866254792",
 ]
 
 [project.scripts]

{marin_shellbox-0.2.152.dev37849924057 → marin_shellbox-0.2.153.dev37866254792}/src/shellbox/backends/shellsim/machine.py

@@ -31,6 +31,7 @@ DEFAULT_CPU_LIMIT = 10_000_000_000
 DEFAULT_DISK_LIMIT = 256 * 1024 * 1024
 DEFAULT_OUTPUT_LIMIT = 128 * 1024 * 1024
 DEFAULT_MEMORY_MB = 256
+SIMULATOR_PANIC_EXIT_CODE = 1
 ENV_NAME = re.compile(r"[A-Za-z_][A-Za-z0-9_]*\Z")
 
 
@@ -45,7 +46,16 @@ class ShellSimShellSession:
     async def execute(
         self, command: str, *, wait: float = 120, output_limit_bytes: int = DEFAULT_MACHINE_OUTPUT_LIMIT_BYTES
     ) -> ShellUpdate:
-        result = await self.machine._run_source(command)
+        try:
+            result = await self.machine._run_source(command)
+        except shellsim.SimulationError as error:
+            output = str(error).encode()
+            return ShellUpdate(
+                output[:output_limit_bytes],
+                ShellStatus.COMPLETED,
+                SIMULATOR_PANIC_EXIT_CODE,
+                len(output) > output_limit_bytes,
+            )
         output = result.stdout + result.stderr
         return ShellUpdate(
             output[:output_limit_bytes],
@@ -123,6 +133,17 @@ class ShellSimMachine:
         except TimeoutError:
             self._closed = True
             return Result(None, b"", b"", False, False, ExitReason.TIMED_OUT)
+        except shellsim.SimulationError as error:
+            stderr = str(error).encode()
+            limit = command.output_limit_bytes
+            return Result(
+                SIMULATOR_PANIC_EXIT_CODE,
+                b"",
+                stderr[:limit],
+                False,
+                len(stderr) > limit,
+                ExitReason.EXITED,
+            )
         limit = command.output_limit_bytes
         return Result(
             result.returncode,

marin_shellbox-0.2.153.dev37866254792/tests/test_shellsim_machine.py

@@ -0,0 +1,106 @@
+# Copyright The Marin Authors
+# SPDX-License-Identifier: Apache-2.0
+
+"""Behavior checks for the simulated shell and verifier boundary."""
+
+import asyncio
+from pathlib import Path
+
+from shellbox.backends.shellsim.machine import ShellSimMachineFactory
+from shellbox.machine import Command, ExitReason, MachineSpec, ShellSimBuiltins, ShellStatus
+
+PANIC_COMMAND = "cat /workspace/numbers.txt | python3 -c 'import sys; print(sum(int(line) for line in sys.stdin))'"
+PANIC_OUTPUT_LIMIT_BYTES = 64
+
+
+def test_shell_state_and_one_shot_command() -> None:
+    async def check() -> None:
+        machine = await ShellSimMachineFactory().create(MachineSpec(ShellSimBuiltins()))
+        try:
+            shell = await machine.open_shell()
+            first = await shell.execute(
+                'cd /tmp; export ANSWER=hello; answer() { echo "$ANSWER"; }; echo file >/workspace/result'
+            )
+            assert first.status is ShellStatus.COMPLETED
+            second = await shell.execute("pwd; answer")
+            assert second.output == b"/tmp\nhello\n"
+
+            verifier = await machine.run(Command(("sh", "-c", "pwd; cat /workspace/result")))
+            assert verifier.stdout == b"/workspace\nfile\n"
+            after = await shell.execute("pwd; answer")
+            assert after.output == b"/tmp\nhello\n"
+        finally:
+            await machine.close()
+
+    asyncio.run(check())
+
+
+def test_file_transfer_and_bounded_output(tmp_path: Path) -> None:
+    async def check() -> None:
+        machine = await ShellSimMachineFactory().create(MachineSpec(ShellSimBuiltins()))
+        try:
+            source = tmp_path / "source"
+            source.mkdir()
+            (source / "data.txt").write_text("payload")
+            await machine.upload(source, "/workspace/imported")
+            shell = await machine.open_shell()
+            result = await shell.execute("cat /workspace/imported/data.txt; printf 'x'", output_limit_bytes=4)
+            assert result.output == b"payl"
+            assert result.truncated
+
+            target = tmp_path / "downloaded"
+            target.mkdir()
+            await machine.download("/workspace/imported", target)
+            assert (target / "data.txt").read_text() == "payload"
+        finally:
+            await machine.close()
+
+    asyncio.run(check())
+
+
+def test_run_simulator_panic_returns_failed_result(tmp_path: Path) -> None:
+    async def check() -> None:
+        machine = await ShellSimMachineFactory().create(MachineSpec(ShellSimBuiltins()))
+        try:
+            source = tmp_path / "numbers.txt"
+            source.write_text("1\n2\n")
+            await machine.upload(source, "/workspace/numbers.txt")
+
+            result = await machine.run(Command(("sh", "-c", PANIC_COMMAND), output_limit_bytes=PANIC_OUTPUT_LIMIT_BYTES))
+            assert result.reason is ExitReason.EXITED
+            assert result.exit_code == 1
+            assert result.stdout == b""
+            assert result.stderr.startswith(b"shellsim operation panicked")
+            assert len(result.stderr) == PANIC_OUTPUT_LIMIT_BYTES
+            assert result.stderr_truncated
+
+            followup = await machine.run(Command(("cat", "/workspace/numbers.txt")))
+            assert (followup.exit_code, followup.stdout) == (0, b"1\n2\n")
+        finally:
+            await machine.close()
+
+    asyncio.run(check())
+
+
+def test_shell_session_simulator_panic_returns_failed_update(tmp_path: Path) -> None:
+    async def check() -> None:
+        machine = await ShellSimMachineFactory().create(MachineSpec(ShellSimBuiltins()))
+        try:
+            source = tmp_path / "numbers.txt"
+            source.write_text("1\n2\n")
+            await machine.upload(source, "/workspace/numbers.txt")
+            shell = await machine.open_shell()
+
+            update = await shell.execute(PANIC_COMMAND, output_limit_bytes=PANIC_OUTPUT_LIMIT_BYTES)
+            assert update.status is ShellStatus.COMPLETED
+            assert update.exit_code == 1
+            assert update.output.startswith(b"shellsim operation panicked")
+            assert len(update.output) == PANIC_OUTPUT_LIMIT_BYTES
+            assert update.truncated
+
+            followup = await shell.execute("cat /workspace/numbers.txt")
+            assert (followup.exit_code, followup.output) == (0, b"1\n2\n")
+        finally:
+            await machine.close()
+
+    asyncio.run(check())

marin_shellbox-0.2.152.dev37849924057/tests/test_shellsim_machine.py

@@ -1,55 +0,0 @@
-# Copyright The Marin Authors
-# SPDX-License-Identifier: Apache-2.0
-
-"""Behavior checks for the simulated shell and verifier boundary."""
-
-import asyncio
-from pathlib import Path
-
-from shellbox.backends.shellsim.machine import ShellSimMachineFactory
-from shellbox.machine import Command, MachineSpec, ShellSimBuiltins, ShellStatus
-
-
-def test_shell_state_and_one_shot_command() -> None:
-    async def check() -> None:
-        machine = await ShellSimMachineFactory().create(MachineSpec(ShellSimBuiltins()))
-        try:
-            shell = await machine.open_shell()
-            first = await shell.execute(
-                'cd /tmp; export ANSWER=hello; answer() { echo "$ANSWER"; }; echo file >/workspace/result'
-            )
-            assert first.status is ShellStatus.COMPLETED
-            second = await shell.execute("pwd; answer")
-            assert second.output == b"/tmp\nhello\n"
-
-            verifier = await machine.run(Command(("sh", "-c", "pwd; cat /workspace/result")))
-            assert verifier.stdout == b"/workspace\nfile\n"
-            after = await shell.execute("pwd; answer")
-            assert after.output == b"/tmp\nhello\n"
-        finally:
-            await machine.close()
-
-    asyncio.run(check())
-
-
-def test_file_transfer_and_bounded_output(tmp_path: Path) -> None:
-    async def check() -> None:
-        machine = await ShellSimMachineFactory().create(MachineSpec(ShellSimBuiltins()))
-        try:
-            source = tmp_path / "source"
-            source.mkdir()
-            (source / "data.txt").write_text("payload")
-            await machine.upload(source, "/workspace/imported")
-            shell = await machine.open_shell()
-            result = await shell.execute("cat /workspace/imported/data.txt; printf 'x'", output_limit_bytes=4)
-            assert result.output == b"payl"
-            assert result.truncated
-
-            target = tmp_path / "downloaded"
-            target.mkdir()
-            await machine.download("/workspace/imported", target)
-            assert (target / "data.txt").read_text() == "payload"
-        finally:
-            await machine.close()
-
-    asyncio.run(check())