added try/catch blocks to avoid throwing on negative err code

Author: mishushakov

js/tests/supervisord.test.ts

@@ -24,12 +24,18 @@ sandboxTest('restart after jupyter kill', async ({ sandbox }) => {
   expect(initialHealth).toBe(true)
 
   // Kill the jupyter process as root
-  await sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server') || true", {
-    user: 'root',
-  })
+  // The command handle may get killed too (since killing jupyter cascades to code-interpreter),
+  // so we catch the error.
+  try {
+    await sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server')", {
+      user: 'root',
+    })
+  } catch {
+    // Expected — the kill cascade may terminate the command handle
+  }
 
-  // Wait for supervisord to restart it and health to come back
-  const recovered = await waitForHealth(sandbox, 20, 100)
+  // Wait for supervisord to restart both services (jupyter startup + code-interpreter startup)
+  const recovered = await waitForHealth(sandbox, 60, 500)
   expect(recovered).toBe(true)
 
   // Verify code execution works after recovery
@@ -43,12 +49,16 @@ sandboxTest('restart after code-interpreter kill', async ({ sandbox }) => {
   expect(initialHealth).toBe(true)
 
   // Kill the code-interpreter process as root
-  await sandbox.commands.run('kill -9 $(cat /var/run/code-interpreter.pid) || true', {
-    user: 'root',
-  })
+  try {
+    await sandbox.commands.run('kill -9 $(cat /var/run/code-interpreter.pid)', {
+      user: 'root',
+    })
+  } catch {
+    // Expected — killing code-interpreter may terminate the command handle
+  }
 
   // Wait for supervisord to restart it and health to come back
-  const recovered = await waitForHealth(sandbox, 20, 100)
+  const recovered = await waitForHealth(sandbox, 60, 500)
   expect(recovered).toBe(true)
 
   // Verify code execution works after recovery

python/tests/async/test_async_supervisord.py

@@ -22,10 +22,15 @@ async def test_restart_after_jupyter_kill(async_sandbox: AsyncSandbox):
     assert await wait_for_health(async_sandbox)
 
     # Kill the jupyter process as root
-    await async_sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server') || true", user="root")
+    # The command handle may get killed too (killing jupyter cascades to code-interpreter),
+    # so we catch the error.
+    try:
+        await async_sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server')", user="root")
+    except Exception:
+        pass
 
-    # Wait for supervisord to restart it and health to come back
-    assert await wait_for_health(async_sandbox, 20, 100)
+    # Wait for supervisord to restart both services
+    assert await wait_for_health(async_sandbox, 60, 500)
 
     # Verify code execution works after recovery
     result = await async_sandbox.run_code("x = 1; x")
@@ -37,10 +42,13 @@ async def test_restart_after_code_interpreter_kill(async_sandbox: AsyncSandbox):
     assert await wait_for_health(async_sandbox)
 
     # Kill the code-interpreter process as root
-    await async_sandbox.commands.run("kill -9 $(cat /var/run/code-interpreter.pid) || true", user="root")
+    try:
+        await async_sandbox.commands.run("kill -9 $(cat /var/run/code-interpreter.pid)", user="root")
+    except Exception:
+        pass
 
     # Wait for supervisord to restart it and health to come back
-    assert await wait_for_health(async_sandbox, 20, 100)
+    assert await wait_for_health(async_sandbox, 60, 500)
 
     # Verify code execution works after recovery
     result = await async_sandbox.run_code("x = 1; x")

python/tests/sync/test_supervisord.py

@@ -22,10 +22,15 @@ def test_restart_after_jupyter_kill(sandbox: Sandbox):
     assert wait_for_health(sandbox)
 
     # Kill the jupyter process as root
-    sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server') || true", user="root")
+    # The command handle may get killed too (killing jupyter cascades to code-interpreter),
+    # so we catch the error.
+    try:
+        sandbox.commands.run("kill -9 $(pgrep -f 'jupyter server')", user="root")
+    except Exception:
+        pass
 
-    # Wait for supervisord to restart it and health to come back
-    assert wait_for_health(sandbox, 20, 100)
+    # Wait for supervisord to restart both services
+    assert wait_for_health(sandbox, 60, 500)
 
     # Verify code execution works after recovery
     result = sandbox.run_code("x = 1; x")
@@ -37,12 +42,15 @@ def test_restart_after_code_interpreter_kill(sandbox: Sandbox):
     assert wait_for_health(sandbox)
 
     # Kill the code-interpreter process as root
-    sandbox.commands.run(
-        "kill -9 $(cat /var/run/code-interpreter.pid) || true", user="root"
-    )
+    try:
+        sandbox.commands.run(
+            "kill -9 $(cat /var/run/code-interpreter.pid)", user="root"
+        )
+    except Exception:
+        pass
 
     # Wait for supervisord to restart it and health to come back
-    assert wait_for_health(sandbox, 20, 100)
+    assert wait_for_health(sandbox, 60, 500)
 
     # Verify code execution works after recovery
     result = sandbox.run_code("x = 1; x")