WIP

Author: marvinhagemeister

pyproject.toml

@@ -27,4 +27,7 @@ dev = [
 ]
 
 [tool.pytest.ini_options]
+# asyncio_debug = true
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
 timeout = 10

src/deno_sandbox/api_generated.py

@@ -106,7 +106,7 @@ class TimelineListOptions:
 
 @dataclass_json(letter_case=LetterCase.CAMEL)
 @dataclass
-class SandboxConnectOptions:
+class SandboxCreateOptions:
     region: str | None = None
     env: dict[str, str] | None = None
     timeout: str | None = None
@@ -121,6 +121,17 @@ class SandboxConnectOptions:
     org: str | None = None
 
 
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class SandboxConnectOptions:
+    id: str
+    region: str | None = None
+    debug: bool | None = None
+    ssh: bool | None = None
+    token: str | None = None
+    org: str | None = None
+
+
 @dataclass_json(letter_case=LetterCase.CAMEL)
 @dataclass
 class SandboxListOptions:
@@ -186,38 +197,22 @@ class WriteFileOptions:
 
 @dataclass_json(letter_case=LetterCase.CAMEL)
 @dataclass
-class WriteFileWithContent:
-    path: str
-    content: str
-    abort_id: int | None = None
-    options: WriteFileOptions | None = None
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL)
-@dataclass
-class WriteFileWithStream:
-    path: str
-    content_stream_id: int
-    abort_id: int | None = None
-    options: WriteFileOptions | None = None
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL)
-@dataclass
-class WriteTextFileWithContent:
+class WriteFileArgs:
     path: str
-    content: str
     abort_id: int | None = None
     options: WriteFileOptions | None = None
+    content: str | None = None
+    content_stream_id: int | None = None
 
 
 @dataclass_json(letter_case=LetterCase.CAMEL)
 @dataclass
-class WriteTextFileWithStream:
+class WriteTextFileArgs:
     path: str
-    content_stream_id: int
     abort_id: int | None = None
     options: WriteFileOptions | None = None
+    content: str | None = None
+    content_stream_id: int | None = None
 
 
 @dataclass_json(letter_case=LetterCase.CAMEL)
@@ -620,20 +615,7 @@ class KillArgs:
 
 @dataclass_json(letter_case=LetterCase.CAMEL)
 @dataclass
-class SpawnDenoByEntrypoint:
-    entrypoint: str
-    stdout: Literal["piped", "null"] = "piped"
-    stderr: Literal["piped", "null"] = "piped"
-    env: dict[str, str] | None = None
-    clear_env: bool | None = None
-    cwd: str | None = None
-    stdin_stream_id: int | None = None
-    script_args: list[str] | None = None
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL)
-@dataclass
-class SpawnDenoByCode:
+class RunArgs:
     code: str
     extension: Literal["js", "cjs", "mjs", "ts", "cts", "mts", "jsx", "tsx"]
     stdout: Literal["piped", "null"] = "piped"
@@ -643,6 +625,7 @@ class SpawnDenoByCode:
     cwd: str | None = None
     stdin_stream_id: int | None = None
     script_args: list[str] | None = None
+    entrypoint: str | None = None
 
 
 @dataclass_json(letter_case=LetterCase.CAMEL)
@@ -723,16 +706,10 @@ class NetFetchResult:
 
 @dataclass_json(letter_case=LetterCase.CAMEL)
 @dataclass
-class ExposeHttpByPort:
+class ExposeHttpArgs:
     domain: str
-    port: int
-
-
-@dataclass_json(letter_case=LetterCase.CAMEL)
-@dataclass
-class ExposeHttpByPid:
-    domain: str
-    pid: int
+    port: int | None = None
+    pid: int | None = None
 
 
 @dataclass_json(letter_case=LetterCase.CAMEL)

src/deno_sandbox/api_types_generated.py

@@ -1,3 +1,5 @@
+from dataclasses import is_dataclass
+from typing import Any
 from deno_sandbox.api_types_generated import PaginatedList
 
 
@@ -8,3 +10,10 @@ def convert_paginated_list_response(response, item_converter):
         total_count=response.total_count,
         next_page_token=response.next_page_token,
     )
