kiwi-code 0.0.436__tar.gz → 0.0.436.dev1__tar.gz

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.436
+Version: 0.0.436.dev1
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.436"
+version = "0.0.436.dev1"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_cli/commands.py

@@ -283,7 +283,6 @@ Session:
   /continue <run_id>    Continue an existing run
   /new                  Start new conversation
   /status               Show current action & run
-  /cancel               Cancel active request
 
 Files:
   /upload <path> [...]  Upload file(s), attach to next message

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_cli/terminal_mode.py

@@ -16,14 +16,10 @@ from kiwi_cli.models import AppConfig, LoginCredentials
 from kiwi_cli.server import http_url_from_server, server_from_backend_url
 from kiwi_tui.runtime_agent import (
     RuntimeConnectArgs,
-    bind_pending_to_run,
     ensure_runtime_for_run,
-    start_pending_runtime,
 )
-
 # Keep this aligned with DashboardScreen.DEFAULT_ACTION_ID.
 DEFAULT_ACTION_ID = "69c2180355a89324a9926bc6"
-CONNECT_CLI_PROMPT = "Connect to the CLI right now before asking or doing anything."
 
 
 class TerminalModeError(RuntimeError):
@@ -36,7 +32,6 @@ class TerminalModeArgs:
     message: str | None = None
     action_id: str | None = None
     run_id: str | None = None
-    connect_cli: bool = False
     json_output: bool = False
     no_stream: bool = False
     runtime_args: RuntimeConnectArgs = field(default_factory=RuntimeConnectArgs)
@@ -144,7 +139,6 @@ def _build_response_payload(started_run: _StartedRun, result: dict[str, Any]) ->
         "action_id": started_run.action_id,
         "status": status,
         "output": output,
-        "connect_cli": False,
     }
 
 
