withruntime 0.6.0__tar.gz → 0.7.0__tar.gz

{withruntime-0.6.0/withruntime.egg-info → withruntime-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: withruntime
-Version: 0.6.0
+Version: 0.7.0
 Summary: Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first.
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -10,6 +10,10 @@ Provides-Extra: openai-agents
 Requires-Dist: openai-agents>=0.22.3; extra == "openai-agents"
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.7; extra == "deepagents"
+Provides-Extra: harbor
+Requires-Dist: harbor>=0.23.0; extra == "harbor"
+Provides-Extra: inspect-ai
+Requires-Dist: inspect-ai>=0.3.268; extra == "inspect-ai"
 Dynamic: license-file
 
 # Runtime Cloud Python SDK
@@ -39,7 +43,7 @@ with Sandbox.create() as sbx:
 
 `Sandbox.create()` needs no arguments and returns once the sandbox is running;
 leaving the `with` block stops it. With no arguments you get the free trial
-while it lasts: 50 free hours, no card, up to eight sandboxes running at once.
+while it lasts: 100 free hours, no card, up to eight sandboxes running at once.
 The current default image includes NumPy, pandas and matplotlib; see the
 [sandbox environment](https://withruntime.com/docs/sandbox-environment).
 `AsyncRuntime` is the same client for asyncio, method for method:

{withruntime-0.6.0 → withruntime-0.7.0}/README.md

@@ -25,7 +25,7 @@ with Sandbox.create() as sbx:
 
 `Sandbox.create()` needs no arguments and returns once the sandbox is running;
 leaving the `with` block stops it. With no arguments you get the free trial
-while it lasts: 50 free hours, no card, up to eight sandboxes running at once.
+while it lasts: 100 free hours, no card, up to eight sandboxes running at once.
 The current default image includes NumPy, pandas and matplotlib; see the
 [sandbox environment](https://withruntime.com/docs/sandbox-environment).
 `AsyncRuntime` is the same client for asyncio, method for method:

{withruntime-0.6.0 → withruntime-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "withruntime"
-version = "0.6.0"
+version = "0.7.0"
 description = "Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -16,6 +16,13 @@ dependencies = []
 openai-agents = ["openai-agents>=0.22.3"]
 # withruntime.deepagents: a LangChain Deep Agents sandbox backend.
 deepagents = ["deepagents>=0.7"]
+# withruntime.harbor: an environment for Harbor (Terminal-Bench): -e withruntime.harbor:RuntimeEnvironment.
+harbor = ["harbor>=0.23.0"]
+# withruntime.inspect_ai: sandbox="runtime" for Inspect AI, registered by the entry point below.
+inspect-ai = ["inspect-ai>=0.3.268"]
+
+[project.entry-points.inspect_ai]
+withruntime = "withruntime.inspect_ai"
 
 [tool.setuptools.packages.find]
 where = ["."]

withruntime-0.7.0/tests/test_account_errors.py

@@ -0,0 +1,46 @@
+"""A blocked account gets its own error type (ARCHITECTURE.md section 11,
+"A blocked account is told why")."""
+
+import unittest
+from typing import Any
+
+import withruntime
+from withruntime._errors import error_for
+
+
+class AccountErrorsTest(unittest.TestCase):
+    def test_account_blocked_is_its_own_type(self) -> None:
+        error = error_for(402, {"error": {"code": "account_blocked",
+                                          "message": "This account cannot spend: a payment on it is disputed."}}, None)
+        self.assertIsInstance(error, withruntime.AccountBlockedError)
+        self.assertIsInstance(error, withruntime.RuntimeError)
+        self.assertEqual(error.code, "account_blocked")
+        self.assertEqual(error.status, 402)
+        self.assertFalse(error.retryable)
+
+    def test_empty_balance_stays_plain(self) -> None:
+        error = error_for(402, {"error": {"code": "insufficient_funds", "message": "Add credit."}}, None)
+        self.assertNotIsInstance(error, withruntime.AccountBlockedError)
+
+
+class AccountCloseTest(unittest.TestCase):
+    """runtime.account.close (ARCHITECTURE.md section 3.1)."""
+
+    def test_close_posts_the_typed_name_once(self) -> None:
+        from withruntime._sync_client import Account
+
+        calls: list[tuple[Any, ...]] = []
+
+        class Transport:
+            def json(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+                calls.append((method, path, kwargs))
+                return {"orgId": "o1", "name": "Acme", "closedAt": "2026-09-25T20:00:00Z", "released": True}
+
+        closed = Account(Transport()).close(confirm="Acme")  # type: ignore[arg-type]
+        self.assertTrue(closed["released"])
+        self.assertEqual(calls, [("POST", "/v1/account:close", {"body": {"confirm": "Acme"}, "retry": False})])
+        self.assertTrue(hasattr(withruntime.Runtime(api_key="rk_x"), "account"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{withruntime-0.6.0 → withruntime-0.7.0}/tests/test_async_stream_cleanup.py

@@ -63,6 +63,38 @@ class AsyncStreamCleanupTest(unittest.IsolatedAsyncioTestCase):
         await asyncio.wait_for(asyncio.gather(*(event.wait() for event in self.peer_eofs)), 0.5)
         self.assertEqual(len(self.transport._http._idle), 0)
 
+    async def test_cancel_in_the_turn_a_read_completes_is_not_swallowed(self):
+        """Python 3.11's asyncio.wait_for returned the read's data and dropped the cancel
+        (CPython gh-86296); the stream then read on until its timeout, which is how
+        test_cancelled_pending_read_closes_peer failed there. Both paths of within()."""
+        import unittest.mock
+        from withruntime._http import within
+
+        async def race():
+            ready = asyncio.get_running_loop().create_future()
+
+            async def read():
+                return await ready
+            task = asyncio.create_task(within(read(), 5))
+            await asyncio.sleep(0)
+            ready.set_result(b'data')
+            task.cancel()
+            with self.assertRaises(asyncio.CancelledError):
+                await task
+
+        async def results():
+            self.assertEqual(await within(asyncio.sleep(0, b'ok'), 5), b'ok')
+            with self.assertRaises(asyncio.TimeoutError):
+                await within(asyncio.sleep(5), 0.01)
+
+        await race()
+        await results()
+        # Python 3.10 has no asyncio.timeout: the fallback waits on a task instead.
+        with unittest.mock.patch.dict(asyncio.__dict__):
+            asyncio.__dict__.pop('timeout', None)
+            await race()
+            await results()
+
     async def test_buffered_stream_close_then_transport_close_does_not_repool_later(self):
         stream = self.transport.events('GET', '/events')
         self.assertEqual(await anext(stream), {'event': 1})
@@ -220,3 +252,18 @@ class SyncStreamCleanupTest(unittest.TestCase):
         response.close()
         self.assertTrue(self.eof.wait(0.5), 'closed pool retained a late response')
         self.assertEqual(self.transport._http._idle.qsize(), 0)
+
+
+class NoWaitForTest(unittest.TestCase):
+    def test_no_module_uses_asyncio_wait_for(self):
+        # asyncio.wait_for loses a cancel before Python 3.12 (gh-86296); the
+        # client waits through _http.within instead, everywhere.
+        import re
+        from pathlib import Path
+        package = Path(__file__).resolve().parent.parent / "withruntime"
+        found = [f"{path.relative_to(package)}:{number}"
+                 for path in sorted(package.rglob("*.py"))
+                 for number, line in enumerate(path.read_text().splitlines(), 1)
+                 if re.search(r"\basyncio\.wait_for\(", line)]
+        self.assertEqual(found, [])
+

withruntime-0.7.0/tests/test_billing.py

@@ -0,0 +1,72 @@
+"""runtime.billing.topup() and topup_status() against a stub API, sync and
+async. The route is tested in packages/cloud (billing-api)."""
+import asyncio
+import json
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from withruntime import AsyncRuntime, Runtime
+
+TOPUP = {
+    "purchaseId": "3f0c2a4e-1b7d-4c5a-9e2f-0a1b2c3d4e5f",
+    "status": "open",
+    "amountUsd": "20.00",
+    "amount": "20.000000",
+    "payBy": "2026-09-25T13:00:00.000Z",
+    "networks": [{"network": "base", "address": "0xbase", "tokens": [{"currency": "usdc", "contract": "0xusdc"}]}],
+}
+
+
+class Stub(BaseHTTPRequestHandler):
+    seen: list = []
+
+    def log_message(self, *args):
+        pass
+
+    def answer(self):
+        length = int(self.headers.get("content-length") or 0)
+        body = json.loads(self.rfile.read(length)) if length else None
+        Stub.seen.append((self.command, self.path, body, self.headers.get("idempotency-key")))
+        data = json.dumps(TOPUP).encode()
+        self.send_response(200)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    do_GET = answer
+    do_POST = answer
+
+
+class BillingTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.server = ThreadingHTTPServer(("127.0.0.1", 0), Stub)
+        threading.Thread(target=cls.server.serve_forever, daemon=True).start()
+        cls.url = f"http://127.0.0.1:{cls.server.server_address[1]}"
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.server.shutdown()
+
+    def setUp(self):
+        Stub.seen = []
+
+    def test_sync_topup_and_status(self):
+        with Runtime(api_key="rk_test", base_url=self.url, max_retries=0) as runtime:
+            self.assertEqual(runtime.billing.topup(20, idempotency_key="k1")["amount"], "20.000000")
+            self.assertEqual(runtime.billing.topup_status(TOPUP["purchaseId"])["status"], "open")
+        self.assertEqual(Stub.seen[0], ("POST", "/v1/billing/topups", {"usd": 20}, "k1"))
+        self.assertEqual(Stub.seen[1][:2], ("GET", f"/v1/billing/topups/{TOPUP['purchaseId']}"))
+
+    def test_async_topup(self):
+        async def go():
+            async with AsyncRuntime(api_key="rk_test", base_url=self.url, max_retries=0) as runtime:
+                return await runtime.billing.topup(20)
+
+        self.assertEqual(asyncio.run(go())["networks"][0]["address"], "0xbase")
+
+
+if __name__ == "__main__":
+    unittest.main()

{withruntime-0.6.0 → withruntime-0.7.0}/tests/test_capacity_wait.py

@@ -84,6 +84,15 @@ class CapacityWait(unittest.TestCase):
             self.assertEqual(len(set(wire.bodies)), 1)
             self.assertEqual(json.loads(wire.bodies[0]), {"funding": "trial", "labels": {"ci": "1"}})
 
+    def test_a_create_says_why_it_waits_before_each_wait(self):
+        heard = []
+        busy = refusal("trial_busy")
+        for _, outcome, _ in create([busy, busy], on_capacity_wait=lambda error, seconds: heard.append(
+                (error.code, seconds))):
+            self.assertEqual(outcome.id, "sbx")
+        # Sync, then async: two waits each, of retryAfterMs.
+        self.assertEqual(heard, [("trial_busy", 0.005)] * 4)
+
     def test_the_paid_limit_a_domain_limit_and_a_full_region_are_waited_out_too(self):
         for code in ("quota_exceeded", "trial_domain_limit", "no_capacity"):
             for wire, outcome, _ in create([refusal(code)]):

{withruntime-0.6.0 → withruntime-0.7.0}/tests/test_client.py

@@ -83,8 +83,10 @@ class Sync(unittest.TestCase):
         self.assertEqual(seen, ["hello\n"])
 
     def test_errors_are_typed_and_keys_never_leak(self):
+        # A misspelled field is refused before sending (test_exec_stream.CreateFields);
+        # a value out of range is the API's to refuse.
         with self.assertRaises(InvalidRequestError) as caught:
-            client().sandboxes.create(vcpus=2)
+            client().sandboxes.create(vcpu=0)
         self.assertIn("issues", caught.exception.details)
         self.assertNotIn("rk_test", str(caught.exception))
         self.assertTrue(ServiceUnavailableError("x", status=503).retryable)

withruntime-0.7.0/tests/test_deepagents.py

@@ -0,0 +1,194 @@
+"""withruntime.deepagents against stand-in sandboxes. Skipped without Deep Agents
+(pip install "withruntime[deepagents]"). A real sandbox and create_deep_agent
+were exercised on 23 September 2026; see packages/cloud-guide/docs/frameworks.md.
+LocalSandbox runs Deep Agents' own commands on this machine, so every protocol
+method is checked end to end; sdks/python/integrations/langchain-withruntime
+runs LangChain's standard sandbox suite the same way."""
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+try:
+    import deepagents  # noqa: F401
+    HAVE_DEEPAGENTS = True
+except ImportError:
+    HAVE_DEEPAGENTS = False
+
+from withruntime import CommandResult
+from withruntime._errors import NotFoundError
+from withruntime._errors import RuntimeError as RuntimeCloudError
+
+
+class Files:
+    def __init__(self):
+        self.data, self.removed = {}, []
+
+    def read(self, path):
+        if path not in self.data:
+            raise NotFoundError("missing", code="file_not_found", status=404)
+        return self.data[path]
+
+    def write(self, path, data):
+        self.data[path] = data
+
+    def remove(self, path, recursive=False):
+        self.removed.append(path)
+        self.data.pop(path, None)
+
+
+class StubSandbox:
+    id = "sbx-1"
+
+    def __init__(self):
+        self.files, self.commands, self.outside = Files(), [], {}
+
+    def exec(self, command, **kwargs):
+        self.commands.append((command, kwargs))
+        if isinstance(command, list) and command[:2] == ["sh", "-c"]:
+            source, target = command[4], command[5]
+            if source.startswith("/workspace/"):
+                self.outside[target] = self.files.data[source]
+            elif source in self.outside:
+                self.files.data[target] = self.outside[source]
+            else:
+                return CommandResult(exit_code=1, stdout="", stderr=f"cat: {source}: No such file or directory\n")
+            return CommandResult(exit_code=0, stdout="", stderr="")
+        return CommandResult(exit_code=2, stdout="out\n", stderr="err\n", timed_out=True)
+
+
+class LocalFiles:
+    """The Files API over a temporary directory that stands for /workspace."""
+
+    def __init__(self, root):
+        self.root = root
+
+    def host(self, path):
+        assert path.startswith("/workspace/"), path
+        return self.root / path[len("/workspace/"):]
+
+    def read(self, path):
+        target = self.host(path)
+        if target.is_dir():
+            raise RuntimeCloudError(f"{path} is a directory", code="is_directory", status=400)
+        if not target.exists():
+            raise NotFoundError("missing", code="file_not_found", status=404)
+        return target.read_bytes()
+
+    def write(self, path, data):
+        target = self.host(path)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(data)
+
+    def remove(self, path, recursive=False):
+        self.host(path).unlink()
+
+
+class LocalSandbox:
+    """exec runs on this machine: a string under bash -c, a list without a shell,
+    with a /workspace argument mapped to the stand-in directory."""
+    id = "sbx-local"
+
+    def __init__(self, root):
+        self.files = LocalFiles(root / "workspace")
+
+    def exec(self, command, timeout_ms=None, **kwargs):
+        if isinstance(command, str):
+            argv = ["bash", "-c", command]
+        else:
+            argv = [str(self.files.host(a)) if a.startswith("/workspace/") else a for a in command]
+        done = subprocess.run(argv, capture_output=True, timeout=None if timeout_ms is None else timeout_ms / 1000)
+        return CommandResult(exit_code=done.returncode, stdout=done.stdout.decode(errors="replace"),
+                             stderr=done.stderr.decode(errors="replace"))
+
+
+@unittest.skipUnless(HAVE_DEEPAGENTS, "Deep Agents is not installed")
+class DeepAgentsTest(unittest.TestCase):
+    def test_execute_joins_output_and_reports_timeouts(self):
+        from withruntime.deepagents import RuntimeSandbox
+        sandbox = StubSandbox()
+        response = RuntimeSandbox(sandbox, timeout_seconds=9).execute("make")
+        self.assertEqual(response.exit_code, 2)
+        self.assertTrue(response.output.startswith("out\nerr\n"))
+        self.assertIn("ran past 9 seconds", response.output)
+        self.assertEqual(sandbox.commands[-1][1], {"timeout_ms": 9000})
+
+    def test_files_inside_and_outside_the_workspace(self):
+        from withruntime.deepagents import RuntimeSandbox
+        sandbox = StubSandbox()
+        backend = RuntimeSandbox(sandbox)
+        uploaded = backend.upload_files([("/workspace/a.txt", b"a"), ("/etc/app.conf", b"b"), ("rel.txt", b"c")])
+        self.assertEqual([u.error for u in uploaded], [None, None, "invalid_path"])
+        self.assertEqual(sandbox.outside["/etc/app.conf"], b"b")
+        downloaded = backend.download_files(["/workspace/a.txt", "/etc/app.conf", "/workspace/none", "/etc/none"])
+        self.assertEqual([d.content for d in downloaded[:2]], [b"a", b"b"])
+        self.assertEqual([d.error for d in downloaded[2:]], ["file_not_found", "file_not_found"])
+        self.assertTrue(all(path.startswith("/workspace/.deepagents-staging/") for path in sandbox.files.removed))
+        self.assertEqual(backend.id, "sbx-1")
+
+    def test_long_output_is_returned_whole_by_default(self):
+        from withruntime.deepagents import RuntimeSandbox
+
+        class Loud(StubSandbox):
+            def exec(self, command, **kwargs):
+                return CommandResult(exit_code=0, stdout="x" * 250_000, stderr="")
+
+        response = RuntimeSandbox(Loud()).execute("cat big")
+        self.assertEqual((len(response.output), response.truncated), (250_000, False))
+        capped = RuntimeSandbox(Loud(), max_output_chars=10).execute("cat big")
+        self.assertEqual((capped.output, capped.truncated), ("x" * 10, True))
+
+
+@unittest.skipUnless(HAVE_DEEPAGENTS, "Deep Agents is not installed")
+@unittest.skipUnless(sys.platform.startswith("linux") and shutil.which("bash") and shutil.which("python3"),
+                     "LocalSandbox runs Deep Agents' GNU shell and python3 commands on this machine")
+class DeepAgentsEndToEndTest(unittest.TestCase):
+    def setUp(self):
+        from withruntime.deepagents import RuntimeSandbox
+        self.dir = Path(tempfile.mkdtemp(prefix="runtime-deepagents-test-"))
+        self.root = str(self.dir / "outside")
+        self.backend = RuntimeSandbox(LocalSandbox(self.dir))
+
+    def tearDown(self):
+        shutil.rmtree(self.dir, ignore_errors=True)
+
+    def test_every_protocol_method(self):
+        backend, root = self.backend, self.root
+        self.assertIsNone(backend.write(f"{root}/src/app.py", "print('hello')\n").error)
+        edited = backend.edit(f"{root}/src/app.py", "hello", "world")
+        self.assertEqual((edited.error, edited.occurrences), (None, 1))
+        read = backend.read(f"{root}/src/app.py")
+        self.assertIn("print('world')", read.file_data["content"])
+        ran = backend.execute(f"python3 {root}/src/app.py")
+        self.assertEqual((ran.output, ran.exit_code, ran.truncated), ("world\n", 0, False))
+        self.assertEqual([e["path"] for e in backend.ls(f"{root}/src").entries], [f"{root}/src/app.py"])
+        self.assertEqual([m["path"] for m in backend.glob("**/*.py", path=root).matches], [f"{root}/src/app.py"])
+        grep = backend.grep("world", path=root)
+        self.assertEqual([(m["path"], m["line"]) for m in grep.matches], [(f"{root}/src/app.py", 1)])
+        self.assertIsNone(backend.delete(f"{root}/src/app.py").error)
+        self.assertIsNotNone(backend.read(f"{root}/src/app.py").error)
+        # Nothing staged outside the workspace was left behind.
+        self.assertEqual(list((self.dir / "workspace" / ".deepagents-staging").iterdir()), [])
+
+    def test_a_file_past_the_old_output_cap_reads_back(self):
+        backend, path = self.backend, f"{self.root}/big.txt"
+        text = "".join(f"line {i:06d} {'x' * 90}\n" for i in range(1500))  # about 150 KB
+        self.assertIsNone(backend.write(path, text).error)
+        read = backend.read(path, limit=2000)
+        self.assertIsNone(read.error)
+        self.assertIn("line 001499", read.file_data["content"])
+
+    def test_async_methods(self):
+        import asyncio
+
+        async def run():
+            self.assertIsNone((await self.backend.awrite(f"{self.root}/a.txt", "one")).error)
+            return await self.backend.aread(f"{self.root}/a.txt")
+
+        self.assertIn("one", asyncio.run(run()).file_data["content"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{withruntime-0.6.0 → withruntime-0.7.0}/tests/test_e2b_sandbox.py

@@ -340,11 +340,15 @@ class ForksPortsAndGaps(Base):
             self.assertEqual(caught.exception.code, "fork_unavailable")
 
     def test_ports(self):
+        # 25 September 2026: get_host raised, so E2B code did not run unchanged.
         sbx = self.create()
-        with self.assertRaises(NotSupportedException) as caught:
-            sbx.get_host(3000)
-        self.assertIn("get_public_host", str(caught.exception))
-        self.assertEqual(sbx.get_public_host(3000), f"3000-{sbx.sandbox_id}.runtimehost.com")
+        host = f"3000-{sbx.sandbox_id.replace('-', '')}.runtimehost.com"
+        self.assertEqual(sbx.get_host(3000), host)
+        self.assertEqual(sbx.get_host(3000), host)
+        self.assertEqual(sbx.get_public_host(3000), host)
+        self.assertEqual(len(self.world.called("previews.create")), 1)
+        with self.assertRaises(e2b.InvalidArgumentException):
+            sbx.get_host(0)
 
     def test_gaps(self):
         sbx = self.create()
@@ -356,6 +360,17 @@ class ForksPortsAndGaps(Base):
 
 
 class Async(unittest.TestCase):
+    def test_get_host_answers_at_once_and_the_share_lands_beside_it(self):
+        world = World()
+
+        async def scenario():
+            async with await AsyncSandbox.create(client=world.async_client()) as sbx:
+                host = sbx.get_host(8000)  # no await, as in E2B
+                self.assertEqual(host, f"8000-{sbx.sandbox_id.replace('-', '')}.runtimehost.com")
+                self.assertEqual(await sbx.get_public_host(8000), host)
+                self.assertEqual(len(world.called("previews.create")), 1)
+        asyncio.run(scenario())
+
     def test_async_sandbox_end_to_end(self):
         world = World()
 

withruntime-0.7.0/tests/test_eval_sandbox.py

@@ -0,0 +1,43 @@
+"""Exit codes in withruntime._eval_sandbox, which Harbor and Inspect share, as the
+live API reports them (read on 25 September 2026): a command past its limit ends
+with -9 and timedOut, and a command a signal ended with the negative signal
+number. Harbor and Inspect expect what a shell reports. Needs neither."""
+import asyncio
+import unittest
+
+from withruntime._eval_sandbox import _Shell, shell_exit_code
+
+
+class _Sandbox:
+    id = "sbx_exit"
+
+    def __init__(self, exit_event):
+        self.exit_event = exit_event
+
+    async def exec_stream(self, argv, *, env=None, stdin=None, timeout_ms=None):
+        yield {"type": "start", "processId": "p1"}
+        yield self.exit_event
+
+
+def _run(exit_event):
+    shell = _Shell(_Sandbox(exit_event), "/tmp")
+    return asyncio.run(shell._stream(["sh", "-c", "x"], None, None, 1000, None, None))
+
+
+class ShellExitCodeTest(unittest.TestCase):
+    def test_a_timed_out_command_is_124(self):
+        result = _run({"type": "exit", "exitCode": -9, "state": "timed_out", "timedOut": True})
+        self.assertEqual((result.exit_code, result.timed_out), (124, True))
+
+    def test_a_command_a_signal_ended_is_128_plus_the_signal(self):
+        self.assertEqual(_run({"type": "exit", "exitCode": -15, "timedOut": False}).exit_code, 143)
+        self.assertEqual(_run({"type": "exit", "exitCode": -9, "timedOut": False}).exit_code, 137)
+
+    def test_ordinary_codes_are_kept(self):
+        self.assertEqual(_run({"type": "exit", "exitCode": 3, "timedOut": False}).exit_code, 3)
+        self.assertEqual(shell_exit_code(0, False), 0)
+        self.assertEqual(shell_exit_code(None, False), -1)
+
+
+if __name__ == "__main__":
+    unittest.main()