clikernel 0.1.0__tar.gz → 0.1.2__tar.gz

clikernel-0.1.2/CHANGELOG.md

@@ -0,0 +1,20 @@
+<!-- do not remove -->
+
+## 0.1.2
+
+### New Features
+
+- Add ONLCR terminal flag control ([#2](https://github.com/AnswerDotAI/clikernel/issues/2))
+
+
+## 0.1.1
+
+### New Features
+
+- Use a fixed per-session delimiter and emit `.` ack before each response ([#1](https://github.com/AnswerDotAI/clikernel/issues/1))
+
+
+## 0.1.0
+
+- Initial release
+

{clikernel-0.1.0/clikernel.egg-info → clikernel-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clikernel
-Version: 0.1.0
+Version: 0.1.2
 Summary: A tiny stdin/stdout IPython worker
 Author: clikernel contributors
 License: Apache-2.0
@@ -34,7 +34,7 @@ This is especially useful with [pyskills](https://github.com/AnswerDotAI/pyskill
 
 ## Protocol
 
-On startup, `clikernel` prints loading status followed by a fresh ready delimiter:
+On startup, `clikernel` prints loading status followed by a random session delimiter:
 
 ```text
 please wait, loading...
@@ -42,13 +42,17 @@ loading complete. first delimiter:
 --aB3x9
 ```
 
+That delimiter stays the same until the worker exits.
+
 Send one line to execute it immediately:
 
 ```text
 1+1
 ```
 
-For multiline code, send `--` on its own line, then the code, then the latest ready delimiter exactly:
+Each complete request is acknowledged with `.` before execution starts. Send `exit()` or `quit()` to receive an acknowledgement, a final delimiter, and stop the worker.
+
+For multiline code, send `--` on its own line, then the code, then the session delimiter exactly:
 
 ```text
 --
@@ -59,11 +63,12 @@ f(2)
 --aB3x9
 ```
 
-After execution, `clikernel` prints the rendered output followed by a new ready delimiter:
+After execution, `clikernel` prints the acknowledgement, the rendered output, and the session delimiter:
 
 ```text
+.
 3
---Q7z2M
+--aB3x9
 ```
 
 Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output is printed directly. Multiple outputs use raw XML-ish tags, for example `<stdout>`, `<display_data mime="text/markdown">`, and `<execute_result>`.
@@ -74,7 +79,7 @@ Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output
 
 `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.
 
-Each response ends with a delimiter on its own line. The client can read until that line appears instead of parsing prompts or waiting and guessing. The delimiter changes after every request. This matters for multiline input, where the current delimiter is also the block terminator. A random current delimiter is unlikely to appear in generated code, copied logs, examples, or earlier transcript text. Old delimiters stop working as soon as the next response is printed.
+Each complete request prints `.` on its own line before execution starts. That gives the client a cheap early byte to read, which is useful when the request will run for a while. Each response ends with the same delimiter on its own line. The client can read until that line appears instead of parsing prompts or waiting and guessing. The delimiter is random per process, so it is unlikely to appear in generated code, copied logs, examples, or earlier transcript text. Keeping it fixed for the session means a client does not get stuck just because it missed a rotated delimiter.
 
 Startup messages appear before the first delimiter. After that first delimiter, the stream follows the request-response protocol. Outputs are rendered as concise text, using unescaped XML if required when there's multiple outputs.
 
@@ -100,4 +105,3 @@ ship-gh
 ship-pypi
 ship-bump  # dev release always later than prod release
 ```
-

{clikernel-0.1.0 → clikernel-0.1.2}/README.md

@@ -14,7 +14,7 @@ This is especially useful with [pyskills](https://github.com/AnswerDotAI/pyskill
 
 ## Protocol
 
-On startup, `clikernel` prints loading status followed by a fresh ready delimiter:
+On startup, `clikernel` prints loading status followed by a random session delimiter:
 
 ```text
 please wait, loading...
@@ -22,13 +22,17 @@ loading complete. first delimiter:
 --aB3x9
 ```
 
+That delimiter stays the same until the worker exits.
+
 Send one line to execute it immediately:
 
 ```text
 1+1
 ```
 
-For multiline code, send `--` on its own line, then the code, then the latest ready delimiter exactly:
+Each complete request is acknowledged with `.` before execution starts. Send `exit()` or `quit()` to receive an acknowledgement, a final delimiter, and stop the worker.
+
+For multiline code, send `--` on its own line, then the code, then the session delimiter exactly:
 
 ```text
 --
@@ -39,11 +43,12 @@ f(2)
 --aB3x9
 ```
 
-After execution, `clikernel` prints the rendered output followed by a new ready delimiter:
+After execution, `clikernel` prints the acknowledgement, the rendered output, and the session delimiter:
 
 ```text
+.
 3
---Q7z2M
+--aB3x9
 ```
 
 Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output is printed directly. Multiple outputs use raw XML-ish tags, for example `<stdout>`, `<display_data mime="text/markdown">`, and `<execute_result>`.
@@ -54,7 +59,7 @@ Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output
 
 `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.
 
-Each response ends with a delimiter on its own line. The client can read until that line appears instead of parsing prompts or waiting and guessing. The delimiter changes after every request. This matters for multiline input, where the current delimiter is also the block terminator. A random current delimiter is unlikely to appear in generated code, copied logs, examples, or earlier transcript text. Old delimiters stop working as soon as the next response is printed.
+Each complete request prints `.` on its own line before execution starts. That gives the client a cheap early byte to read, which is useful when the request will run for a while. Each response ends with the same delimiter on its own line. The client can read until that line appears instead of parsing prompts or waiting and guessing. The delimiter is random per process, so it is unlikely to appear in generated code, copied logs, examples, or earlier transcript text. Keeping it fixed for the session means a client does not get stuck just because it missed a rotated delimiter.
 
 Startup messages appear before the first delimiter. After that first delimiter, the stream follows the request-response protocol. Outputs are rendered as concise text, using unescaped XML if required when there's multiple outputs.
 
@@ -80,4 +85,3 @@ ship-gh
 ship-pypi
 ship-bump  # dev release always later than prod release
 ```
-

clikernel-0.1.2/clikernel/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.1.2"
+
+

{clikernel-0.1.0 → clikernel-0.1.2}/clikernel/cli.py

@@ -48,9 +48,18 @@ def _execute(shell, code):
     return ("error" if shell.exc else "ok"), render_text(outputs)
 
 
+def _request_exit(shell): shell._clikernel_exit = True
+
+
 def _make_shell():
     from execnb.shell import CaptureShell
-    return CaptureShell(mpl_format=None, history=False)
+    shell = CaptureShell(mpl_format=None, history=False)
+    shell._clikernel_exit = False
+    shell.ask_exit = lambda: _request_exit(shell)
+    return shell
+
+
+def _should_exit(shell): return getattr(shell, "_clikernel_exit", False)
 
 
 def _disable_echo():
@@ -66,10 +75,24 @@ def _disable_echo():
 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()
+    attrs = termios.tcgetattr(fd)
+    new_attrs = attrs[:]
+    new_attrs[1] &= ~termios.ONLCR
+    termios.tcsetattr(fd, termios.TCSADRAIN, new_attrs)
+    return fd, attrs
+
+
+def _restore_termios(state):
+    if state: termios.tcsetattr(state[0], termios.TCSADRAIN, state[1])
+
 
 def main():
-    echo_state = _disable_echo()
     shell = _make_shell()
+    output_state = _disable_output_newline_translation()
+    echo_state = _disable_echo()
     delim = _new_delim()
     print("loading complete. first delimiter:", flush=True)
     _write_response(delim)
@@ -79,15 +102,17 @@ def main():
             if line == _MULTILINE:
                 code, err = _read_block(sys.stdin, delim)
                 if err:
-                    delim = _new_delim()
                     _write_response(delim, _format_error("protocol-error", err))
                     continue
             else: code = line
+            print(".", flush=True)
             try: _, outputs = _execute(shell, code)
             except BaseException: outputs = _format_error("internal-error", traceback.format_exc())
-            delim = _new_delim()
             _write_response(delim, outputs)
-    finally: _restore_echo(echo_state)
+            if _should_exit(shell): break
+    finally:
+        _restore_echo(echo_state)
+        _restore_termios(output_state)
 
 
 if __name__ == "__main__": main()

{clikernel-0.1.0 → clikernel-0.1.2/clikernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clikernel
-Version: 0.1.0
+Version: 0.1.2
 Summary: A tiny stdin/stdout IPython worker
 Author: clikernel contributors
 License: Apache-2.0
@@ -34,7 +34,7 @@ This is especially useful with [pyskills](https://github.com/AnswerDotAI/pyskill
 
 ## Protocol
 
-On startup, `clikernel` prints loading status followed by a fresh ready delimiter:
+On startup, `clikernel` prints loading status followed by a random session delimiter:
 
 ```text
 please wait, loading...
@@ -42,13 +42,17 @@ loading complete. first delimiter:
 --aB3x9
 ```
 
+That delimiter stays the same until the worker exits.
+
 Send one line to execute it immediately:
 
 ```text
 1+1
 ```
 
-For multiline code, send `--` on its own line, then the code, then the latest ready delimiter exactly:
+Each complete request is acknowledged with `.` before execution starts. Send `exit()` or `quit()` to receive an acknowledgement, a final delimiter, and stop the worker.
+
+For multiline code, send `--` on its own line, then the code, then the session delimiter exactly:
 
 ```text
 --
@@ -59,11 +63,12 @@ f(2)
 --aB3x9
 ```
 
-After execution, `clikernel` prints the rendered output followed by a new ready delimiter:
+After execution, `clikernel` prints the acknowledgement, the rendered output, and the session delimiter:
 
 ```text
+.
 3
---Q7z2M
+--aB3x9
 ```
 
 Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output is printed directly. Multiple outputs use raw XML-ish tags, for example `<stdout>`, `<display_data mime="text/markdown">`, and `<execute_result>`.
@@ -74,7 +79,7 @@ Outputs are rendered with `fastcore.nbio.render_text`. A single non-empty output
 
 `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.
 
-Each response ends with a delimiter on its own line. The client can read until that line appears instead of parsing prompts or waiting and guessing. The delimiter changes after every request. This matters for multiline input, where the current delimiter is also the block terminator. A random current delimiter is unlikely to appear in generated code, copied logs, examples, or earlier transcript text. Old delimiters stop working as soon as the next response is printed.
+Each complete request prints `.` on its own line before execution starts. That gives the client a cheap early byte to read, which is useful when the request will run for a while. Each response ends with the same delimiter on its own line. The client can read until that line appears instead of parsing prompts or waiting and guessing. The delimiter is random per process, so it is unlikely to appear in generated code, copied logs, examples, or earlier transcript text. Keeping it fixed for the session means a client does not get stuck just because it missed a rotated delimiter.
 
 Startup messages appear before the first delimiter. After that first delimiter, the stream follows the request-response protocol. Outputs are rendered as concise text, using unescaped XML if required when there's multiple outputs.
 
@@ -100,4 +105,3 @@ ship-gh
 ship-pypi
 ship-bump  # dev release always later than prod release
 ```
-

clikernel-0.1.2/tests/test_cli.py

@@ -0,0 +1,260 @@
+import os,pty,re,select,shutil,subprocess,tempfile,time
+
+import pytest
+
+DELIM_RE = re.compile(r"--[A-Za-z0-9]{5}")
+TIMEOUT = 5
+
+
+def _failure_detail(proc):
+    if proc.stderr is None: return ""
+    ready, _, _ = select.select([proc.stderr], [], [], 0)
+    if not ready: return ""
+    err = os.read(proc.stderr.fileno(), 65536).decode("utf-8", "replace")
+    return f"\nstderr:\n{err}" if err else ""
+
+
+def _readline(proc, timeout):
+    assert proc.stdout is not None
+    buf = proc._stdout_buffer
+    while b"\n" not in buf:
+        ready, _, _ = select.select([proc.stdout], [], [], timeout)
+        if not ready: raise AssertionError(f"timed out waiting for clikernel output{_failure_detail(proc)}")
+        chunk = os.read(proc.stdout.fileno(), 4096)
+        assert chunk, _failure_detail(proc)
+        buf.extend(chunk)
+    line, _, rest = buf.partition(b"\n")
+    proc._stdout_buffer = bytearray(rest)
+    return line.decode("utf-8", "replace") + "\n"
+
+
+def read_until_ready(proc, timeout=TIMEOUT):
+    lines = []
+    deadline = time.monotonic() + timeout
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0: raise AssertionError(f"timed out waiting for ready delimiter{_failure_detail(proc)}")
+        line = _readline(proc, remaining)
+        s = line.rstrip("\n")
+        if DELIM_RE.fullmatch(s): return "".join(lines), s
+        lines.append(line)
+
+
+def start_kernel(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"
+    proc = subprocess.Popen([cmd], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
+    proc._stdout_buffer = bytearray()
+    return proc
+
+
+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)
+    finally: os.close(slave)
+    proc._pty_master = master
+    proc._pty_buffer = bytearray()
+    return proc
+
+
+def stop_kernel(proc):
+    if proc.stdin is not None:
+        try: proc.stdin.close()
+        except OSError: pass
+    if hasattr(proc, "_pty_master"):
+        try: os.close(proc._pty_master)
+        except OSError: pass
+    if proc.poll() is None:
+        try: proc.wait(timeout=1)
+        except subprocess.TimeoutExpired:
+            proc.terminate()
+            try: proc.wait(timeout=1)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait(timeout=1)
+
+
+def send(proc, text, timeout=TIMEOUT):
+    assert proc.stdin is not None
+    proc.stdin.write(text.encode("utf-8"))
+    proc.stdin.flush()
+    assert _readline(proc, timeout) == ".\n"
+    return read_until_ready(proc, timeout)
+
+
+def _read_ptyline(proc, timeout):
+    buf = proc._pty_buffer
+    while b"\n" not in buf:
+        ready, _, _ = select.select([proc._pty_master], [], [], timeout)
+        if not ready: raise AssertionError(f"timed out waiting for clikernel pty output{_failure_detail(proc)}")
+        chunk = os.read(proc._pty_master, 4096)
+        assert chunk, _failure_detail(proc)
+        buf.extend(chunk)
+    line, _, rest = buf.partition(b"\n")
+    proc._pty_buffer = bytearray(rest)
+    return line.decode("utf-8", "replace").rstrip("\r") + "\n"
+
+
+def read_pty_until_ready(proc, timeout=TIMEOUT):
+    lines = []
+    deadline = time.monotonic() + timeout
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0: raise AssertionError(f"timed out waiting for ready delimiter{_failure_detail(proc)}")
+        line = _read_ptyline(proc, remaining)
+        s = line.rstrip("\n")
+        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:
+        ready, _, _ = select.select([proc._pty_master], [], [], timeout)
+        if not ready: raise AssertionError(f"timed out waiting for clikernel pty output{_failure_detail(proc)}")
+        chunk = os.read(proc._pty_master, 4096)
+        assert chunk, _failure_detail(proc)
+        buf.extend(chunk)
+    line, _, rest = buf.partition(b"\n")
+    proc._pty_buffer = bytearray(rest)
+    return bytes(line + b"\n")
+
+
+def read_pty_raw_until_ready(proc, timeout=TIMEOUT):
+    body = bytearray()
+    deadline = time.monotonic() + timeout
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0: raise AssertionError(f"timed out waiting for ready delimiter{_failure_detail(proc)}")
+        line = _read_pty_rawline(proc, remaining)
+        s = line.rstrip(b"\r\n").decode("utf-8", "replace")
+        if DELIM_RE.fullmatch(s): return bytes(body), s, line
+        body.extend(line)
+
+
+@pytest.fixture
+def kernel(tmp_path):
+    proc = start_kernel(tmp_path)
+    try:
+        body, delim = read_until_ready(proc)
+        yield proc, body, delim
+    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
+
+
+def test_tty_input_is_not_echoed_after_startup(tmp_path):
+    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)
+        os.write(proc._pty_master, b"print('hello')\n")
+        body, next_delim, raw_delim = read_pty_raw_until_ready(proc)
+        assert body == b".\nhello\n"
+        assert raw_delim == next_delim.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
+
+
+@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"

clikernel-0.1.0/CHANGELOG.md

@@ -1,6 +0,0 @@
-<!-- do not remove -->
-
-## 0.1.0
-
-- Initial release
-

clikernel-0.1.0/clikernel/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

clikernel-0.1.0/tests/test_cli.py

@@ -1,142 +0,0 @@
-import os,re,select,shutil,subprocess,tempfile,time
-
-import pytest
-
-DELIM_RE = re.compile(r"--[A-Za-z0-9]{5}")
-TIMEOUT = 5
-
-
-def _failure_detail(proc):
-    if proc.stderr is None: return ""
-    ready, _, _ = select.select([proc.stderr], [], [], 0)
-    if not ready: return ""
-    err = os.read(proc.stderr.fileno(), 65536).decode("utf-8", "replace")
-    return f"\nstderr:\n{err}" if err else ""
-
-
-def _readline(proc, timeout):
-    assert proc.stdout is not None
-    buf = proc._stdout_buffer
-    while b"\n" not in buf:
-        ready, _, _ = select.select([proc.stdout], [], [], timeout)
-        if not ready: raise AssertionError(f"timed out waiting for clikernel output{_failure_detail(proc)}")
-        chunk = os.read(proc.stdout.fileno(), 4096)
-        assert chunk, _failure_detail(proc)
-        buf.extend(chunk)
-    line, _, rest = buf.partition(b"\n")
-    proc._stdout_buffer = bytearray(rest)
-    return line.decode("utf-8", "replace") + "\n"
-
-
-def read_until_ready(proc, timeout=TIMEOUT):
-    lines = []
-    deadline = time.monotonic() + timeout
-    while True:
-        remaining = deadline - time.monotonic()
-        if remaining <= 0: raise AssertionError(f"timed out waiting for ready delimiter{_failure_detail(proc)}")
-        line = _readline(proc, remaining)
-        s = line.rstrip("\n")
-        if DELIM_RE.fullmatch(s): return "".join(lines), s
-        lines.append(line)
-
-
-def start_kernel(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"
-    proc = subprocess.Popen([cmd], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
-    proc._stdout_buffer = bytearray()
-    return proc
-
-
-def stop_kernel(proc):
-    if proc.stdin is not None:
-        try: proc.stdin.close()
-        except OSError: pass
-    if proc.poll() is None:
-        try: proc.wait(timeout=1)
-        except subprocess.TimeoutExpired:
-            proc.terminate()
-            try: proc.wait(timeout=1)
-            except subprocess.TimeoutExpired:
-                proc.kill()
-                proc.wait(timeout=1)
-
-
-def send(proc, text, timeout=TIMEOUT):
-    assert proc.stdin is not None
-    proc.stdin.write(text.encode("utf-8"))
-    proc.stdin.flush()
-    return read_until_ready(proc, timeout)
-
-
-@pytest.fixture
-def kernel(tmp_path):
-    proc = start_kernel(tmp_path)
-    try:
-        body, delim = read_until_ready(proc)
-        yield proc, body, delim
-    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_fresh_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
-
-
-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_fresh_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_history_is_disabled(kernel):
-    proc, _, _ = kernel
-    body, _ = send(proc, "get_ipython().history_manager.enabled\n")
-    assert body == "False\n"