turnloop 0.1.4__tar.gz → 0.1.5__tar.gz

{turnloop-0.1.4 → turnloop-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turnloop
-Version: 0.1.4
+Version: 0.1.5
 Summary: A local-first agentic coding harness: streaming tool loop, permission gating, context compaction, subagents, and any LLM provider.
 Project-URL: Homepage, https://github.com/Pranesh-2005/turnloop
 Author: Pranesh
@@ -49,7 +49,7 @@ tl experiment run smoke         # a measurement run, offline and free
 
 Four runtime dependencies: `textual`, `pydantic`, `httpx`, `pyyaml`. No vendor
 SDKs, no agent framework — the loop is the point, so the loop is written here.
-~18,000 lines of Python, 255 tests, no network in the default test run.
+~18,000 lines of Python, 290 tests, no network in the default test run.
 
 ---
 
@@ -117,7 +117,7 @@ point.
 Verify:
 
 ```bash
-tl --version                # turnloop 0.1.4
+tl --version                # turnloop 0.1.5
 tl doctor                   # every provider, key presence, shell, context budget
 ```
 
@@ -869,11 +869,34 @@ and through session JSONL, so a `--resume`d conversation does not hit the same w
 check, and anyone who pointed 0.1.2 at Gemini got one working tool call and then a
 400. Fixed in 0.1.3.
 
-**The lesson, four times over in one project:** an 84-run sweep failing while printing
+### `NoActiveWorker`: 283 green tests and a crash on the first keystroke
+
+The config UI shipped with tests covering `/config` — they asserted that dispatching it
+returned `open_screen="config"`. All 283 passed. Typing `/config` in the actual TUI
+raised `NoActiveWorker: push_screen must be run from a worker`.
+
+Textual's `push_screen_wait` blocks the calling coroutine until the screen is dismissed,
+so it must run inside a worker; called from the message pump it would deadlock the pump
+it is waiting on, and Textual refuses rather than hanging. `_handle_command` runs on the
+pump. So does Textual's action dispatch, which meant the same defect existed at four
+call sites, not the one in the traceback — including the provider form reachable from
+`tl config --edit`, a path the crash report never touched.
+
+The correct pattern was eleven lines away in the same file: `_permission_worker` is
+`@work`-decorated, which is exactly why *its* `push_screen_wait` works.
+
+Two things this cost, both worth stating. The tests verified the layer *below* the bug —
+that the command produced the right instruction, never that the app could carry it out.
+And **0.1.4 shipped this way**, so `pip install turnloop==0.1.4` crashes on `/config`.
+Fixed in 0.1.5. The tests now drive a real app through Textual's `run_test()` pilot and
+fail if the decorators are removed.
+
+**The lesson, five times over in one project:** an 84-run sweep failing while printing
 a tidy report of zeros; a tool returning empty with `ok: true`; a sweep sitting at
 10/18 doing nothing for 25 minutes; an adapter passing its live test and failing on
-the turn the test never made. Each was caught only by looking past the summary line —
-and the last one only by using the thing instead of testing it.
+the turn the test never made; a feature with green tests that crashed on its first
+keystroke. Each was caught only by looking past the summary line — and the last two
+only by using the thing instead of testing it.
 
 ---
 
@@ -907,7 +930,7 @@ one-line edit in a CRLF checkout does not produce a whole-file diff.
 ## Testing
 
 ```bash
-pytest                    # 283 tests, no network
+pytest                    # 290 tests, no network
 ruff check turnloop
 mypy turnloop
 ```
@@ -926,7 +949,7 @@ mypy turnloop
 | `test_configio.py` | 15 | minimal-diff writes, atomic save, secret-bearing MCP targets, the settings deny rules |
 | `test_config_screen.py` | 10 | provider form validation, caps derivation, env indicator leaks |
 | `test_websearch.py` | 9 | HTML parsing, backend selection, truncation, failure modes |
-| `test_tui.py` | 8 | Textual snapshots |
+| `test_tui.py` | 15 | Textual snapshots, `/config` and `/mcp add` driven through a real app |
 
 `conftest.py` monkeypatches httpx's transport to raise unless a test is marked
 `live` — **network is off at the transport layer**, so a forgotten real call fails

{turnloop-0.1.4 → turnloop-0.1.5}/README.md

@@ -20,7 +20,7 @@ tl experiment run smoke         # a measurement run, offline and free
 
 Four runtime dependencies: `textual`, `pydantic`, `httpx`, `pyyaml`. No vendor
 SDKs, no agent framework — the loop is the point, so the loop is written here.
-~18,000 lines of Python, 255 tests, no network in the default test run.
+~18,000 lines of Python, 290 tests, no network in the default test run.
 
 ---
 
@@ -88,7 +88,7 @@ point.
 Verify:
 
 ```bash
-tl --version                # turnloop 0.1.4
+tl --version                # turnloop 0.1.5
 tl doctor                   # every provider, key presence, shell, context budget
 ```
 
@@ -840,11 +840,34 @@ and through session JSONL, so a `--resume`d conversation does not hit the same w
 check, and anyone who pointed 0.1.2 at Gemini got one working tool call and then a
 400. Fixed in 0.1.3.
 
-**The lesson, four times over in one project:** an 84-run sweep failing while printing
+### `NoActiveWorker`: 283 green tests and a crash on the first keystroke
+
+The config UI shipped with tests covering `/config` — they asserted that dispatching it
+returned `open_screen="config"`. All 283 passed. Typing `/config` in the actual TUI
+raised `NoActiveWorker: push_screen must be run from a worker`.
+
+Textual's `push_screen_wait` blocks the calling coroutine until the screen is dismissed,
+so it must run inside a worker; called from the message pump it would deadlock the pump
+it is waiting on, and Textual refuses rather than hanging. `_handle_command` runs on the
+pump. So does Textual's action dispatch, which meant the same defect existed at four
+call sites, not the one in the traceback — including the provider form reachable from
+`tl config --edit`, a path the crash report never touched.
+
+The correct pattern was eleven lines away in the same file: `_permission_worker` is
+`@work`-decorated, which is exactly why *its* `push_screen_wait` works.
+
+Two things this cost, both worth stating. The tests verified the layer *below* the bug —
+that the command produced the right instruction, never that the app could carry it out.
+And **0.1.4 shipped this way**, so `pip install turnloop==0.1.4` crashes on `/config`.
+Fixed in 0.1.5. The tests now drive a real app through Textual's `run_test()` pilot and
+fail if the decorators are removed.
+
+**The lesson, five times over in one project:** an 84-run sweep failing while printing
 a tidy report of zeros; a tool returning empty with `ok: true`; a sweep sitting at
 10/18 doing nothing for 25 minutes; an adapter passing its live test and failing on
-the turn the test never made. Each was caught only by looking past the summary line —
-and the last one only by using the thing instead of testing it.
+the turn the test never made; a feature with green tests that crashed on its first
+keystroke. Each was caught only by looking past the summary line — and the last two
+only by using the thing instead of testing it.
 
 ---
 
@@ -878,7 +901,7 @@ one-line edit in a CRLF checkout does not produce a whole-file diff.
 ## Testing
 
 ```bash
-pytest                    # 283 tests, no network
+pytest                    # 290 tests, no network
 ruff check turnloop
 mypy turnloop
 ```
@@ -897,7 +920,7 @@ mypy turnloop
 | `test_configio.py` | 15 | minimal-diff writes, atomic save, secret-bearing MCP targets, the settings deny rules |
 | `test_config_screen.py` | 10 | provider form validation, caps derivation, env indicator leaks |
 | `test_websearch.py` | 9 | HTML parsing, backend selection, truncation, failure modes |
-| `test_tui.py` | 8 | Textual snapshots |
+| `test_tui.py` | 15 | Textual snapshots, `/config` and `/mcp add` driven through a real app |
 
 `conftest.py` monkeypatches httpx's transport to raise unless a test is marked
 `live` — **network is off at the transport layer**, so a forgotten real call fails

{turnloop-0.1.4 → turnloop-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "turnloop"
-version = "0.1.4"
+version = "0.1.5"
 description = "A local-first agentic coding harness: streaming tool loop, permission gating, context compaction, subagents, and any LLM provider."
 readme = "README.md"
 requires-python = ">=3.11"

turnloop-0.1.5/tests/test_tui.py

@@ -0,0 +1,397 @@
+"""TUI tests driven through Textual's pilot.
+
+The assertions worth having here are about the concurrency contract, not about
+pixels: a turn runs without blocking the UI, a permission prompt reaches the modal
+and its answer reaches the parked agent task, and typing during a turn queues
+rather than being dropped.
+"""
+
+from __future__ import annotations
+
+from turnloop.providers.mock import MockProvider, ScriptTurn
+from turnloop.tui.app import TurnloopApp
+from turnloop.tui.widgets.status import StatusBar
+from turnloop.tui.widgets.transcript import Transcript
+
+
+def app_with(settings, project, turns) -> TurnloopApp:
+    app = TurnloopApp(settings=settings, cwd=project, resume=None)
+    # Swap in a scripted provider; the loop holds the reference.
+    provider = MockProvider(mode="scripted", script=turns)
+    app.agent.provider = provider
+    app.agent.loop.provider = provider
+    return app
+
+
+async def test_a_turn_streams_into_the_transcript(settings, project):
+    app = app_with(settings, project, [ScriptTurn(text="Hello from the model.")])
+    async with app.run_test() as pilot:
+        await pilot.press(*"hi")
+        await pilot.press("enter")
+        await pilot.pause()
+        for _ in range(40):
+            await pilot.pause()
+            if not app._busy:
+                break
+        rendered = _transcript_text(app)
+        assert "Hello from the model." in rendered
+        assert "› hi" in rendered
+
+
+async def test_a_permission_prompt_reaches_the_modal_and_unblocks_the_agent(settings, project):
+    """The agent task parks on ask(); the UI stays live and answers it."""
+    app = app_with(
+        settings,
+        project,
+        [
+            ScriptTurn(tools=[("Write", {"file_path": "made.txt", "content": "x"})]),
+            ScriptTurn(text="Created it."),
+        ],
+    )
+    async with app.run_test() as pilot:
+        await pilot.press(*"go")
+        await pilot.press("enter")
+
+        for _ in range(60):
+            await pilot.pause()
+            if app.screen is not app.screen_stack[0]:
+                break
+        assert app.screen is not app.screen_stack[0], "the modal never appeared"
+
+        await pilot.press("y")
+        for _ in range(80):
+            await pilot.pause()
+            if not app._busy:
+                break
+
+        assert (project / "made.txt").exists()
+        assert "Created it." in _transcript_text(app)
+
+
+async def test_declining_a_prompt_leaves_the_file_alone(settings, project):
+    app = app_with(
+        settings,
+        project,
+        [
+            ScriptTurn(tools=[("Write", {"file_path": "nope.txt", "content": "x"})]),
+            ScriptTurn(text="Understood."),
+        ],
+    )
+    async with app.run_test() as pilot:
+        await pilot.press(*"go")
+        await pilot.press("enter")
+        for _ in range(60):
+            await pilot.pause()
+            if app.screen is not app.screen_stack[0]:
+                break
+        await pilot.press("n")
+        for _ in range(80):
+            await pilot.pause()
+            if not app._busy:
+                break
+    assert not (project / "nope.txt").exists()
+
+
+async def test_typing_during_a_turn_queues_the_message(settings, project):
+    app = app_with(
+        settings,
+        project,
+        [ScriptTurn(text="first"), ScriptTurn(text="second")],
+    )
+    async with app.run_test() as pilot:
+        app._busy = True  # simulate an in-flight turn
+        await pilot.press(*"later")
+        await pilot.press("enter")
+        await pilot.pause()
+        assert app._queued == ["later"]
+        assert "queued" in _transcript_text(app)
+
+
+async def test_slash_command_runs_without_reaching_the_model(settings, project):
+    app = app_with(settings, project, [ScriptTurn(text="unused")])
+    async with app.run_test() as pilot:
+        await pilot.press(*"/tools")
+        await pilot.press("enter")
+        await pilot.pause()
+        await pilot.pause()
+        assert "TodoWrite" in _transcript_text(app)
+        assert app.agent.provider.calls == 0
+
+
+async def test_ctrl_p_cycles_permission_mode(settings, project):
+    app = app_with(settings, project, [ScriptTurn(text="x")])
+    async with app.run_test() as pilot:
+        assert app.query_one(StatusBar).mode == "default"
+        await pilot.press("ctrl+p")
+        await pilot.pause()
+        assert app.query_one(StatusBar).mode == "plan"
+        assert app.agent.permissions.mode == "plan"
+
+
+async def test_status_bar_reports_the_context_gauge(settings, project):
+    app = app_with(settings, project, [ScriptTurn(text="done")])
+    async with app.run_test() as pilot:
+        await pilot.press(*"hi")
+        await pilot.press("enter")
+        for _ in range(40):
+            await pilot.pause()
+            if not app._busy:
+                break
+        status = app.query_one(StatusBar)
+        assert status.context_tokens > 0
+        assert status.tokens_out > 0
+
+
+async def test_cold_boot_panel_appears_and_clears(settings, project):
+    from turnloop.core.events import ProviderStatus, StatusUpdate
+    from turnloop.tui.widgets.status import BootPanel
+
+    app = app_with(settings, project, [ScriptTurn(text="x")])
+    async with app.run_test() as pilot:
+        boot = app.query_one("#boot", BootPanel)
+        assert not boot.display
+
+        await app.channel.send(ProviderStatus("cold boot", phase="cold_boot", elapsed_s=95))
+        await pilot.pause()
+        await pilot.pause()
+        assert boot.display
+        assert "01:35" in str(boot.render())
+
+        await app.channel.send(StatusUpdate(context_tokens=10, context_max=100))
+        await pilot.pause()
+        await pilot.pause()
+        assert not boot.display
+
+
+async def test_slash_config_opens_and_dismisses_the_settings_screen(settings, project):
+    """`/config` used to raise `NoActiveWorker` on the very first keystroke:
+    `_handle_command` runs on the message pump, and `push_screen_wait` deadlocks
+    that pump unless it runs inside a Textual worker. This drives the real app —
+    the dispatch-level test alone (`outcome.open_screen == "config"`) already
+    passed while this was broken, because nothing ever consumed the outcome.
+    """
+    from turnloop.tui.config_screen import ConfigScreen
+
+    app = app_with(settings, project, [ScriptTurn(text="unused")])
+    async with app.run_test() as pilot:
+        base_screen = app.screen_stack[0]
+        await pilot.press(*"/config")
+        await pilot.press("enter")
+
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is not base_screen:
+                break
+        assert isinstance(app.screen, ConfigScreen), "the config screen never appeared"
+
+        await pilot.press("escape")
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is base_screen:
+                break
+        assert app.screen is base_screen, "dismissing the screen must return to the main screen"
+
+
+async def test_config_screen_add_provider_opens_the_provider_form(settings, project):
+    """`ConfigScreen.action_add_provider` (key `a`) has the identical
+    `push_screen_wait`-outside-a-worker defect as `/config` itself — a
+    different call path (Textual's action dispatch, not `_handle_command`) but
+    the same bug. This confirms the standalone `tl config --edit` screen (which
+    is this exact class) does not crash on first use either.
+    """
+    from textual.widgets import Button, DataTable
+
+    from turnloop.tui.config_screen import ConfigScreen, ProviderFormModal
+
+    app = app_with(settings, project, [ScriptTurn(text="unused")])
+    async with app.run_test() as pilot:
+        base_screen = app.screen_stack[0]
+        await pilot.press(*"/config")
+        await pilot.press("enter")
+        for _ in range(40):
+            await pilot.pause()
+            if isinstance(app.screen, ConfigScreen):
+                break
+        config_screen = app.screen
+        assert isinstance(config_screen, ConfigScreen)
+
+        config_screen.set_focus(config_screen.query_one("#providers-table", DataTable))
+        await pilot.pause()
+        await pilot.press("a")
+
+        for _ in range(40):
+            await pilot.pause()
+            if isinstance(app.screen, ProviderFormModal):
+                break
+        assert isinstance(app.screen, ProviderFormModal), "the provider form never appeared"
+
+        app.screen.query_one("#pcancel", Button).press()
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is config_screen:
+                break
+        assert app.screen is config_screen
+
+        await pilot.press("escape")
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is base_screen:
+                break
+        assert app.screen is base_screen
+
+
+async def test_slash_mcp_add_opens_and_dismisses_the_server_form(settings, project):
+    from textual.widgets import Button
+
+    from turnloop.tui.mcp_screen import ServerFormModal
+
+    app = app_with(settings, project, [ScriptTurn(text="unused")])
+    async with app.run_test() as pilot:
+        base_screen = app.screen_stack[0]
+        await pilot.press(*"/mcp add")
+        await pilot.press("enter")
+
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is not base_screen:
+                break
+        assert isinstance(app.screen, ServerFormModal), "the mcp add form never appeared"
+
+        app.screen.query_one("#cancel", Button).press()
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is base_screen:
+                break
+        assert app.screen is base_screen
+
+
+async def test_mcp_editor_app_action_add_opens_the_server_form():
+    """The standalone `tl mcp` app has its own `action_add` binding, dispatched
+    through the exact same Textual action-dispatch path as `/config`'s bug —
+    confirms the fix covers `McpEditorApp` too, not just the in-TUI path."""
+    from textual.widgets import Button
+
+    from turnloop.config import default_settings
+    from turnloop.tui.mcp_screen import McpEditorApp, ServerFormModal
+
+    app = McpEditorApp(default_settings())
+    async with app.run_test() as pilot:
+        base_screen = app.screen_stack[0]
+        await pilot.press("a")
+
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is not base_screen:
+                break
+        assert isinstance(app.screen, ServerFormModal), "the mcp add form never appeared"
+
+        app.screen.query_one("#cancel", Button).press()
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is base_screen:
+                break
+        assert app.screen is base_screen
+
+
+async def test_escape_in_provider_form_returns_to_config_screen_only(settings, project):
+    """Escape must dismiss only the top modal (`ProviderFormModal`), landing back
+    on `ConfigScreen` — which is itself still open, not also dismissed by the
+    same keypress bubbling into its own escape binding.
+    """
+    from textual.widgets import DataTable
+
+    from turnloop.tui.config_screen import ConfigScreen, ProviderFormModal
+
+    app = app_with(settings, project, [ScriptTurn(text="unused")])
+    async with app.run_test() as pilot:
+        base_screen = app.screen_stack[0]
+        await pilot.press(*"/config")
+        await pilot.press("enter")
+        for _ in range(40):
+            await pilot.pause()
+            if isinstance(app.screen, ConfigScreen):
+                break
+        config_screen = app.screen
+        assert isinstance(config_screen, ConfigScreen)
+
+        config_screen.set_focus(config_screen.query_one("#providers-table", DataTable))
+        await pilot.pause()
+        await pilot.press("a")
+        for _ in range(40):
+            await pilot.pause()
+            if isinstance(app.screen, ProviderFormModal):
+                break
+        assert isinstance(app.screen, ProviderFormModal), "the provider form never appeared"
+
+        await pilot.press("escape")
+        for _ in range(40):
+            await pilot.pause()
+            if app.screen is not None and not isinstance(app.screen, ProviderFormModal):
+                break
+
+        assert app.screen is config_screen, "escape must land back on ConfigScreen, still open"
+        assert app.screen is not base_screen, "a single escape must not also close ConfigScreen"
+
+
+async def test_escape_in_mcp_editor_add_form_returns_to_the_table_without_quitting(settings, project):
+    """`McpEditorApp` binds its own top-level escape to `action_quit_app`. Without
+    a binding on `ServerFormModal` itself, an unhandled escape bubbles straight
+    past the modal to that App binding and quits the whole standalone `tl mcp`
+    screen — a materially worse bug than "escape does nothing".
+    """
+    from turnloop.config import default_settings
+    from turnloop.tui.mcp_screen import McpEditorApp, ServerFormModal
+
+    app = McpEditorApp(default_settings())
+    async with app.run_test() as pilot:
+        base_screen = app.screen_stack[0]
+        await pilot.press("a")
+        for _ in range(40):
+            await pilot.pause()
+            if isinstance(app.screen, ServerFormModal):
+                break
+        assert isinstance(app.screen, ServerFormModal), "the mcp add form never appeared"
+
+        await pilot.press("escape")
+        for _ in range(40):
+            await pilot.pause()
+            if not isinstance(app.screen, ServerFormModal):
+                break
+
+        assert app.is_running, "escape must close only the form, not quit the app"
+        assert app.screen is base_screen, "escape must land back on the server table"
+
+
+async def test_escape_in_mcp_add_form_returns_to_the_main_tui_screen(settings, project):
+    """`/mcp add` pushes `ServerFormModal` straight onto the main `TurnloopApp`
+    screen (no intermediate `McpEditorApp`) — escape there must return to the
+    running session, not exit turnloop or leave the modal stuck.
+    """
+    from turnloop.tui.mcp_screen import ServerFormModal
+
+    app = app_with(settings, project, [ScriptTurn(text="unused")])
+    async with app.run_test() as pilot:
+        base_screen = app.screen_stack[0]
+        await pilot.press(*"/mcp add")
+        await pilot.press("enter")
+        for _ in range(40):
+            await pilot.pause()
+            if isinstance(app.screen, ServerFormModal):
+                break
+        assert isinstance(app.screen, ServerFormModal), "the mcp add form never appeared"
+
+        await pilot.press("escape")
+        for _ in range(40):
+            await pilot.pause()
+            if not isinstance(app.screen, ServerFormModal):
+                break
+
+        assert app.is_running, "escape must not quit the running session"
+        assert app.screen is base_screen, "escape must return to the main TUI screen"
+
+
+def _transcript_text(app: TurnloopApp) -> str:
+    transcript = app.query_one(Transcript)
+    from textual.widgets import Static
+
+    return "\n".join(str(w.render()) for w in transcript.query(Static))

{turnloop-0.1.4 → turnloop-0.1.5}/turnloop/__init__.py

@@ -1,3 +1,3 @@
 """turnloop — a local-first agentic coding harness."""
 
-__version__ = "0.1.4"
+__version__ = "0.1.5"

{turnloop-0.1.4 → turnloop-0.1.5}/turnloop/tui/app.py

@@ -295,16 +295,32 @@ class TurnloopApp(App):
             else:
                 self._start_turn(outcome.prompt)
         if outcome.open_screen == "config":
-            await self._open_config_screen()
+            # Fire-and-forget: `_open_config_screen` is a `@work`-decorated
+            # method, so calling it returns a Worker (not a coroutine) and
+            # runs the body — including its `push_screen_wait` — inside real
+            # worker context. Everything the result needs (the transcript
+            # note, applying the patch) already happens inside that worker;
+            # `_handle_command` itself has nothing left to do afterwards, so
+            # there is nothing here worth `.wait()`-ing on.
+            self._open_config_screen()
         elif outcome.open_screen == "mcp_add":
-            await self._open_mcp_add_screen()
+            self._open_mcp_add_screen()
 
     # --- settings screens ---------------------------------------------------
     #
     # Reached only from `_handle_command`, which is reached only from the
     # human's Input widget (see CommandOutcome.open_screen's docstring for the
     # full argument). Nothing here is importable from a tool.
-
+    #
+    # Both are `@work`-decorated for the same reason `_permission_worker`
+    # (above) is: `push_screen_wait` blocks the calling coroutine while
+    # keeping the event loop alive, which requires running inside a Textual
+    # worker or it deadlocks the very message pump it is waiting on
+    # (`NoActiveWorker`). `_handle_command` runs directly on that pump, so it
+    # cannot call `push_screen_wait` itself — it has to hand the work to one
+    # of these instead.
+
+    @work(exclusive=False, thread=False, name="config-screen")
     async def _open_config_screen(self) -> None:
         from turnloop.tui.config_screen import ConfigScreen
 
@@ -319,6 +335,7 @@ class TurnloopApp(App):
             message += f" — restart turnloop to apply: {', '.join(restart_for)}"
         await transcript.add_note(message)
 
+    @work(exclusive=False, thread=False, name="mcp-add-screen")
     async def _open_mcp_add_screen(self) -> None:
         from turnloop.config import MCPServerConfig
         from turnloop.configio import local_settings_path, write_mcp_server

{turnloop-0.1.4 → turnloop-0.1.5}/turnloop/tui/config_screen.py

@@ -22,6 +22,7 @@ import os
 from pathlib import Path
 from typing import Any
 
+from textual import work
 from textual.app import App, ComposeResult
 from textual.containers import Horizontal, VerticalScroll
 from textual.screen import ModalScreen
@@ -116,6 +117,15 @@ def build_provider_dict(existing: dict[str, Any], *, kind: str, model: str,
 class ProviderFormModal(ModalScreen[dict | None]):
     """Add or edit one provider. Dismisses with `{"name": ..., "provider": {...}}` or None."""
 
+    # Bound here, on the modal itself, rather than left to bubble: this is the
+    # active screen while the form is open, so Textual checks its BINDINGS
+    # before anything below it in the stack (`ConfigScreen`, which also binds
+    # escape) or the App. Without this, escape here is at best a dead key and
+    # at worst reaches a parent App's own escape binding — `McpEditorApp`
+    # binds escape to quit. Consuming it here keeps the behavior identical
+    # regardless of which screen pushed this one.
+    BINDINGS = [("escape", "cancel", "Cancel")]
+
     CSS = """
     ProviderFormModal { align: center middle; }
     #pform { width: 92%; max-width: 100; height: auto; max-height: 92%;
@@ -172,10 +182,13 @@ class ProviderFormModal(ModalScreen[dict | None]):
 
     def on_button_pressed(self, event: Button.Pressed) -> None:
         if event.button.id == "pcancel":
-            self.dismiss(None)
+            self.action_cancel()
         else:
             self._save()
 
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
     def _error(self, message: str) -> None:
         self.query_one("#pstatus", Static).update(message)
 
@@ -313,6 +326,11 @@ class ConfigScreen(ModalScreen[tuple[Path, dict] | None]):
             return None
         return self._provider_names[table.cursor_row]
 
+    # `push_screen_wait` requires worker context or it deadlocks the message
+    # pump that key-bound actions dispatch on (`NoActiveWorker`). `@work`
+    # makes calling these return a Worker instead of running inline; Textual's
+    # action dispatch handles that fine (see `textual._callback.invoke`).
+    @work(exclusive=False, thread=False, name="provider-add")
     async def action_add_provider(self) -> None:
         result = await self.app.push_screen_wait(
             ProviderFormModal("", None, set(self._providers))
@@ -321,6 +339,7 @@ class ConfigScreen(ModalScreen[tuple[Path, dict] | None]):
             self._providers[result["name"]] = result["provider"]
             self._reload_providers_table()
 
+    @work(exclusive=False, thread=False, name="provider-edit")
     async def action_edit_provider(self) -> None:
         name = self._selected_provider_name()
         if not name: