Change javascript kernel to Deno

Author: jakubno

js/tests/languages/js.test.ts

@@ -0,0 +1,62 @@
+import { expect } from 'vitest'
+
+import { sandboxTest } from '../setup'
+
+sandboxTest('js simple', async ({ sandbox }) => {
+  const result = await sandbox.runCode('console.log("Hello, World!")', {language: "js"})
+
+  expect(result.logs.stdout.join().trim()).toEqual('Hello, World!')
+})
+
+sandboxTest('js import', async ({ sandbox }) => {
+  const result = await sandbox.runCode('import isOdd from "npm:is-odd"\nisOdd(3)', {language: "js"})
+
+  expect(result.results[0].text).toEqual('true')
+})
+
+sandboxTest('js top level await', async ({ sandbox }) => {
+  const result = await sandbox.runCode(`
+    async function main() {
+        return 'Hello, World!'
+    }
+
+    await main()
+    `, {language: "js"})
+  expect(result.results[0].text).toEqual('Hello, World!')
+})
+
+sandboxTest('js es6', async ({ sandbox }) => {
+  const result = await sandbox.runCode(`
+const add = (x, y) => x + y;
+add(1, 2)
+`, {language: "js"})
+  expect(result.results[0].text).toEqual('3')
+})
+
+
+sandboxTest('js context', async ({ sandbox }) => {
+  await sandbox.runCode('const z = 1', {language: "js"})
+  const result = await sandbox.runCode('z', {language: "js"})
+  expect(result.results[0].text).toEqual('1')
+})
+
+sandboxTest('js cwd', async ({ sandbox }) => {
+  const result = await sandbox.runCode('process.cwd()', {language: "js"})
+  expect(result.results[0].text).toEqual('/home/user')
+
+  const ctx = await sandbox.createCodeContext( {cwd: '/home', language: "js"})
+  const result2 = await sandbox.runCode('process.cwd()', {context: ctx})
+  expect(result2.results[0].text).toEqual('/home')
+})
+
+sandboxTest('ts simple', async ({ sandbox }) => {
+  const result = await sandbox.runCode(`
+function subtract(x: number, y: number): number {
+  return x - y;
+}
+
+subtract(1, 2)
+`, {language: "ts"})
+
+  expect(result.results[0].text).toEqual('-1')
+})

python/tests/languages/test_js.py

@@ -0,0 +1,68 @@
+from e2b_code_interpreter import AsyncSandbox
+
+
+async def test_javascript(async_sandbox: AsyncSandbox):
+    code = """
+    console.log('Hello, World!')
+    """
+    execution = await async_sandbox.run_code(code, language="js")
+    assert execution.logs.stdout == ["Hello, World!\n"]
+
+
+async def test_import(async_sandbox: AsyncSandbox):
+    code = """
+    import isOdd from 'npm:is-odd'
+    isOdd(3)
+    """
+    execution = await async_sandbox.run_code(code, language="js")
+    assert execution.results[0].text == "true"
+
+
+async def test_toplevel_await(async_sandbox: AsyncSandbox):
+    code = """
+    async function main() {
+        return 'Hello, World!'
+    }
+    
+    await main()
+    """
+    execution = await async_sandbox.run_code(code, language="js")
+    assert execution.results[0].text == "Hello, World!"
+
+
+async def test_es6(async_sandbox: AsyncSandbox):
+    code = """
+const add = (x, y) => x + y;
+add(1, 2);
+    """
+    execution = await async_sandbox.run_code(code, language="js")
+    assert execution.results[0].text == "3"
+
+
+async def test_context(async_sandbox: AsyncSandbox):
+    await async_sandbox.run_code("const x = 1", language="js")
+    execution = await async_sandbox.run_code("x", language="js")
+    assert execution.results[0].text == "1"
+
+
+async def test_cwd(async_sandbox: AsyncSandbox):
+    execution = await async_sandbox.run_code("process.cwd()", language="js")
+    assert execution.results[0].text == "/home/user"
+
+    ctx = await async_sandbox.create_code_context("/home", language="js")
+    execution = await async_sandbox.run_code("process.cwd()", context=ctx)
+    assert execution.results[0].text == "/home"
+
+
+async def test_typescript(async_sandbox: AsyncSandbox):
+    execution = await async_sandbox.run_code(
+        """
+function subtract(x: number, y: number): number {
+  return x - y;
+}
+  
+subtract(1, 2);
+""",
+        language="ts",
+    )
+    assert execution.results[0].text == "-1"

python/tests/sync/test_default_kernels.py

@@ -4,3 +4,13 @@
 def test_js_kernel(sandbox: Sandbox):
     execution = sandbox.run_code("console.log('Hello, World!')", language="js")
     assert execution.logs.stdout == ["Hello, World!\n"]
+
+
+def test_r_kernel(sandbox: Sandbox):
+    execution = sandbox.run_code('print("Hello, World!")', language="r")
+    assert execution.logs.stdout == ['[1] "Hello, World!"\n']
+
+
+def test_java_kernel(sandbox: Sandbox):
+    execution = sandbox.run_code('System.out.println("Hello, World!")', language="java")
+    assert execution.logs.stdout[0] == "Hello, World!"

template/Dockerfile

@@ -23,9 +23,10 @@ RUN R -e "install.packages('IRkernel')"
 RUN R -e "IRkernel::installspec(user = FALSE, name = 'r', displayname = 'R')"
 
 # Javascript Kernel
-RUN npm install -g node-gyp
-RUN npm install -g --unsafe-perm ijavascript
-RUN ijsinstall --install=global
+COPY --from=denoland/deno:bin-2.0.4 /deno /usr/bin/deno
+RUN chmod +x /usr/bin/deno
+RUN deno jupyter --unstable --install
+COPY ./deno.json /root/.local/share/jupyter/kernels/deno/kernel.json
 
 # Bash Kernel
 RUN pip install bash_kernel

template/deno.json

@@ -0,0 +1,14 @@
+{
+  "argv": [
+    "/usr/bin/deno",
+    "jupyter",
+    "--kernel",
+    "--conn",
+    "{connection_file}"
+  ],
+  "display_name": "Deno",
+  "env": {
+    "NO_COLOR": "1"
+  },
+  "language": "typescript"
+}

template/server/api/models/result.py

@@ -45,7 +45,10 @@ def __init__(self, is_main_result: bool, data: [str, str]):
         self.is_main_result = is_main_result
 
         self.text = data.pop("text/plain", None)
-        if self.text and self.text.startswith("'") and self.text.endswith("'"):
+        if self.text and (
+            (self.text.startswith("'") and self.text.endswith("'"))
+            or (self.text.startswith('"') and self.text.endswith('"'))
+        ):
             self.text = self.text[1:-1]
 
         self.html = data.pop("text/html", None)

template/server/contexts.py

@@ -20,11 +20,16 @@ def normalize_language(language: Optional[str]) -> str:
 
     if language == "js":
         return "javascript"
+    if language == "ts":
+        return "typescript"
 
     return language
 
 
 async def create_context(client, websockets: dict, language: str, cwd: str) -> Context:
+    if language == "javascript" or language == "typescript":
+        language = "deno"
+
     data = {
         "path": str(uuid.uuid4()),
         "kernel": {"name": language},
@@ -53,7 +58,7 @@ async def create_context(client, websockets: dict, language: str, cwd: str) -> C
 
     logger.info(f"Setting working directory to {cwd}")
     try:
-        await ws.change_current_directory(cwd)
+        await ws.change_current_directory(cwd, language)
     except ExecutionError as e:
         return PlainTextResponse(
             "Failed to set working directory",

template/server/main.py

@@ -88,6 +88,7 @@ async def post_execute(request: ExecutionRequest):
         if not context_id:
             context = await create_context(client, websockets, language, "/home/user")
             context_id = context.id
+            default_websockets[language] = context_id
 
     elif request.context_id:
         context_id = request.context_id
@@ -104,7 +105,10 @@ async def post_execute(request: ExecutionRequest):
         )
 
     return StreamingListJsonResponse(
-        ws.execute(request.code, env_vars=request.env_vars)
+        ws.execute(
+            request.code,
+            env_vars=request.env_vars,
+        )
     )
 
 

template/server/messaging.py

@@ -1,3 +1,4 @@
+import datetime
 import json
 import logging
 import uuid
@@ -95,14 +96,21 @@ def _get_execute_request(
                     "session": self.session_id,
                     "msg_type": "execute_request",
                     "version": "5.3",
+                    "date": datetime.datetime.now(datetime.timezone.utc).isoformat(),
                 },
                 "parent_header": {},
-                "metadata": {},
+                "metadata": {
+                    "trusted": True,
+                    "deletedCells": [],
+                    "recordTiming": False,
+                    "cellId": str(uuid.uuid4()),
+                },
                 "content": {
                     "code": code,
                     "silent": background,
                     "store_history": True,
                     "user_expressions": {},
+                    "stop_on_error": True,
                     "allow_stdin": False,
                 },
             }