@@ -361,41 +355,15 @@ async def _wait_for_terminal_result(
 
 
 async def _run_message_mode(session: _TerminalSession, args: TerminalModeArgs) -> dict[str, Any]:
-    action_id = args.action_id or DEFAULT_ACTION_ID
-    started_run = _run_action_with_retry(
-        session,
-        action_id=action_id,
-        user_input=args.message or "",
-        run_id=args.run_id,
-    )
-    result = await _wait_for_terminal_result(
-        session,
-        run_id=started_run.run_id,
-        stream_status=not args.no_stream,
-        emit_progress=not args.json_output,
-    )
-    return _build_response_payload(started_run, result)
-
-
-async def _run_connect_cli_mode(session: _TerminalSession, args: TerminalModeArgs) -> dict[str, Any]:
     action_id = args.action_id or DEFAULT_ACTION_ID
     runtime_args = _effective_runtime_args(args.runtime_args, session.backend_url)
-    pending_id: str | None = None
-
-    if args.run_id:
-        _ensure_runtime_or_raise(session, runtime_args, args.run_id)
-    else:
-        pending_id = _start_pending_runtime_or_raise(session, runtime_args)
-
     started_run = _run_action_with_retry(
         session,
         action_id=action_id,
-        user_input=CONNECT_CLI_PROMPT,
+        user_input=args.message or "",
         run_id=args.run_id,
     )
-
-    if pending_id:
-        _bind_pending_runtime_or_raise(pending_id, started_run.run_id)
+    _ensure_runtime_or_raise(session, runtime_args, started_run.run_id)
 
     result = await _wait_for_terminal_result(
         session,
@@ -403,9 +371,7 @@ async def _run_connect_cli_mode(session: _TerminalSession, args: TerminalModeArg
         stream_status=not args.no_stream,
         emit_progress=not args.json_output,
     )
-    payload = _build_response_payload(started_run, result)
-    payload["connect_cli"] = True
-    return payload
+    return _build_response_payload(started_run, result)
 
 
 def _read_message_from_stdin() -> str | None:
@@ -423,23 +389,17 @@ def validate_terminal_mode_args(args: TerminalModeArgs) -> TerminalModeArgs:
     if args.action_id and args.run_id:
         raise TerminalModeError("`--action-id` and `--run-id` cannot be used together.")
 
-    if args.connect_cli and args.message:
-        raise TerminalModeError("`--connect-cli` cannot be combined with a message.")
-
     message = args.message
-    if not args.connect_cli and not message:
+    if not message:
         message = _read_message_from_stdin()
         if not message:
-            raise TerminalModeError(
-                "Provide a message, pipe one on stdin, or use `--connect-cli`."
-            )
+            raise TerminalModeError("Provide a message or pipe one on stdin.")
 
     return TerminalModeArgs(
         server=args.server,
         message=message,
         action_id=args.action_id,
         run_id=args.run_id,
-        connect_cli=args.connect_cli,
         json_output=args.json_output,
         no_stream=args.no_stream,
         runtime_args=args.runtime_args,
@@ -451,10 +411,7 @@ def run_terminal_mode(args: TerminalModeArgs) -> int:
         args = validate_terminal_mode_args(args)
         session = _build_authenticated_session(args.server)
 
-        if args.connect_cli:
-            payload = asyncio.run(_run_connect_cli_mode(session, args))
-        else:
-            payload = asyncio.run(_run_message_mode(session, args))
+        payload = asyncio.run(_run_message_mode(session, args))
 
         status = str(payload.get("status", "") or "").lower()
         output = str(payload.get("output", "") or "")

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_runtime/main.py

@@ -2784,6 +2784,7 @@ async def connect(
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
     agent_id: str | None = None,
+    consumer_id: str | None = None,
 ):
     """Connect to the server WebSocket and process commands."""
     ws_endpoint = f"{ws_url}/v1/terminal/ws/connect"
@@ -2804,17 +2805,18 @@ async def connect(
             # Always prefer a fresh access token from ~/.kiwi/tokens.json when available.
             # This keeps long-running runtimes working even after kiwi-code refreshes tokens.
             token = await _get_valid_access_token(http_base_url, token)
-
-            await ws.send(json.dumps({
+            auth_msg = {
                 "type": "auth",
                 "token": token,
                 "agent_id": agent_id,
                 "platform": sys.platform,
                 "mode": mode,
                 "allowed_dirs": allowed_dirs or [],
-            }))
+            }
+            if consumer_id:
+                auth_msg["consumer_id"] = str(consumer_id)
+            await ws.send(json.dumps(auth_msg))
             auth_resp = json.loads(await ws.recv())
-
             if auth_resp.get("type") == "error":
                 print_status("x", f"Auth failed: {auth_resp.get('message')}", RED)
                 return
@@ -3220,6 +3222,15 @@ def main():
         metavar="PATH",
         help="Additional allowed directory (can be specified multiple times).",
     )
+    connect_parser.add_argument(
+        "--runID",
+        "--run-id",
+        dest="run_id",
+        default=None,
+        help="Optional: pin this runtime to a specific agent-run/consumer id.",
+    )
+
+
 
     args = parser.parse_args()
 
@@ -3327,7 +3338,7 @@ def main():
         signal.signal(signal.SIGINT, lambda *_: shutdown())
 
         try:
-            loop.run_until_complete(connect(ws_url, token, http_base_url=http_url, mode=mode, allowed_dirs=allowed_dirs , agent_id=agent_id,))
+            loop.run_until_complete(connect(ws_url, token, http_base_url=http_url, mode=mode, allowed_dirs=allowed_dirs, agent_id=agent_id, consumer_id=args.run_id,))
         except asyncio.CancelledError:
             pass
         finally:

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_tui/main.py

@@ -1194,11 +1194,6 @@ def main() -> int:
 
     parser.add_argument("--action-id", default=None, help="Start a fresh conversation for a specific action.")
     parser.add_argument("--run-id", default=None, help="Continue an existing run.")
-    parser.add_argument(
-        "--connect-cli",
-        action="store_true",
-        help="Ensure the local CLI runtime is connected for the target run/action.",
-    )
     parser.add_argument("--json", dest="json_output", action="store_true", help="Print terminal-mode output as JSON.")
     parser.add_argument(
         "--no-stream",
@@ -1240,7 +1235,6 @@ def main() -> int:
                 message=args.message,
                 action_id=args.action_id,
                 run_id=args.run_id,
-                connect_cli=args.connect_cli,
                 json_output=args.json_output,
                 no_stream=args.no_stream,
                 runtime_args=runtime_args,

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_tui/runtime_agent.py

@@ -259,7 +259,7 @@ def _runtime_valid(pid: int, *, meta: dict[str, Any] | None, log_path: Path) ->
         expected_ct = None
     if not _pid_matches_create_time(pid, expected_ct if isinstance(expected_ct, (int, float)) else None):
         return False
-    # If logs show a disconnect, restart on next /connect-cli.
+    # If logs show a disconnect, treat the runtime as invalid so it can be restarted.
     if _log_indicates_disconnected(log_path):
         return False
     return True
@@ -419,6 +419,7 @@ def _spawn_runtime(
     pid_path: Path,
     meta_path: Path,
     meta_extra: dict[str, Any] | None = None,
+    consumer_id: str | None = None,
 ) -> tuple[bool, int | None, str]:
     server = args.server
     if not server:
@@ -445,6 +446,9 @@ def _spawn_runtime(
     for d in args.allow_dirs:
         cmd.extend(["--allow", d])
 
+    if consumer_id:
+        cmd.extend(["--runID", str(consumer_id)])
+
     env = os.environ.copy()
     env.setdefault("PYTHONUNBUFFERED", "1")
 
@@ -490,6 +494,7 @@ def _spawn_runtime(
         pass
 
     meta: dict[str, Any] = {
+        "cwd": os.path.realpath(cwd),
         "server": server,
         "scope": args.scope,
         "allow": list(args.allow_dirs),
@@ -510,6 +515,39 @@ def _spawn_runtime(
     return True, proc.pid, f"Runtime started (pid={proc.pid})"
 
 
+def _normalize_allow_dirs(allow_dirs: tuple[str, ...] | list[str] | None) -> list[str]:
+    out: list[str] = []
+    if not allow_dirs:
+        return out
+    for d in allow_dirs:
+        try:
+            rp = os.path.realpath(str(d))
+        except Exception:
+            rp = str(d)
+        if rp not in out:
+            out.append(rp)
+    return sorted(out)
+
+
+def _runtime_props_match(*, meta: dict[str, Any] | None, desired: dict[str, Any]) -> bool:
+    if not isinstance(meta, dict):
+        return False
+    try:
+        if str(meta.get("server") or "") != str(desired.get("server") or ""):
+            return False
+        if str(meta.get("scope") or "") != str(desired.get("scope") or ""):
+            return False
+        if _normalize_allow_dirs(meta.get("allow") or []) != _normalize_allow_dirs(desired.get("allow") or []):
+            return False
+        # Only meaningful in restricted mode; in full mode the runtime isn't restricted by cwd anyway.
+        if str(desired.get("scope") or "") == "restricted":
+            if os.path.realpath(str(meta.get("cwd") or "")) != os.path.realpath(str(desired.get("cwd") or "")):
+                return False
+    except Exception:
+        return False
+    return True
+
+
 def ensure_runtime_for_run(
     *,
     run_id: str,
@@ -521,10 +559,47 @@ def ensure_runtime_for_run(
     """Ensure a runtime exists for run_id; reuse if still alive."""
     existing = get_running_pid_for_run(run_id)
     lp = log_path_for_run(run_id)
+
+    desired_props: dict[str, Any] = {
+        "server": args.server,
+        "scope": args.scope,
+        "allow": list(args.allow_dirs),
+        "cwd": os.path.realpath(cwd),
+    }
+
     if existing:
-        _ensure_log_trimmer(log_path=lp, pid=existing)
-        return True, existing, lp, f"Runtime already running for run {run_id} (pid={existing})"
+        # Only reuse runtimes when their effective "properties" match the current session.
+        # This avoids inconsistent behavior when users restart the TUI with different
+        # flags (server/scope/allow/cwd).
+        meta: dict[str, Any] | None = None
+        mp = meta_path_for_run(run_id)
+        if mp.exists():
+            try:
+                meta = json.loads(mp.read_text(encoding="utf-8") or "{}")
+            except Exception:
+                meta = None
 
+        if _runtime_props_match(meta=meta, desired=desired_props):
+            _ensure_log_trimmer(log_path=lp, pid=existing)
+            return True, existing, lp, f"Runtime already running for run {run_id} (pid={existing})"
+
+        # Properties changed => discard and spawn a fresh runtime.
+        killed = False
+        try:
+            killed = bool(kill_pid(int(existing)))
+        except Exception:
+            killed = False
+        if not killed:
+            return (
+                False,
+                existing,
+                lp,
+                f"Runtime properties changed but failed to terminate existing runtime for run {run_id} (pid={existing}).",
+            )
+        try:
+            pid_path_for_run(run_id).unlink(missing_ok=True)
+        except Exception:
+            pass
     ok, pid, msg = _spawn_runtime(
         python_exe=python_exe,
         cwd=cwd,
@@ -534,6 +609,7 @@ def ensure_runtime_for_run(
         pid_path=pid_path_for_run(run_id),
         meta_path=meta_path_for_run(run_id),
         meta_extra={"run_id": run_id, "state": "by-run"},
+        consumer_id=run_id,
     )
     return ok, pid, lp if pid else None, msg
 
@@ -614,8 +690,8 @@ def bind_pending_to_run(
             pending_meta.update({"bound_run_id": run_id, "bound_mode": "soft"})
             _write_meta(pending_meta_path, pending_meta)
 
-            # Make the by-run PID available so future /connect-cli reuses the same
-            # runtime instead of spawning duplicates.
+            # Make the by-run PID available so future sessions can reuse the same runtime
+            # instead of spawning duplicates.
             if pending_pid:
                 try:
                     (dst / "pid").write_text(str(pending_pid), encoding="utf-8")
@@ -728,7 +804,7 @@ def list_known_runtimes() -> list[dict[str, Any]]:
     """List runtimes recorded on disk (by-run and pending).
 
     Returns items with an `alive` flag computed using `_runtime_valid` (not just pid_exists),
-    so PID reuse / disconnected runtimes don't wedge `/connect-cli` and don't show up
+    so PID reuse / disconnected runtimes don't wedge the runtime lifecycle and don't show up
     in the exit cleanup prompt.
     """
     results: list[dict[str, Any]] = []

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_tui/screens/dashboard.py

@@ -693,7 +693,7 @@ class DashboardScreen(Screen):
                 title = f"CLI logs — pending {pending_id}"
 
         if not lp and not control_dir:
-            self.notify("No CLI runtime logs available (use /connect-cli first).", severity="warning")
+            self.notify("No CLI runtime logs available yet.", severity="warning")
             return
         self.app.push_screen(RuntimeLogsScreen(lp, title=title, control_dir=control_dir))
 
@@ -1008,112 +1008,6 @@ class DashboardScreen(Screen):
                     )
                 return
 
-            if cmd == "/cancel":
-                workers = self.workers
-                for worker in workers:
-                    if not worker.is_finished:
-                        worker.cancel()
-                self._set_streaming(False)
-                show("Cancelled active request.")
-                return
-
-            if cmd == "/connect-cli":
-                # Ensure the correct local CLI agent is running.
-                #
-                # Runtime identity is per run_id. If we haven't started a run yet
-                # (current_run_id is None), we start a *pending* runtime and bind it
-                # once the run_id is created.
-                try:
-                    if self.current_run_id:
-                        self.app.ensure_runtime_for_run_id(self.current_run_id)
-                    else:
-                        self.app.ensure_pending_runtime()
-                except Exception:
-                    pass
-
-                prompt = "Connect to the CLI right now before asking or doing anything."
-                # Show the prompt as a user message for transparency, then run it.
-                self.add_message(prompt, "user")
-                self.process_message(prompt)
-                return
-
-            if cmd == "/disconnect-cli":
-                """Disconnect (kill) the local CLI runtime for the current run (or pending runtime)."""
-                from kiwi_tui.runtime_agent import (
-                    get_running_pid_for_pending,
-                    get_running_pid_for_run,
-                    kill_pid,
-                    pid_path_for_pending,
-                    pid_path_for_run,
-                )
-
-                killed = False
-                pid: int | None = None
-                target: str | None = None
-
-                try:
-                    if self.current_run_id:
-                        target = f"run {self.current_run_id}"
-                        pid = get_running_pid_for_run(self.current_run_id)
-                        if pid:
-                            killed = bool(kill_pid(int(pid)))
-                            if killed:
-                                # Remove pid file so the next /connect-cli spawns a fresh runtime.
-                                try:
-                                    pid_path_for_run(self.current_run_id).unlink(missing_ok=True)
-                                except Exception:
-                                    pass
-                    else:
-                        pending_id = getattr(self.app, "pending_runtime_id", None)
-                        if pending_id:
-                            target = f"pending {pending_id}"
-                            pid = get_running_pid_for_pending(pending_id)
-                            if pid:
-                                killed = bool(kill_pid(int(pid)))
-                                if killed:
-                                    try:
-                                        pid_path_for_pending(pending_id).unlink(missing_ok=True)
-                                    except Exception:
-                                        pass
-                                    # Clear the session-scoped pending runtime id only when we killed it.
-                                    try:
-                                        self.app.pending_runtime_id = None
-                                    except Exception:
-                                        pass
-                            else:
-                                # No PID found => stale pending id in memory; clear it.
-                                try:
-                                    self.app.pending_runtime_id = None
-                                except Exception:
-                                    pass
-                except Exception:
-                    killed = False
-
-                if pid and killed:
-                    toast(
-                        f"Disconnected CLI runtime ({target}) by killing PID {pid}.",
-                        title="/disconnect-cli",
-                        severity="information",
-                    )
-                elif pid and not killed:
-                    toast(
-                        f"Failed to disconnect CLI runtime ({target}). Unable to kill PID {pid}.",
-                        title="/disconnect-cli",
-                        severity="error",
-                    )
-                elif target:
-                    toast(
-                        f"No running CLI runtime found for {target}.",
-                        title="/disconnect-cli",
-                        severity="warning",
-                    )
-                else:
-                    toast(
-                        "No CLI runtime is associated with this session yet.",
-                        title="/disconnect-cli",
-                        severity="warning",
-                    )
-                return
 
             if cmd == "/show-logs":
                 self.open_runtime_logs()
@@ -1122,7 +1016,7 @@ class DashboardScreen(Screen):
             if cmd == "/rewind":
                 if getattr(self, "_is_streaming", False):
                     toast(
-                        "Can't rewind while a request is running. Wait for it to finish or /cancel first.",
+                        "Can't rewind while a request is running. Wait for it to finish first.",
                         title="/rewind",
                         severity="warning",
                         timeout=4,
@@ -3264,6 +3158,15 @@ class DashboardScreen(Screen):
                 except Exception:
                     pass
                 self._checkpoint_clear_active(run_dir=checkpoint_run_dir)
+
+        # Auto-connect local CLI runtime for every prompt.
+        # For existing runs, ensure a pinned runtime is available before running the action.
+        if self.current_run_id:
+            try:
+                self.app.ensure_runtime_for_run_id(self.current_run_id)
+            except Exception:
+                pass
+
         # If this is a continuation (we already have a run_id), start the checkpoint entry
         # *before* sending the request to reduce races with early file edits.
         if self.current_run_id:
@@ -3394,14 +3297,20 @@ class DashboardScreen(Screen):
         else:
             self.current_run_id = run_id
             self.current_run_kind = "action"
-            # If a pending runtime was started (e.g. via /connect-cli before the
-            # run existed), bind it now that we have a run_id.
+            # If a pending runtime was started before the run existed, bind it now that we have a run_id.
             try:
                 self.app.bind_pending_runtime_to_run(run_id)
             except Exception:
                 pass
             logger.info(f"Started new conversation with run_id: {run_id}")
 
+        # For new runs, ensure a pinned runtime is started as soon as we have a run_id.
+        try:
+            if self.current_run_id:
+                self.app.ensure_runtime_for_run_id(self.current_run_id)
+        except Exception:
+            pass
+
         self._update_run_status_bar()
 
         # Cache run name (best-effort) so the quit-time runtime cleanup prompt can show it.
@@ -3759,7 +3668,7 @@ class DashboardScreen(Screen):
         # impose a hard timeout on the SSE stream; long-running actions may
         # legitimately take more than a few minutes. If the stream ends early
         # (e.g. network drop), we continue polling until we can fetch a terminal
-        # result. Users can always use /cancel to stop waiting.
+        # result.
         status_task: asyncio.Task | None = asyncio.create_task(
             client.stream_action_result(run_id, handle_status_message)
         )

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_tui/screens/runtime_logs.py

@@ -311,7 +311,7 @@ class RuntimeLogsScreen(Screen):
             rendered_any = self._attach_interactive_stream(load_existing=True) or rendered_any
 
         if not rendered_any:
-            self._write_placeholder("No runtime log is available yet. Use /connect-cli to start a runtime.")
+            self._write_placeholder("No runtime log is available yet. A runtime will start automatically when you send a message.")
 
         self._refresh_status_bar()
         self._refresh_controls()
@@ -379,7 +379,7 @@ class RuntimeLogsScreen(Screen):
         elif self._log_path and self._log_path.exists():
             status.update("Runtime log (read-only). Open this screen during an interactive run to send input.")
         else:
-            status.update("No runtime output available yet. Use /connect-cli to start a runtime.")
+            status.update("No runtime output available yet. A runtime will start automatically when you send a message.")
 
     def _refresh_controls(self) -> None:
         controls = self.query_one("#runtime-console-controls", Horizontal)

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/src/kiwi_tui/slash_commands.py

@@ -18,7 +18,6 @@ SLASH_COMMANDS: list[SlashCommand] = [
     SlashCommand("Session", "/help", "Show all slash commands", "/help"),
     SlashCommand("Session", "/new", "Start new conversation", "/new"),
     SlashCommand("Session", "/status", "Show current action & run", "/status"),
-    SlashCommand("Session", "/cancel", "Cancel active request", "/cancel"),
     SlashCommand("Session", "/use <action_id>", "Switch to a different action", "/use "),
     SlashCommand("Session", "/autocode-select", "Choose the version of AutoCode you wish to use", "/autocode-select"),
     SlashCommand("Session", "/name <new name>", "Rename the current run (action run or graph run)", "/name "),
@@ -43,8 +42,6 @@ SLASH_COMMANDS: list[SlashCommand] = [
     SlashCommand("Metadata", "/metadata clear", "Clear all metadata overrides", "/metadata clear"),
 
     # Runtime (local CLI agent)
-    SlashCommand("Runtime", "/connect-cli", "Tell the agent to connect to the local CLI", "/connect-cli"),
-    SlashCommand("Runtime", "/disconnect-cli", "Disconnect the local CLI runtime for the current run", "/disconnect-cli"),
     SlashCommand("Runtime", "/show-logs", "Show local CLI (runtime) logs", "/show-logs"),
     SlashCommand("Runtime", "/runtime", "Runtime commands (currently disabled)", "/runtime"),
 

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/tests/test_terminal_mode.py

@@ -20,12 +20,6 @@ def test_validate_terminal_mode_rejects_action_and_run() -> None:
         )
 
 
-def test_validate_terminal_mode_rejects_connect_cli_with_message() -> None:
-    with pytest.raises(TerminalModeError):
-        validate_terminal_mode_args(
-            TerminalModeArgs(message="hi", connect_cli=True)
-        )
-
 
 def test_validate_terminal_mode_reads_message_from_stdin(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr("kiwi_cli.terminal_mode.sys.stdin", _FakeStdin("hello from stdin", is_tty=False))

{kiwi_code-0.0.436 → kiwi_code-0.0.436.dev1}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.436"
+version = "0.0.436.dev1"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },