WIP

Author: marvinhagemeister

src/deno_sandbox/errors.py

@@ -19,6 +19,21 @@ class UnknownRpcMethod(Exception):
     pass
 
 
+class ProcessAlreadyExited(Exception):
+    """Raised when trying to interact with a process that has already exited."""
+
+    pass
+
+
+class HTTPStatusError(Exception):
+    """Raised when an HTTP request returns a non-success status code."""
+
+    def __init__(self, status_code: int, message: str) -> None:
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"HTTP Status {status_code}: {message}")
+
+
 class ZodErrorRaw(TypedDict):
     expected: str
     code: str

src/deno_sandbox/rpc.py

@@ -5,7 +5,12 @@
 from websockets import ConnectionClosed
 
 from deno_sandbox.bridge import AsyncBridge
-from deno_sandbox.errors import RpcValidationError, UnknownRpcMethod, ZodErrorRaw
+from deno_sandbox.errors import (
+    ProcessAlreadyExited,
+    RpcValidationError,
+    UnknownRpcMethod,
+    ZodErrorRaw,
+)
 from deno_sandbox.transport import WebSocketTransport
 from deno_sandbox.utils import (
     convert_to_camel_case,
@@ -41,6 +46,11 @@ def __init__(self, transport: WebSocketTransport):
         self._listen_task: asyncio.Task[Any] | None = None
         self._pending_processes: Dict[int, asyncio.StreamReader] = {}
         self._loop: asyncio.AbstractEventLoop | None = None
+        self._signal_id = 0
+
+    def get_next_signal_id(self) -> int:
+        self._signal_id += 1
+        return self._signal_id
 
     async def close(self):
         await self._transport.close()
@@ -89,7 +99,16 @@ async def call(self, method: str, params: Dict[str, Any]) -> Any:
             raise Exception(response["error"])
 
         if response.get("result") and response["result"].get("error"):
-            raise Exception(f"Application Error: {response['result']['error']}")
+            err = response["result"]["error"]
+            if (
+                "constructor_name" in err
+                and err["constructor_name"] == "TypeError"
+                and "code" in err
+                and err["code"] == "ENOENT"
+            ):
+                raise ProcessAlreadyExited("Process has already exited")
+
+            raise Exception(f"Application Error: {err}")
         return response["result"]["ok"] if response.get("result") else None
 
     async def _listener(self) -> None:
@@ -134,6 +153,9 @@ def __init__(self, async_client: AsyncRpcClient, bridge: AsyncBridge):
         self._async_client = async_client
         self._bridge = bridge
 
+    def get_next_signal_id(self) -> int:
+        return self._async_client.get_next_signal_id()
+
     def call(self, method: str, params: Dict[str, Any]) -> Any:
         return self._bridge.run(self._async_client.call(method, params))
 

src/deno_sandbox/sandbox.py

@@ -20,6 +20,7 @@
 )
 from deno_sandbox.api_types_generated import (
     DenoReplOptions,
+    DenoRunOptions,
     SandboxListOptions,
     SandboxCreateOptions,
     SandboxConnectOptions,
@@ -35,8 +36,11 @@
 from deno_sandbox.utils import to_camel_case, to_snake_case
 from deno_sandbox.wrappers import (
     AsyncChildProcess,
+    AsyncDenoProcess,
     AsyncDenoRepl,
     ChildProcess,
+    DenoProcess,
+    DenoRepl,
     ProcessSpawnResult,
     RemoteProcessOptions,
 )
@@ -212,9 +216,41 @@ class VsCodeOptions(TypedDict):
 
 
 class AsyncSandboxDeno(AsyncSandboxDenoGenerated):
+    async def run(self, options: DenoRunOptions) -> AsyncDenoProcess:
+        """Create a new Deno process from the specified entrypoint file or code. The runtime will execute the given code to completion, and then exit."""
+
+        params = {
+            "stdout": "inherit",
+            "stderr": "inherit",
+        }
+
+        if options is not None:
+            for key, value in options.items():
+                if value is not None:
+                    params[to_snake_case(key)] = value
+
+        if "code" in params and "extension" not in params:
+            params["extension"] = "ts"
+
+        opts = RemoteProcessOptions(
+            stdout_inherit=params["stdout"] == "inherit",
+            stderr_inherit=params["stderr"] == "inherit",
+        )
+
+        if params["stdout"] == "inherit":
+            params["stdout"] = "piped"
+        if params["stderr"] == "inherit":
+            params["stderr"] = "piped"
+
+        result = await self._rpc.call("spawnDeno", params)
+
+        return await AsyncDenoProcess.create(result, self._rpc, opts)
+
     async def eval(self, code: str) -> Any:
         repl = await self.repl()
-        return await repl.eval(code)
+        result = await repl.eval(code)
+        await repl.close()
+        return result
 
     async def repl(self, options: Optional[DenoReplOptions] = None) -> AsyncDenoRepl:
         params = {"stdout": "piped", "stderr": "piped"}
@@ -243,9 +279,17 @@ def __init__(self, client: ConsoleClient, rpc: RpcClient):
 
         self._async = AsyncSandboxDeno(self._client._async, rpc._async_client)
 
+    def run(self, options: DenoRunOptions) -> DenoProcess:
+        async_deno = self._client._bridge.run(self._async.run(options))
+        return DenoProcess(self._rpc, async_deno)
+
     def eval(self, code: str) -> Any:
         return self._client._bridge.run(self._async.eval(code))
 
+    def repl(self, options: Optional[DenoReplOptions] = None) -> DenoRepl:
+        async_repl = self._client._bridge.run(self._async.repl(options))
+        return DenoRepl(self._rpc, async_repl)
+
 
 class AsyncSandbox:
     def __init__(