@@ -127,10 +135,25 @@ async def _wait_for_result(self, message_id: str):
 
             yield output.model_dump(exclude_none=True)
 
-    async def change_current_directory(self, path: Union[str, StrictStr]):
+    async def change_current_directory(
+        self, path: Union[str, StrictStr], language: str
+    ):
         message_id = str(uuid.uuid4())
         self._executions[message_id] = Execution(in_background=True)
-        request = self._get_execute_request(message_id, f"%cd {path}", True)
+        if language == "python":
+            request = self._get_execute_request(message_id, f"%cd {path}", True)
+        elif language == "deno":
+            request = self._get_execute_request(
+                message_id, f"Deno.chdir('{path}')", True
+            )
+        elif language == "r":
+            request = self._get_execute_request(message_id, f"setwd('{path}')", True)
+        elif language == "java":
+            request = self._get_execute_request(
+                message_id, f"System.setProperty('user.dir', '{path}')", True
+            )
+        else:
+            return
 
         await self._ws.send(request)
 
@@ -165,11 +188,12 @@ async def execute(
                         indent = len(line) - len(line.lstrip())
                         break
 
-                code = (
-                    indent * " "
-                    + f"os.environ.set_envs_for_execution({vars_to_set})\n"
-                    + code
-                )
+                if self.language == "python":
+                    code = (
+                        indent * " "
+                        + f"os.environ.set_envs_for_execution({vars_to_set})\n"
+                        + code
+                    )
 
             logger.info(code)
             request = self._get_execute_request(message_id, code, False)
@@ -192,7 +216,9 @@ async def _receive_message(self):
             async for message in self._ws:
                 await self._process_message(json.loads(message))
         except Exception as e:
-            logger.error(f"WebSocket received error while receiving messages: {e}")
+            logger.error(
+                f"WebSocket received error while receiving messages: {type(e)}: {str(e)}"
+            )
 
     async def _process_message(self, data: dict):
         """
@@ -308,11 +334,21 @@ async def _process_message(self, data: dict):
                 execution.errored = True
                 await queue.put(
                     Error(
-                        name=data["content"]["ename"],
-                        value=data["content"]["evalue"],
-                        traceback="".join(data["content"]["traceback"]),
+                        name=data["content"].get("ename", ""),
+                        value=data["content"].get("evalue", ""),
+                        traceback="".join(data["content"].get("traceback", [])),
                     )
                 )
+            elif data["content"]["status"] == "abort":
+                logger.debug(f"Execution {parent_msg_ig} was aborted")
+                await queue.put(
+                    Error(
+                        name="ExecutionAborted",
+                        value="Execution was aborted",
+                        traceback="",
+                    )
+                )
+                await queue.put(EndOfExecution())
             elif data["content"]["status"] == "ok":
                 pass
 

template/test.Dockerfile

@@ -19,9 +19,10 @@ COPY ./template/requirements.txt requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt && ipython kernel install --name "python3" --user
 
 # Javascript Kernel
-RUN npm install -g node-gyp
-RUN npm install -g --unsafe-perm ijavascript
-RUN ijsinstall --install=global
+COPY --from=denoland/deno:bin-2.0.4 /deno /usr/bin/deno
+RUN chmod +x /usr/bin/deno
+RUN deno jupyter --unstable --install
+COPY ./template/deno.json /root/.local/share/jupyter/kernels/deno/kernel.json
 
 # Create separate virtual environment for server
 RUN python -m venv $SERVER_PATH/.venv