clikernel 0.1.3__tar.gz → 0.1.4__tar.gz

{clikernel-0.1.3 → clikernel-0.1.4}/CHANGELOG.md

@@ -1,5 +1,13 @@
 <!-- do not remove -->
 
+## 0.1.4
+
+### New Features
+
+- Add cell inspectors, consolidate terminal handling, and harden MCP supervisor with signal guards and error recovery ([#9](https://github.com/AnswerDotAI/clikernel/issues/9))
+- Switch MCP server from in-process shell to supervised subprocess worker, add interrupt tool and idle-SIGINT handling ([#8](https://github.com/AnswerDotAI/clikernel/issues/8))
+
+
 ## 0.1.3
 
 ### New Features

{clikernel-0.1.3/clikernel.egg-info → clikernel-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clikernel
-Version: 0.1.3
+Version: 0.1.4
 Summary: A tiny stdin/stdout IPython worker
 Author: clikernel contributors
 License: Apache-2.0
@@ -10,7 +10,8 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: execnb>=0.2.3
+Requires-Dist: execnb>=0.2.4
+Requires-Dist: fastcore
 Requires-Dist: mcp
 Provides-Extra: dev
 Requires-Dist: fastship; extra == "dev"
@@ -90,6 +91,14 @@ Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output
 
 `clikernel` sets quiet defaults for `IPYTHONDIR`, `MPLCONFIGDIR`, and `MPLBACKEND=Agg` before creating the shell. Existing `IPYTHONDIR` and `MPLCONFIGDIR` values are left alone. Loading messages and any startup warnings are printed before the first delimiter. Set `CLIKERNEL_STATE_DIR` to choose the default parent directory.
 
+## Inspectors
+
+`clikernel` can check each cell before it runs, to warn about or forbid certain code. On startup it loads inspectors from `$XDG_CONFIG_HOME/clikernel/inspectors.py` (usually `~/.config/clikernel/inspectors.py`). If that file is absent, nothing changes.
+
+Each cell is transformed first (so IPython magics and `!` shell escapes parse), and its AST is passed to every inspector before the cell executes. An inspector returns a string to prepend a note to the cell's output, raises to block the cell (it does not run, and the exception is reported), or returns None to do nothing. Define a function `inspect(tree)` and/or a list `inspectors` of such functions in the file. A broken `inspectors.py` is reported on stderr and skipped, so it cannot stop the kernel starting.
+
+See [`examples/inspectors.py`](examples/inspectors.py) for one that blocks `subprocess`, `os.system`/`os.popen`, and `!` escapes, steering the agent to the permission-checked Bash tool instead.
+
 ## Why The Protocol Is Odd
 
 `clikernel` is built for a client that reads stdout as tokens. Local echo is disabled when stdin is a TTY. The client already knows the code it sent, so echoing it back only makes the LLM read slow, expensive tokens that add no information.
@@ -120,3 +129,4 @@ ship-gh
 ship-pypi
 ship-bump  # dev release always later than prod release
 ```
+

{clikernel-0.1.3 → clikernel-0.1.4}/README.md

@@ -69,6 +69,14 @@ Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output
 
 `clikernel` sets quiet defaults for `IPYTHONDIR`, `MPLCONFIGDIR`, and `MPLBACKEND=Agg` before creating the shell. Existing `IPYTHONDIR` and `MPLCONFIGDIR` values are left alone. Loading messages and any startup warnings are printed before the first delimiter. Set `CLIKERNEL_STATE_DIR` to choose the default parent directory.
 
+## Inspectors
+
+`clikernel` can check each cell before it runs, to warn about or forbid certain code. On startup it loads inspectors from `$XDG_CONFIG_HOME/clikernel/inspectors.py` (usually `~/.config/clikernel/inspectors.py`). If that file is absent, nothing changes.
+
+Each cell is transformed first (so IPython magics and `!` shell escapes parse), and its AST is passed to every inspector before the cell executes. An inspector returns a string to prepend a note to the cell's output, raises to block the cell (it does not run, and the exception is reported), or returns None to do nothing. Define a function `inspect(tree)` and/or a list `inspectors` of such functions in the file. A broken `inspectors.py` is reported on stderr and skipped, so it cannot stop the kernel starting.
+
+See [`examples/inspectors.py`](examples/inspectors.py) for one that blocks `subprocess`, `os.system`/`os.popen`, and `!` escapes, steering the agent to the permission-checked Bash tool instead.
+
 ## Why The Protocol Is Odd
 
 `clikernel` is built for a client that reads stdout as tokens. Local echo is disabled when stdin is a TTY. The client already knows the code it sent, so echoing it back only makes the LLM read slow, expensive tokens that add no information.
@@ -99,3 +107,4 @@ ship-gh
 ship-pypi
 ship-bump  # dev release always later than prod release
 ```
+

clikernel-0.1.4/clikernel/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1.4"
+
+
+
+

{clikernel-0.1.3 → clikernel-0.1.4}/clikernel/cli.py

@@ -1,5 +1,6 @@
-import inspect,os,secrets,shlex,string,sys,tempfile,termios,traceback
+import ast,inspect,os,runpy,secrets,shlex,signal,string,sys,tempfile,termios,traceback,tty
 from pathlib import Path
+from fastcore.xdg import xdg_config_home
 
 def _state_root():
     if d := os.environ.get("CLIKERNEL_STATE_DIR"): return Path(d).expanduser()
@@ -38,10 +39,33 @@ def _write_response(delim, body=None):
     print(delim, flush=True)
 
 
-def _execute(shell, code):
+def _load_inspectors():
+    "Cell inspectors from `$XDG_CONFIG_HOME/clikernel/inspectors.py`: each is called with the cell AST before execution, and may return a note (prepended to the output) or raise (blocking the cell). The file may define `inspect` and/or an `inspectors` list."
+    path = xdg_config_home()/"clikernel"/"inspectors.py"
+    if not path.exists(): return []
+    try: ns = runpy.run_path(str(path))
+    except Exception:
+        print(f"clikernel: failed to load {path}:\n{traceback.format_exc()}", file=sys.stderr, flush=True)
+        return []
+    ins = list(ns.get("inspectors", []))
+    if callable(ns.get("inspect")): ins.append(ns["inspect"])
+    return ins
+
+
+def _inspect(shell, inspectors, code):
+    "Run each inspector on the cell's transformed AST; return concatenated notes. An inspector may raise to block the cell."
+    if not inspectors: return ""
+    try: tree = ast.parse(shell.transform_cell(code))
+    except SyntaxError: return ""  # let the cell's own execution report the error
+    return "".join(note for f in inspectors if (note := f(tree)))
+
+
+def _execute(shell, inspectors, code):
     from fastcore.nbio import render_text
+    try: note = _inspect(shell, inspectors, code)
+    except Exception as e: return "blocked", _format_error("blocked", f"{type(e).__name__}: {e}")
     outputs = shell.run(code)
-    return ("error" if shell.exc else "ok"), render_text(outputs)
+    return ("error" if shell.exc else "ok"), note + render_text(outputs)
 
 
 def _request_exit(shell): shell._clikernel_exit = True
@@ -78,25 +102,24 @@ def _make_shell():
 def _should_exit(shell): return getattr(shell, "_clikernel_exit", False)
 
 
-def _disable_echo():
-    if not sys.stdin.isatty(): return None
-    fd = sys.stdin.fileno()
-    attrs = termios.tcgetattr(fd)
-    new_attrs = attrs[:]
-    new_attrs[3] &= ~termios.ECHO
-    termios.tcsetattr(fd, termios.TCSADRAIN, new_attrs)
-    return fd, attrs
-
+def _next_line(stdin):
+    "Read one line; when not a TTY, SIGINT while idle means 'interrupt execution', not 'kill the worker', so ignore it"
+    while True:
+        try: return stdin.readline()
+        except KeyboardInterrupt:
+            if stdin.isatty(): raise
 
-def _restore_echo(state):
-    if state: termios.tcsetattr(state[0], termios.TCSADRAIN, state[1])
 
-def _disable_output_newline_translation():
-    if not sys.__stdout__.isatty(): return None
-    fd = sys.__stdout__.fileno()
+def _tty_clear(stream, idx, mask, cc=None):
+    "Clear `mask` bits in termios field `idx` when `stream` is a TTY, with optional `cc` char overrides; returns state for `_restore_termios`"
+    if not stream.isatty(): return None
+    fd = stream.fileno()
     attrs = termios.tcgetattr(fd)
     new_attrs = attrs[:]
-    new_attrs[1] &= ~termios.ONLCR
+    new_attrs[idx] &= ~mask
+    if cc:
+        new_attrs[6] = attrs[6][:]
+        for k, v in cc.items(): new_attrs[6][k] = v
     termios.tcsetattr(fd, termios.TCSADRAIN, new_attrs)
     return fd, attrs
 
@@ -106,16 +129,25 @@ def _restore_termios(state):
 
 
 def main():
+    # Establish our own SIGINT disposition rather than inherit the parent's: a supervisor that ignores
+    # SIGINT would otherwise pass SIG_IGN down (inherited across exec), leaving this worker uninterruptible
+    signal.signal(signal.SIGINT, signal.default_int_handler)
     print("please wait, loading...", flush=True)
     _set_default_dirs()
     shell = _make_shell()
-    output_state = _disable_output_newline_translation()
-    echo_state = _disable_echo()
+    inspectors = _load_inspectors()
+    # ONLCR off so protocol output stays bare LF; ECHO off (echoed input corrupts the protocol) and ICANON
+    # off (canonical mode drops bytes past MAX_CANON with BEL spam; VMIN/VTIME make non-canonical reads
+    # return per byte; ISIG stays on so ^C still interrupts)
+    output_state = _tty_clear(sys.__stdout__, tty.OFLAG, termios.ONLCR)
+    echo_state = _tty_clear(sys.stdin, tty.LFLAG, termios.ECHO | termios.ICANON, {termios.VMIN: 1, termios.VTIME: 0})
     delim = _new_delim()
     print("loading complete. first delimiter:", flush=True)
     _write_response(delim)
     try:
-        for line in sys.stdin:
+        while True:
+            line = _next_line(sys.stdin)
+            if not line: break
             line = line.rstrip("\n")
             if line == _MULTILINE:
                 code, err = _read_block(sys.stdin, delim)
@@ -124,12 +156,12 @@ def main():
                     continue
             else: code = line
             print(".", flush=True)
-            try: _, outputs = _execute(shell, code)
+            try: _, outputs = _execute(shell, inspectors, code)
             except BaseException: outputs = _format_error("internal-error", traceback.format_exc())
             _write_response(delim, outputs)
             if _should_exit(shell): break
     finally:
-        _restore_echo(echo_state)
+        _restore_termios(echo_state)
         _restore_termios(output_state)
 
 

clikernel-0.1.4/clikernel/mcp.py

@@ -0,0 +1,129 @@
+"MCP server supervising a persistent `clikernel` CLI worker subprocess."
+import asyncio,atexit,os,signal,sys,traceback
+
+_MARKER = "loading complete. first delimiter:"
+_DIED = "NOTE: the kernel process had died; a fresh one was started, and all previous session state (imports, variables, monkeypatches) is gone.\n"
+_MULTILINE = "--"
+
+
+class _Worker:
+    def __init__(self):
+        self.proc,self.delim,self.started,self.busy,self.desynced = None,None,False,False,False
+        self.lock = asyncio.Lock()
+
+    def alive(self): return self.proc is not None and self.proc.returncode is None
+
+    async def start(self):
+        PIPE = asyncio.subprocess.PIPE
+        self.proc = await asyncio.create_subprocess_exec(sys.executable, "-m", "clikernel.cli", limit=2**24, stdin=PIPE, stdout=PIPE)
+        while True:
+            line = (await self.proc.stdout.readline()).decode()
+            if not line: raise RuntimeError("clikernel worker failed to start")
+            if line.rstrip("\n") == _MARKER: break
+        self.delim = (await self.proc.stdout.readline()).decode().rstrip("\n")
+        self.started,self.busy,self.desynced = True,False,False
+
+    async def kill(self):
+        if self.alive():
+            self.proc.kill()
+            await self.proc.wait()
+
+    async def run(self, code):
+        "Send `code`; return `(acked, body)`. `body` None means the worker died; retry is only safe if it never acked."
+        msg = f"{_MULTILINE}\n{code}\n{self.delim}\n" if "\n" in code or code == _MULTILINE else code + "\n"
+        try:
+            self.proc.stdin.write(msg.encode())
+            await self.proc.stdin.drain()
+        except Exception: return False, None  # write failed before the worker accepted anything: safe to retry
+        self.busy = True
+        try:
+            if not (await self.proc.stdout.readline()): return False, None  # "." ack
+            lines = []
+            while True:
+                line = (await self.proc.stdout.readline()).decode()
+                if not line: return True, None
+                if line.rstrip("\n") == self.delim: return True, "".join(lines).removesuffix("\n")
+                lines.append(line)
+        except asyncio.CancelledError:
+            self.desynced = True
+            raise
+        except Exception:
+            self.desynced = True  # unexpected read failure (e.g. a line past the buffer limit): rebuild on the next call
+            return True, None
+        finally: self.busy = False
+
+
+def _errbox(): return "<internal-error>\n" + traceback.format_exc() + "</internal-error>"
+
+
+def _kill_worker(w):
+    "Reap the worker child so it can never outlive the supervisor (signal-handler safe: no await)"
+    p = w.proc
+    if p is not None and p.returncode is None:
+        try: os.kill(p.pid, signal.SIGKILL)
+        except OSError: pass
+
+
+def _install_signal_guards(w):
+    "A stray group SIGINT must not fell the supervisor; SIGTERM/SIGHUP shut down cleanly, always taking the worker with us (never orphan it)"
+    signal.signal(signal.SIGINT, signal.SIG_IGN)
+    def _shutdown(signum, frame):
+        _kill_worker(w)
+        os._exit(0)
+    for s in (signal.SIGTERM, signal.SIGHUP):
+        try: signal.signal(s, _shutdown)
+        except (ValueError, OSError): pass  # platform lacks the signal, or not on the main thread
+    atexit.register(_kill_worker, w)
+
+
+def main():
+    from mcp.server.fastmcp import FastMCP
+    mcp = FastMCP("clikernel")
+    w = _Worker()
+    _install_signal_guards(w)
+
+    @mcp.tool(structured_output=False)
+    async def execute(code:str  # IPython-compatible code to run in the persistent session
+                     )->str:   # Rendered outputs (stdout, display data, last-expression result, errors)
+        "Run `code` in the persistent IPython session, keeping state across calls (imports, variables, monkeypatches, cached objects). If the kernel process has died since the last call, a fresh one is started automatically and the response notes that session state was lost."
+        try:
+            async with w.lock:
+                note = ""
+                if w.desynced: await w.kill()
+                if not w.alive():
+                    if w.started: note = _DIED
+                    await w.start()
+                acked, body = await w.run(code)
+                if body is None and not acked:  # died before accepting the request: safe to retry on a fresh worker
+                    note = _DIED
+                    await w.start()
+                    acked, body = await w.run(code)
+                if body is None:
+                    return note + "<internal-error>\nkernel process died while executing this request; a fresh kernel will be started on the next call, with all session state lost\n</internal-error>"
+                return note + body
+        except Exception:
+            w.desynced = True
+            return _errbox()
+
+    @mcp.tool(structured_output=False)
+    async def restart()->str:
+        "Kill the kernel process and start a fresh one: new pid, `sys.modules` genuinely reset, all session state (imports, variables, monkeypatches, cached objects) discarded. Use for a clean slate, after rebuilding a native extension, or after reloading a module that other already-imported modules had patched (symptoms: a stale-class bug where `isinstance`/`is` checks mysteriously fail, or a class is missing a method you know it has). Also works when `execute` is stuck: the stuck call returns an error and the kernel comes back fresh. After restarting, redo any imports/setup the task still needs."
+        try:
+            await w.kill()
+            async with w.lock: await w.start()
+            return "restarted"
+        except Exception: return _errbox()
+
+    @mcp.tool(structured_output=False)
+    async def interrupt()->str:
+        "Interrupt the code the kernel is currently running (SIGINT, i.e. KeyboardInterrupt): the in-flight `execute` call returns with a KeyboardInterrupt traceback, and session state survives. Prefer this over `restart` when a call is merely taking too long. Only meaningful while an `execute` call is running."
+        try:
+            if not (w.alive() and w.busy): return "nothing is running"
+            w.proc.send_signal(signal.SIGINT)
+            return "interrupt sent; the running `execute` call will return with a KeyboardInterrupt"
+        except Exception: return _errbox()
+
+    mcp.run()
+
+
+if __name__ == "__main__": main()

{clikernel-0.1.3 → clikernel-0.1.4}/clikernel/skill.py

@@ -13,7 +13,7 @@ There are two ways to drive it, depending on what the host supports:
 
 # MCP tools
 
-`execute`, `restart`, and `exit` are self-documenting -- read each tool's own MCP description rather than looking for docs elsewhere.
+`execute`, `restart`, and `interrupt` are self-documenting -- read each tool's own MCP description rather than looking for docs elsewhere. `restart` gives a genuinely fresh interpreter process (new pid, `sys.modules` reset); `interrupt` stops a too-long-running `execute` while keeping session state.
 
 # CLI protocol
 
@@ -45,7 +45,7 @@ Do not look for an IPython prompt, do not use `%cpaste`, and do not invent your
 
 Python exceptions render as normal notebook error output. Protocol/worker failures render with readable XML-ish error tags, then the session delimiter.
 
-To end the session, send `exit`. In CLI mode there is no `restart` tool -- starting a fresh process *is* the restart, and gives a genuinely fresh interpreter (the equivalent of the MCP `exit` tool).
+To end the session, send `exit`. In CLI mode there is no `restart` tool -- starting a fresh process *is* the restart, and gives a genuinely fresh interpreter (the equivalent of the MCP `restart` tool).
 
 # Notebook magics
 
@@ -85,7 +85,7 @@ Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty stream
 
 - Like Jupyter, only the *last* expression in a cell is printed/returned. `print(...)` any earlier value you need to see.
 - Don't re-run an `import` you've already run this session -- it's persistent, so it's already done. Use `importlib.reload` if you've changed a module and need the change picked up. If a previously-imported name raises `NameError`, the session restarted -- redo whatever imports/setup the task needs.
-- `importlib.reload`ing a module is not always enough to pick up a change: other already-imported modules that did `from x import *`, or that monkeypatched one of its classes (e.g. via fastcore's `@patch`), hold stale references that a targeted reload won't fix. If you hit a stale-class symptom (a class missing a method you know it has, `isinstance` mysteriously failing), you need a fresh interpreter process: the MCP `exit` tool (see the `restart`/`exit` tool descriptions for which does what), or in CLI mode, exit and start a new process.
+- `importlib.reload`ing a module is not always enough to pick up a change: other already-imported modules that did `from x import *`, or that monkeypatched one of its classes (e.g. via fastcore's `@patch`), hold stale references that a targeted reload won't fix. If you hit a stale-class symptom (a class missing a method you know it has, `isinstance` mysteriously failing), you need a fresh interpreter process: the MCP `restart` tool, or in CLI mode, exit and start a new process.
 - Everything a cell outputs lands in the conversation and stays there. Be surgical: inspect only what's needed, and don't dump large values -- `print(len(v))` first, then decide whether to print in full or filter down.
 - The kernel is scoped to one client session and shared by any subagents within it. If the server restarts or exits, in-memory state is gone -- redo imports and setup.
 

{clikernel-0.1.3 → clikernel-0.1.4/clikernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clikernel
-Version: 0.1.3
+Version: 0.1.4
 Summary: A tiny stdin/stdout IPython worker
 Author: clikernel contributors
 License: Apache-2.0
@@ -10,7 +10,8 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: execnb>=0.2.3
+Requires-Dist: execnb>=0.2.4
+Requires-Dist: fastcore
 Requires-Dist: mcp
 Provides-Extra: dev
 Requires-Dist: fastship; extra == "dev"
@@ -90,6 +91,14 @@ Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output
 
 `clikernel` sets quiet defaults for `IPYTHONDIR`, `MPLCONFIGDIR`, and `MPLBACKEND=Agg` before creating the shell. Existing `IPYTHONDIR` and `MPLCONFIGDIR` values are left alone. Loading messages and any startup warnings are printed before the first delimiter. Set `CLIKERNEL_STATE_DIR` to choose the default parent directory.
 
+## Inspectors
+
+`clikernel` can check each cell before it runs, to warn about or forbid certain code. On startup it loads inspectors from `$XDG_CONFIG_HOME/clikernel/inspectors.py` (usually `~/.config/clikernel/inspectors.py`). If that file is absent, nothing changes.
+
+Each cell is transformed first (so IPython magics and `!` shell escapes parse), and its AST is passed to every inspector before the cell executes. An inspector returns a string to prepend a note to the cell's output, raises to block the cell (it does not run, and the exception is reported), or returns None to do nothing. Define a function `inspect(tree)` and/or a list `inspectors` of such functions in the file. A broken `inspectors.py` is reported on stderr and skipped, so it cannot stop the kernel starting.
+
+See [`examples/inspectors.py`](examples/inspectors.py) for one that blocks `subprocess`, `os.system`/`os.popen`, and `!` escapes, steering the agent to the permission-checked Bash tool instead.
+
 ## Why The Protocol Is Odd
 
 `clikernel` is built for a client that reads stdout as tokens. Local echo is disabled when stdin is a TTY. The client already knows the code it sent, so echoing it back only makes the LLM read slow, expensive tokens that add no information.
@@ -120,3 +129,4 @@ ship-gh
 ship-pypi
 ship-bump  # dev release always later than prod release
 ```
+

{clikernel-0.1.3 → clikernel-0.1.4}/clikernel.egg-info/requires.txt

@@ -1,4 +1,5 @@
-execnb>=0.2.3
+execnb>=0.2.4
+fastcore
 mcp
 
 [dev]

{clikernel-0.1.3 → clikernel-0.1.4}/pyproject.toml

@@ -16,7 +16,8 @@ classifiers = [
 ]
 
 dependencies = [
-  "execnb>=0.2.3",
+  "execnb>=0.2.4",
+  "fastcore",
   "mcp",
 ]
 

{clikernel-0.1.3 → clikernel-0.1.4}/tests/test_cli.py

@@ -1,6 +1,4 @@
-import json,os,pty,re,select,shutil,subprocess,tempfile,time
-
-import pytest
+import json,os,pty,re,select,shutil,signal,subprocess,tempfile,time
 
 DELIM_RE = re.compile(r"--[A-Za-z0-9]{5}")
 TIMEOUT = 5
@@ -40,9 +38,7 @@ def read_until_ready(proc, timeout=TIMEOUT):
         lines.append(line)
 
 
-def start_kernel(tmp_path):
-    cmd = shutil.which("clikernel")
-    assert cmd, "clikernel console script is not on PATH"
+def _env(tmp_path):
     env = os.environ.copy()
     state = os.path.join(tempfile.gettempdir(), f"clikernel-{os.getuid()}")
     env["CLIKERNEL_STATE_DIR"] = str(tmp_path / "state")
@@ -50,6 +46,14 @@ def start_kernel(tmp_path):
     env.setdefault("MPLCONFIGDIR", os.path.join(state, "matplotlib"))
     env.setdefault("MPLBACKEND", "Agg")
     env["PYTHONUNBUFFERED"] = "1"
+    return env
+
+
+def start_kernel(tmp_path, extra_env=None):
+    cmd = shutil.which("clikernel")
+    assert cmd, "clikernel console script is not on PATH"
+    env = _env(tmp_path)
+    if extra_env: env.update(extra_env)
     proc = subprocess.Popen([cmd], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
     proc._stdout_buffer = bytearray()
     return proc
@@ -58,15 +62,8 @@ def start_kernel(tmp_path):
 def start_kernel_pty(tmp_path):
     cmd = shutil.which("clikernel")
     assert cmd, "clikernel console script is not on PATH"
-    env = os.environ.copy()
-    state = os.path.join(tempfile.gettempdir(), f"clikernel-{os.getuid()}")
-    env["CLIKERNEL_STATE_DIR"] = str(tmp_path / "state")
-    env.setdefault("IPYTHONDIR", os.path.join(state, "ipython"))
-    env.setdefault("MPLCONFIGDIR", os.path.join(state, "matplotlib"))
-    env.setdefault("MPLBACKEND", "Agg")
-    env["PYTHONUNBUFFERED"] = "1"
     master, slave = pty.openpty()
-    try: proc = subprocess.Popen([cmd], stdin=slave, stdout=slave, stderr=subprocess.PIPE, env=env, close_fds=True)
+    try: proc = subprocess.Popen([cmd], stdin=slave, stdout=slave, stderr=subprocess.PIPE, env=_env(tmp_path), close_fds=True)
     finally: os.close(slave)
     proc._pty_master = master
     proc._pty_buffer = bytearray()
@@ -122,6 +119,7 @@ def read_pty_until_ready(proc, timeout=TIMEOUT):
         if DELIM_RE.fullmatch(s): return "".join(lines), s
         lines.append(line)
 
+
 def _read_pty_rawline(proc, timeout):
     buf = proc._pty_buffer
     while b"\n" not in buf:
@@ -147,163 +145,141 @@ def read_pty_raw_until_ready(proc, timeout=TIMEOUT):
         body.extend(line)
 
 
-@pytest.fixture
-def kernel(tmp_path):
+NB_CELLS = [("aaa111", "x = 41\nprint('one')"),
+    ("bbb222", "#| export\nprint('two', x + 1)"),
+    ("ccc333", "print('three')")]
+
+def make_nb(path):
+    cells = [dict(cell_type="code", id=i, metadata={}, outputs=[], execution_count=None, source=src) for i,src in NB_CELLS]
+    path.write_text(json.dumps(dict(cells=cells, metadata={}, nbformat=4, nbformat_minor=5)))
+    return path
+
+
+def test_cli(tmp_path):
+    "One pipe-driven worker through the whole protocol, ending with exit(); then a fresh worker for quit()."
     proc = start_kernel(tmp_path)
     try:
         body, delim = read_until_ready(proc)
-        yield proc, body, delim
+        assert body == "please wait, loading...\nloading complete. first delimiter:\n"
+        assert DELIM_RE.fullmatch(delim)
+
+        # ack arrives before the result; result then same delimiter
+        proc.stdin.write(b"1+1\n")
+        proc.stdin.flush()
+        assert _readline(proc, TIMEOUT) == ".\n"
+        body, nd = read_until_ready(proc)
+        assert body == "2\n" and nd == delim
+
+        # state persists
+        assert send(proc, "x=41\n")[0] == ""
+        assert send(proc, "x+1\n")[0] == "42\n"
+
+        # multiline block; multiple outputs use xmlish blocks
+        assert send(proc, f"--\ndef f(x):\n    return x + 1\n\nf(41)\n{delim}\n")[0] == "42\n"
+        code = ("--\nfrom IPython.display import Markdown, display\nprint('hello')\n"
+            f"display(Markdown('**shown**'))\n42\n{delim}\n")
+        body, _ = send(proc, code)
+        assert '<stdout>\nhello\n</stdout>\n' in body
+        assert '<display_data mime="text/markdown">\n**shown**\n</display_data>\n' in body
+        assert '<execute_result>\n42\n</execute_result>\n' in body
+
+        # errors: clean, single traceback, no ansi, genuine stdout preserved
+        body, nd = send(proc, "1/0\n")
+        assert "ZeroDivisionError" in body and nd == delim
+        assert "\x1b[" not in body and body.count("ZeroDivisionError") == 1 and "<stdout>" not in body
+        body, _ = send(proc, f"--\nprint('before')\n1/0\n{delim}\n")
+        assert "<stdout>\nbefore\n</stdout>" in body and body.count("ZeroDivisionError") == 1
+
+        assert send(proc, "get_ipython().history_manager.enabled\n")[0] == "False\n"
+
+        # SIGINT: ignored while idle (non-tty); interrupts running code
+        time.sleep(0.2)
+        proc.send_signal(signal.SIGINT)
+        time.sleep(0.2)
+        assert proc.poll() is None
+        assert send(proc, "1+1\n")[0] == "2\n"
+        proc.stdin.write(b"import time; time.sleep(30)\n")
+        proc.stdin.flush()
+        assert _readline(proc, TIMEOUT) == ".\n"
+        time.sleep(0.3)
+        proc.send_signal(signal.SIGINT)
+        body, _ = read_until_ready(proc)
+        assert "KeyboardInterrupt" in body
+        assert send(proc, "1+1\n")[0] == "2\n"
+
+        # notebook magics
+        nb = make_nb(tmp_path/"t.ipynb")
+        assert "error" not in send(proc, f"%nbopen {nb}\n")[0].lower()
+        body, _ = send(proc, "%nbrun aaa\n")
+        assert "--- aaa111 ---" in body and "one" in body
+        body, _ = send(proc, "%nbrun bbb222 --above\n")
+        assert "one" in body and "two 42" in body
+        body, _ = send(proc, "%nbrun --all --exported\n")
+        assert "two 42" in body and "one" not in body and "three" not in body
+
+        # exit(): empty body, final delimiter, clean stop
+        body, nd = send(proc, "exit()\n")
+        assert body == "" and nd == delim
+        proc.wait(timeout=TIMEOUT)
+        assert proc.returncode == 0
     finally: stop_kernel(proc)
 
-
-def test_startup_prints_valid_ready_delimiter(kernel):
-    _, body, delim = kernel
-    assert body == "please wait, loading...\nloading complete. first delimiter:\n"
-    assert DELIM_RE.fullmatch(delim)
-
-
-def test_single_line_request_returns_result_and_same_delimiter(kernel):
-    proc, _, delim = kernel
-    body, next_delim = send(proc, "1+1\n")
-    assert body == "2\n"
-    assert DELIM_RE.fullmatch(next_delim)
-    assert next_delim == delim
+    proc = start_kernel(tmp_path)
+    try:
+        _, delim = read_until_ready(proc)
+        body, nd = send(proc, "quit()\n")
+        assert body == "" and nd == delim
+        proc.wait(timeout=TIMEOUT)
+        assert proc.returncode == 0
+    finally: stop_kernel(proc)
 
 
-def test_tty_input_is_not_echoed_after_startup(tmp_path):
+def test_cli_tty(tmp_path):
+    "One pty-driven worker: input isn't echoed, and output newlines stay LF (no ONLCR CR)."
     proc = start_kernel_pty(tmp_path)
     try:
         body, delim = read_pty_until_ready(proc)
         assert body == "please wait, loading...\nloading complete. first delimiter:\n"
         os.write(proc._pty_master, b"1+1\n")
         assert _read_ptyline(proc, TIMEOUT) == ".\n"
-        body, next_delim = read_pty_until_ready(proc)
-        assert body == "2\n"
-        assert next_delim == delim
-    finally: stop_kernel(proc)
-
-def test_tty_output_keeps_newlines_as_lf(tmp_path):
-    proc = start_kernel_pty(tmp_path)
-    try:
-        _, delim = read_pty_until_ready(proc)
+        body, nd = read_pty_until_ready(proc)
+        assert body == "2\n" and nd == delim
         os.write(proc._pty_master, b"print('hello')\n")
-        body, next_delim, raw_delim = read_pty_raw_until_ready(proc)
+        body, nd2, raw_delim = read_pty_raw_until_ready(proc)
         assert body == b".\nhello\n"
-        assert raw_delim == next_delim.encode() + b"\n"
+        assert raw_delim == nd2.encode() + b"\n"
         assert b"\r" not in body + raw_delim
-        assert next_delim == delim
-    finally: stop_kernel(proc)
-
-
-def test_request_ack_is_written_before_result(kernel):
-    proc, _, delim = kernel
-    assert proc.stdin is not None
-    proc.stdin.write(b"1+1\n")
-    proc.stdin.flush()
-    assert _readline(proc, TIMEOUT) == ".\n"
-    body, next_delim = read_until_ready(proc)
-    assert body == "2\n"
-    assert next_delim == delim
-
-
-def test_state_persists_across_requests(kernel):
-    proc, _, _ = kernel
-    body, _ = send(proc, "x=41\n")
-    assert body == ""
-    body, _ = send(proc, "x+1\n")
-    assert body == "42\n"
-
-
-def test_multiline_request_uses_current_delimiter(kernel):
-    proc, _, delim = kernel
-    body, _ = send(proc, f"--\ndef f(x):\n    return x + 1\n\nf(41)\n{delim}\n")
-    assert body == "42\n"
-
-
-def test_multiple_outputs_use_xmlish_blocks(kernel):
-    proc, _, delim = kernel
-    code = (
-        "--\n"
-        "from IPython.display import Markdown, display\n"
-        "print('hello')\n"
-        "display(Markdown('**shown**'))\n"
-        "42\n"
-        f"{delim}\n")
-    body, _ = send(proc, code)
-    assert '<stdout>\nhello\n</stdout>\n' in body
-    assert '<display_data mime="text/markdown">\n**shown**\n</display_data>\n' in body
-    assert '<execute_result>\n42\n</execute_result>\n' in body
-
-
-def test_runtime_errors_return_error_text_and_same_delimiter(kernel):
-    proc, _, delim = kernel
-    body, next_delim = send(proc, "1/0\n")
-    assert "ZeroDivisionError" in body
-    assert DELIM_RE.fullmatch(next_delim)
-    assert next_delim == delim
-
-
-def test_error_has_no_ansi_and_no_duplicate_traceback(kernel):
-    proc, _, _ = kernel
-    body, _ = send(proc, "1/0\n")
-    assert "\x1b[" not in body                    # no ANSI colour codes
-    assert body.count("ZeroDivisionError") == 1   # single traceback, not duplicated
-    assert "<stdout>" not in body                 # no captured stdout traceback copy
+        assert nd2 == delim
 
-
-def test_error_preserves_real_stdout(kernel):
-    proc, _, delim = kernel
-    body, _ = send(proc, f"--\nprint('before')\n1/0\n{delim}\n")
-    assert "<stdout>\nbefore\n</stdout>" in body   # genuine prints kept
-    assert body.count("ZeroDivisionError") == 1
-
-
-@pytest.mark.parametrize("cmd", ["exit()", "quit()"])
-def test_exit_request_returns_final_delimiter_and_stops_process(kernel, cmd):
-    proc, _, start_delim = kernel
-    body, delim = send(proc, f"{cmd}\n")
-    assert body == ""
-    assert DELIM_RE.fullmatch(delim)
-    assert delim == start_delim
-    proc.wait(timeout=TIMEOUT)
-    assert proc.returncode == 0
-
-
-def test_history_is_disabled(kernel):
-    proc, _, _ = kernel
-    body, _ = send(proc, "get_ipython().history_manager.enabled\n")
-    assert body == "False\n"
-
-
-NB_CELLS = [("aaa111", "x = 41\nprint('one')"),
-            ("bbb222", "#| export\nprint('two', x + 1)"),
-            ("ccc333", "print('three')")]
-
-def make_nb(path):
-    cells = [dict(cell_type="code", id=i, metadata={}, outputs=[], execution_count=None, source=src)
-             for i,src in NB_CELLS]
-    path.write_text(json.dumps(dict(cells=cells, metadata={}, nbformat=4, nbformat_minor=5)))
-    return path
+        # long lines must survive the pty: canonical mode drops bytes past MAX_CANON and spams BEL
+        os.write(proc._pty_master, f"--\ns = 'b' * 2\ns += 'b{'b' * 5000}'\nlen(s)\n{delim}\n".encode())
+        assert _read_ptyline(proc, TIMEOUT) == ".\n"
+        body, nd = read_pty_until_ready(proc)
+        assert body == "5003\n" and nd == delim
+    finally: stop_kernel(proc)
 
 
-def test_nbopen_nbrun_magics(kernel, tmp_path):
-    proc, _, _ = kernel
-    nb = make_nb(tmp_path/"t.ipynb")
-    body, _ = send(proc, f"%nbopen {nb}\n")
-    assert "error" not in body.lower()
-    body, _ = send(proc, "%nbrun aaa\n")
-    assert "--- aaa111 ---" in body
-    assert "one" in body
-    body, _ = send(proc, "%nbrun bbb222 --above\n")
-    assert "one" in body and "two 42" in body
-    body, _ = send(proc, "%nbrun --all --exported\n")
-    assert "two 42" in body and "one" not in body and "three" not in body
-
-
-def test_nbrun_fname_arg_sets_default(kernel, tmp_path):
-    proc, _, _ = kernel
-    nb = make_nb(tmp_path/"t.ipynb")
-    body, _ = send(proc, f"%nbrun aaa --fname {nb}\n")
-    assert "one" in body
-    body, _ = send(proc, "%nbrun ccc\n")
-    assert "three" in body
+INSPECTORS_SRC = r'''
+import ast
+def inspect(tree):
+    for n in ast.walk(tree):
+        if isinstance(n, ast.Import) and any(a.name == "subprocess" for a in n.names):
+            return "<reminder>\nuse the Bash tool, not subprocess\n</reminder>\n"
+        if isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id == "blockme":
+            raise RuntimeError("blocked by policy")
+'''
+
+def test_cli_inspectors(tmp_path):
+    "Inspectors loaded from XDG inspectors.py: a returned note is prepended to output, and a raising inspector blocks the cell before it runs."
+    xdg = tmp_path/"xdg"
+    (xdg/"clikernel").mkdir(parents=True)
+    (xdg/"clikernel"/"inspectors.py").write_text(INSPECTORS_SRC)
+    proc = start_kernel(tmp_path, {"XDG_CONFIG_HOME": str(xdg)})
+    try:
+        read_until_ready(proc)
+        body, _ = send(proc, "import subprocess\n")
+        assert "use the Bash tool" in body                         # note prepended, cell still ran (no error)
+        assert send(proc, "1+1\n")[0] == "2\n"                     # unrelated cell: no note
+        body, _ = send(proc, "blockme()\n")
+        assert "blocked by policy" in body and "NameError" not in body  # blocked before running
+    finally: stop_kernel(proc)

clikernel-0.1.4/tests/test_mcp.py

@@ -0,0 +1,106 @@
+import asyncio, json, os, shutil, signal, sys, tempfile
+import pytest
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from clikernel.mcp import _Worker, _install_signal_guards, _kill_worker
+
+
+def _server_params():
+    cmd = shutil.which("clikernel-mcp")
+    args = [] if cmd else ["-m", "clikernel.mcp"]
+    cmd = cmd or sys.executable
+    env = dict(os.environ, CLIKERNEL_STATE_DIR=tempfile.mkdtemp(prefix="clikernel-mcp-test-"))
+    return StdioServerParameters(command=cmd, args=args, env=env)
+
+
+async def _text(s, name, **args):
+    res = await s.call_tool(name, args)
+    return res.content[0].text if res.content else ""
+
+
+@pytest.mark.anyio
+async def test_mcp(tmp_path):
+    "One server through everything: execute semantics, magics, restart, interrupt, and worker-death recovery."
+    async with stdio_client(_server_params()) as (r, w), ClientSession(r, w) as s:
+        await s.initialize()
+        assert {t.name for t in (await s.list_tools()).tools} == {"execute", "restart", "interrupt"}
+
+        # execute: results, top-level await, state, xmlish outputs, clean errors
+        assert await _text(s, "execute", code="40+2") == "42"
+        assert await _text(s, "execute", code="import asyncio\nawait asyncio.sleep(0)\n42") == "42"
+        await _text(s, "execute", code="x = 41")
+        assert await _text(s, "execute", code="x + 1") == "42"
+        r_ = await _text(s, "execute", code="print('hi'); 99")
+        assert "<stdout>\nhi\n</stdout>" in r_ and "<execute_result>\n99\n</execute_result>" in r_
+        r_ = await _text(s, "execute", code="1/0")
+        assert "ZeroDivisionError" in r_ and "\x1b[" not in r_ and r_.count("ZeroDivisionError") == 1
+
+        # notebook magics
+        cells = [dict(cell_type="code", id="aaa111", metadata={}, outputs=[], execution_count=None, source="print('one')")]
+        nb = tmp_path/"t.ipynb"
+        nb.write_text(json.dumps(dict(cells=cells, metadata={}, nbformat=4, nbformat_minor=5)))
+        await _text(s, "execute", code=f"%nbopen {nb}")
+        r_ = await _text(s, "execute", code="%nbrun aaa")
+        assert "--- aaa111 ---" in r_ and "one" in r_
+
+        # restart: clean return, fresh pid, sys.modules genuinely reset, kernel usable
+        pid1 = int(await _text(s, "execute", code="import os, sys; sys.modules['fakemod'] = sys; os.getpid()"))
+        assert await _text(s, "restart") == "restarted"
+        pid2 = int(await _text(s, "execute", code="import os; os.getpid()"))
+        assert pid2 != pid1
+        assert await _text(s, "execute", code="import sys; 'fakemod' in sys.modules") == "False"
+        assert "NameError" in await _text(s, "execute", code="x")
+
+        # interrupt: idle reports so; a running execute returns KeyboardInterrupt and state survives
+        assert "nothing" in (await _text(s, "interrupt")).lower()
+        task = asyncio.create_task(s.call_tool("execute", {"code": "import time; time.sleep(30); 'fin'+'ished'"}))
+        await asyncio.sleep(1)
+        assert "interrupt" in (await _text(s, "interrupt")).lower()
+        out = (await task).content[0].text
+        assert "KeyboardInterrupt" in out and "finished" not in out
+        assert await _text(s, "execute", code="40+2") == "42"
+
+        # exit() run as code recycles the worker: next call notes lost state
+        await _text(s, "execute", code="exit()")
+        r_ = await _text(s, "execute", code="40+2")
+        assert "42" in r_ and "state" in r_
+
+        # externally killed while idle: next call self-heals with a note
+        pid3 = int(await _text(s, "execute", code="import os; os.getpid()"))
+        os.kill(pid3, signal.SIGKILL)
+        r_ = await _text(s, "execute", code="40+2")
+        assert "42" in r_ and "state" in r_
+
+        # killed mid-execute: that call reports the death; the next one recovers
+        pid4 = int(await _text(s, "execute", code="import os; os.getpid()"))
+        task = asyncio.create_task(s.call_tool("execute", {"code": "import time; time.sleep(30)"}))
+        await asyncio.sleep(1)
+        os.kill(pid4, signal.SIGKILL)
+        assert "died" in (await task).content[0].text
+        r_ = await _text(s, "execute", code="40+2")
+        assert "42" in r_
+
+
+@pytest.mark.anyio
+async def test_supervisor_guards(monkeypatch, tmp_path):
+    "SIGINT can't fell the supervisor, SIGTERM/SIGHUP get a clean-shutdown handler, and the worker child is reaped so it never outlives us."
+    monkeypatch.setenv("CLIKERNEL_STATE_DIR", str(tmp_path))
+    orig = {s: signal.getsignal(s) for s in (signal.SIGINT, signal.SIGTERM, signal.SIGHUP)}
+    w = _Worker()
+    try:
+        await w.start()
+        pid = w.proc.pid
+        _install_signal_guards(w)
+        assert signal.getsignal(signal.SIGINT) is signal.SIG_IGN
+        for s in (signal.SIGTERM, signal.SIGHUP):
+            assert callable(signal.getsignal(s)) and signal.getsignal(s) not in (signal.SIG_DFL, signal.SIG_IGN)
+        _kill_worker(w)
+        await w.proc.wait()
+        with pytest.raises(ProcessLookupError): os.kill(pid, 0)
+    finally:
+        for s, h in orig.items(): signal.signal(s, h)
+        await w.kill()
+
+
+@pytest.fixture
+def anyio_backend(): return "asyncio"

clikernel-0.1.3/clikernel/__init__.py

@@ -1,4 +0,0 @@
-__version__ = "0.1.3"
-
-
-

clikernel-0.1.3/clikernel/mcp.py

@@ -1,37 +0,0 @@
-"MCP server exposing a persistent IPython `CaptureShell` as an `execute` tool."
-import asyncio
-
-from clikernel.cli import _set_default_dirs, _make_shell
-
-
-def main():
-    _set_default_dirs()
-    from mcp.server.fastmcp import FastMCP
-    from fastcore.nbio import render_text
-    mcp = FastMCP("clikernel")
-    state = {"shell": _make_shell(), "lock": asyncio.Lock()}
-
-    @mcp.tool(structured_output=False)
-    async def execute(code:str  # IPython-compatible code to run in the persistent session
-                     )->str:   # Rendered outputs (stdout, display data, last-expression result, errors)
-        "Run `code` in the persistent IPython session, keeping state across calls (imports, variables, monkeypatches, cached objects)."
-        async with state["lock"]:
-            outputs = await asyncio.to_thread(state["shell"].run, code)
-            return render_text(outputs)
-
-    @mcp.tool(structured_output=False)
-    async def restart()->str:
-        "Discard all session state (imports, variables, monkeypatches, cached objects) and start a fresh IPython shell inside the same server process. Use this for the common case: a bad variable, a half-finished experiment to abandon, or a user-requested clean slate. Note: this does NOT touch `sys.modules` or anything already monkeypatched (e.g. via fastcore's `@patch`) -- those live at the process level, not the shell level, and survive `restart` untouched. If you need a genuinely fresh interpreter (e.g. after reloading a module that other already-imported modules had patched -- symptoms: a stale-class bug where `isinstance`/`is` checks mysteriously fail, or a class is missing a method you know it has), use `exit` instead. After restarting, redo any imports/setup the task still needs."
-        async with state["lock"]: state["shell"] = _make_shell()
-        return "restarted"
-
-    @mcp.tool(structured_output=False)
-    async def exit()->str:
-        "Terminate this MCP server process immediately, for when `restart` isn't enough (see its docstring). This call itself will error (\"Connection closed\") since the process dies before it can respond -- that's expected, not a failure. The next `execute` call transparently reconnects to a freshly-spawned process with `sys.modules` genuinely reset (confirmed via a new pid), no manual reconnect needed. After reconnecting, redo any imports/setup the task still needs."
-        import os
-        os._exit(0)
-
-    mcp.run()
-
-
-if __name__ == "__main__": main()

clikernel-0.1.3/tests/test_mcp.py

@@ -1,91 +0,0 @@
-import os,shutil,sys,tempfile
-
-import pytest
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
-
-
-def _server_params():
-    cmd = shutil.which("clikernel-mcp")
-    args = [] if cmd else ["-m", "clikernel.mcp"]
-    cmd = cmd or sys.executable
-    env = dict(os.environ, CLIKERNEL_STATE_DIR=tempfile.mkdtemp(prefix="clikernel-mcp-test-"))
-    return StdioServerParameters(command=cmd, args=args, env=env)
-
-
-async def _drive(codes):
-    "Run each code string through the execute tool in one session; return result texts."
-    async with stdio_client(_server_params()) as (r,w), ClientSession(r,w) as s:
-        await s.initialize()
-        out = []
-        for c in codes:
-            res = await s.call_tool("execute", {"code": c})
-            out.append(res.content[0].text if res.content else "")
-        return out
-
-
-async def _drive_ops(ops):
-    "Run a mix of ('execute', code) / ('restart',) ops in one session; return result texts."
-    async with stdio_client(_server_params()) as (r,w), ClientSession(r,w) as s:
-        await s.initialize()
-        out = []
-        for op in ops:
-            name, args = (op[0], {"code": op[1]}) if op[0] == "execute" else (op[0], {})
-            res = await s.call_tool(name, args)
-            out.append(res.content[0].text if res.content else "")
-        return out
-
-
-@pytest.mark.anyio
-async def test_execute_returns_result(): assert await _drive(["40+2"]) == ["42"]
-
-
-@pytest.mark.anyio
-async def test_execute_supports_top_level_await():
-    r = await _drive(["import asyncio\nawait asyncio.sleep(0)\n42"])
-    assert r == ["42"]
-
-
-@pytest.mark.anyio
-async def test_state_persists_across_calls(): assert (await _drive(["x = 41", "x + 1"]))[1] == "42"
-
-
-@pytest.mark.anyio
-async def test_multiple_outputs_use_xmlish_blocks():
-    r = (await _drive(["print('hi'); 99"]))[0]
-    assert "<stdout>\nhi\n</stdout>" in r
-    assert "<execute_result>\n99\n</execute_result>" in r
-
-
-@pytest.mark.anyio
-async def test_error_is_clean():
-    r = (await _drive(["1/0"]))[0]
-    assert "ZeroDivisionError" in r
-    assert "\x1b[" not in r
-    assert r.count("ZeroDivisionError") == 1
-
-
-@pytest.mark.anyio
-async def test_restart_clears_state():
-    r = await _drive_ops([("execute","x = 1"), ("restart",), ("execute","x")])
-    assert "NameError" in r[2]
-
-
-@pytest.mark.anyio
-async def test_restart_leaves_kernel_usable():
-    r = await _drive_ops([("execute","x = 1"), ("restart",), ("execute","40+2")])
-    assert r[2] == "42"
-
-
-@pytest.mark.anyio
-async def test_nb_magics(tmp_path):
-    import json
-    cells = [dict(cell_type="code", id="aaa111", metadata={}, outputs=[], execution_count=None, source="print('one')")]
-    nb = tmp_path/"t.ipynb"
-    nb.write_text(json.dumps(dict(cells=cells, metadata={}, nbformat=4, nbformat_minor=5)))
-    r = await _drive([f"%nbopen {nb}", "%nbrun aaa"])
-    assert "--- aaa111 ---" in r[1] and "one" in r[1]
-
-
-@pytest.fixture
-def anyio_backend(): return "asyncio"