+
+
+def convert_dict_to_typed(data: dict[str, Any] | None, type_converter) -> Any:
+    if data is not None and not is_dataclass(data):
+        return type_converter(**data)
+
+    return data

src/deno_sandbox/api_utils.py

@@ -9,12 +9,16 @@ class AsyncConsoleClient:
     def __init__(self, options: Options):
         self._options = get_internal_options(options or Options())
 
-        self.client = httpx.AsyncClient(
-            headers={
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {self._options.token}",
-            }
-        )
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {self._options.token}",
+                }
+            )
+        return self._client
 
     async def post(self, path: str, data: any) -> dict:
         req_url = HttpUrl(self._options.console_url, path=path)
@@ -47,7 +51,6 @@ class ConsoleClient:
     def __init__(self, options: Options):
         self._options = get_internal_options(options or Options())
 
-        print(self._options)
         self.client = httpx.Client(
             headers={
                 "Content-Type": "application/json",

src/deno_sandbox/console.py

@@ -1,58 +1,69 @@
 import asyncio
 import base64
+from dataclasses import dataclass
 import json
-from typing import Any, Dict, Optional
-from pydantic import BaseModel
+from typing import Any, Dict
+from dataclasses_json import dataclass_json
 from websockets import ConnectionClosed
 
 from deno_sandbox.bridge import AsyncBridge
-from deno_sandbox.transport import Transport
+from deno_sandbox.transport import WebSocketTransport
 
 
-class RpcRequest(BaseModel):
-    method: str
-    params: Dict[str, Any]
+@dataclass_json
+@dataclass
+class RpcRequest:
     id: int
+    method: str
+    params: dict[str, Any]
     jsonrpc: str = "2.0"
 
 
-class RpcResult[T](BaseModel):
-    ok: Optional[T] = None
-    error: Optional[Any] = None
+@dataclass_json
+@dataclass
+class RpcResult[T]:
+    ok: T | None = None
+    error: Any | None = None
 
 
-class RpcResponse[T](BaseModel):
-    jsonrpc: str = "2.0"
-    result: Optional[RpcResult[T]] = None
-    error: Dict[str, Any] | None = None
+@dataclass_json
+@dataclass
+class RpcResponse[T]:
     id: int
+    jsonrpc: str = "2.0"
+    result: RpcResult[T] | None = None
+    error: dict[str, Any] | None = None
 
 
 class AsyncRpcClient:
-    def __init__(self, transport: Transport):
+    def __init__(self, transport: WebSocketTransport):
         self._transport = transport
         self._id = 0
         self._pending_requests: Dict[int, asyncio.Future[Any]] = {}
-        self._listen_task = asyncio.create_task(self._listener())
+        self._listen_task: asyncio.Task[Any] | None = None
         self._pending_processes: Dict[int, asyncio.StreamReader] = {}
+        self._loop = None
 
     async def close(self):
         await self._transport.close()
 
     async def call(self, method: str, params: Dict[str, Any]) -> Any:
+        if self._listen_task is None or self._listen_task.done():
+            self._loop = asyncio.get_running_loop()
+            self._listen_task = self._loop.create_task(self._listener())
+
         req_id = self._id + 1
         self._id = req_id
 
         payload = RpcRequest(method=method, params=params, id=req_id)
 
-        loop = asyncio.get_running_loop()
-        future = loop.create_future()
+        future = self._loop.create_future()
         self._pending_requests[req_id] = future
 
-        await self._transport.send(payload.model_dump_json())
+        await self._transport.send(payload.to_json())
 
         raw_response = await future
-        response = RpcResponse[Any](**raw_response)
+        response = RpcResponse[Any].from_json(json.dumps(raw_response))
 
         if response.error:
             raise Exception(response.error)
@@ -91,6 +102,7 @@ async def _listener(self) -> None:
                             del self._pending_processes[stream_id]
 
         except ConnectionClosed:
+            print("Transport connection closed.")  # --- IGNORE ---
             pass
         except Exception as e:
             for future in self._pending_requests.values():