kiwi-code 0.0.445__tar.gz → 0.0.447__tar.gz

{kiwi_code-0.0.445 → kiwi_code-0.0.447}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.445
+Version: 0.0.447
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
-Project-URL: Repository, https://github.com/jetoslabs/kiwi-code
-Author-email: Anurag Jha <anurag@meetkiwi.co>
+Author-email: Anurag <anurag@meetkiwi.co>
 License: Proprietary
 Keywords: cli,terminal,textual,tui
 Classifier: Development Status :: 3 - Alpha

{kiwi_code-0.0.445 → kiwi_code-0.0.447}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.445"
+version = "0.0.447"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"
@@ -19,7 +19,7 @@ dependencies = [
 ]
 
 authors = [
-    { name = "Anurag Jha", email = "anurag@meetkiwi.co" }
+    { name = "Anurag", email = "anurag@meetkiwi.co" }
 ]
 license = { text = "Proprietary" }
 keywords = ["tui", "textual", "terminal", "cli"]
@@ -35,7 +35,6 @@ classifiers = [
 
 [project.urls]
 Homepage = "https://meetkiwi.ai"
-Repository = "https://github.com/jetoslabs/kiwi-code"
 
 [project.scripts]
 kiwi = "kiwi_tui.main:main"

{kiwi_code-0.0.445 → kiwi_code-0.0.447}/src/kiwi_cli/__init__.py

@@ -1,3 +1,4 @@
 """Kiwi CLI - command-line interface and shared infrastructure modules."""
 
-__version__ = "0.0.445"
+
+__version__ = "0.0.447"

{kiwi_code-0.0.445 → kiwi_code-0.0.447}/src/kiwi_runtime/__init__.py

@@ -1,3 +1,4 @@
 """Kiwi Runtime — terminal agent that connects to the server via WebSocket."""
 
-__version__ = "0.0.445"
+
+__version__ = "0.0.447"

{kiwi_code-0.0.445 → kiwi_code-0.0.447}/src/kiwi_runtime/main.py

@@ -3075,6 +3075,98 @@ def validate_command(
     return True, ""
 
 
+def _looks_interactive_oneoff(command: str) -> str | None:
+    """Best-effort detection of commands that are likely to require a TTY / user input.
+
+    This is intentionally conservative and only catches common cases that have caused
+    terminals to appear "hung" when mistakenly executed as one-off commands.
+    """
+    try:
+        tokens = shlex.split(command)
+    except Exception:
+        tokens = (command or "").strip().split()
+    if not tokens:
+        return None
+    exe = os.path.basename(tokens[0]).lower()
+    args = [t.lower() for t in tokens[1:]]
+    # Strip flags for subcommand detection (supports patterns like: gcloud --project X auth login).
+    nonflags = [a for a in args if not a.startswith("-")]
+
+    # Google Cloud / BigQuery CLIs: commonly interactive for auth/init flows.
+    if exe == "gcloud":
+        quiet = ("--quiet" in args) or ("-q" in args)
+        # gcloud init is explicitly interactive.
+        if "init" in nonflags:
+            return "gcloud init"
+
+        # Detect interactive auth flows even when preceded by groups like `alpha`/`beta`.
+        for i, tok in enumerate(nonflags):
+            # gcloud auth login (opens browser / requires user interaction).
+            if tok == "auth" and i + 1 < len(nonflags) and nonflags[i + 1] == "login":
+                return "gcloud auth login"
+            # gcloud auth application-default login
+            if (
+                tok == "auth"
+                and i + 2 < len(nonflags)
+                and nonflags[i + 1] == "application-default"
+                and nonflags[i + 2] == "login"
+            ):
+                return "gcloud auth application-default login"
+
+            # component management often prompts unless --quiet/-q is set.
+            if (
+                (not quiet)
+                and tok == "components"
+                and i + 1 < len(nonflags)
+                and nonflags[i + 1] in {"install", "update", "remove", "reinstall"}
+            ):
+                return f"gcloud components {nonflags[i + 1]}"
+
+    if exe == "bq":
+        # bq init configures defaults and is interactive; other bq commands are generally non-interactive.
+        if "init" in nonflags:
+            return "bq init"
+
+    # npm / node ecosystem: certain subcommands prompt for credentials or project metadata.
+    if exe in {"npm", "pnpm", "yarn", "bun"}:
+        sub = nonflags[0] if nonflags else ""
+        # `npm init` is interactive unless -y/--yes is provided.
+        if sub == "init" and ("-y" not in args and "--yes" not in args):
+            return f"{exe} init"
+        if sub in {"login", "adduser", "publish", "create"}:
+            return f"{exe} {sub}"
+    # Common interactive shells / editors / pagers / REPLs
+    hard_interactive = {
+        "ssh", "sudo", "su", "vim", "vi", "nano", "less", "more", "top", "htop", "passwd",
+        "mysql", "psql", "redis-cli", "telnet", "sftp", "ftp",
+    }
+    if exe in hard_interactive:
+        return exe
+
+    # REPLs when invoked without an explicit script / command
+    if exe in {"python", "python3", "node"} and len(tokens) == 1:
+        return exe
+
+    # `cat` with no args waits on stdin
+    if exe == "cat" and len(tokens) == 1:
+        return exe
+
+    # `watch` is long-running
+    if exe == "watch":
+        return exe
+
+    # `ping` without count is long-running on macOS/Linux
+    if exe == "ping" and ("-c" not in args and "--count" not in args):
+        return exe
+
+    # `tail -f` follows forever
+    if exe == "tail" and ("-f" in args or "--follow" in args):
+        return "tail -f"
+
+    return None
+
+
+
 _SAFE_PATHS = frozenset({
     "/dev/null", "/dev/stdin", "/dev/stdout", "/dev/stderr",
     "/dev/zero", "/dev/random", "/dev/urandom", "/dev/tty",
@@ -3241,7 +3333,7 @@ async def login(http_base_url: str, email: str, password: str) -> str:
 
 async def run_command(
     command: str,
-    timeout: int = 120,
+    timeout: int = 30,
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
 ) -> dict:
@@ -3255,12 +3347,20 @@ async def run_command(
     proc: asyncio.subprocess.Process | None = None
     try:
         cwd = allowed_dirs[0] if allowed_dirs else None
-        proc = await asyncio.create_subprocess_shell(
-            command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            cwd=cwd,
-        )
+
+        # One-off commands must be non-interactive: never read from the user's TTY.
+        # On macOS/Linux this prevents accidental terminal hijacking (e.g. ssh/sudo/vim).
+        # We also start a new session so we can safely kill the whole process group.
+        popen_kwargs: dict[str, Any] = {
+            "stdout": asyncio.subprocess.PIPE,
+            "stderr": asyncio.subprocess.PIPE,
+            "stdin": asyncio.subprocess.DEVNULL,
+            "cwd": cwd,
+        }
+        if not IS_WINDOWS:
+            popen_kwargs["start_new_session"] = True
+
+        proc = await asyncio.create_subprocess_shell(command, **popen_kwargs)
         stdout_bytes, stderr_bytes = await asyncio.wait_for(
             proc.communicate(), timeout=timeout
         )
@@ -3269,8 +3369,22 @@ async def run_command(
         return {"stdout": stdout, "stderr": stderr, "exit_code": proc.returncode}
     except asyncio.TimeoutError:
         if proc and proc.returncode is None:
+            # On POSIX, prefer killing the whole process group so child processes
+            # (ssh/vim/etc.) can't survive and keep the user's terminal wedged.
             try:
-                proc.kill()
+                if not IS_WINDOWS:
+                    try:
+                        os.killpg(proc.pid, signal.SIGKILL)
+                    except ProcessLookupError:
+                        pass
+                    except Exception:
+                        # Fallback: kill just the parent.
+                        try:
+                            proc.kill()
+                        except Exception:
+                            pass
+                else:
+                    proc.kill()
             except ProcessLookupError:
                 pass
             try:
@@ -3280,8 +3394,22 @@ async def run_command(
         return {"stdout": "", "stderr": f"Command timed out after {timeout}s", "exit_code": -1}
     except asyncio.CancelledError:
         if proc and proc.returncode is None:
+            # On POSIX, prefer killing the whole process group so child processes
+            # (ssh/vim/etc.) can't survive and keep the user's terminal wedged.
             try:
-                proc.kill()
+                if not IS_WINDOWS:
+                    try:
+                        os.killpg(proc.pid, signal.SIGKILL)
+                    except ProcessLookupError:
+                        pass
+                    except Exception:
+                        # Fallback: kill just the parent.
+                        try:
+                            proc.kill()
+                        except Exception:
+                            pass
+                else:
+                    proc.kill()
             except ProcessLookupError:
                 pass
             try:
@@ -3300,16 +3428,29 @@ async def run_command(
 
 async def run_interactive_command(
     command: str,
+    *,
+    timeout_sec: int | None = None,
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
     request_id: str | None = None,
-) -> dict:
-    """Execute a command with the user's terminal attached for interactive I/O."""
+ ) -> dict:
+    """Execute a command with the user's terminal attached for interactive I/O.
+
+    Note: interactive commands can block indefinitely waiting on user input. We therefore
+    support an optional timeout_sec; on timeout we terminate the session so the runtime
+    can continue processing subsequent commands.
+    """
     if mode == "restricted" and allowed_dirs:
         ok, reason = validate_command(command, allowed_dirs)
         if not ok:
             return {"stdout": "", "stderr": reason, "exit_code": 1}
 
+    timeout_eff: int | None
+    try:
+        timeout_eff = int(timeout_sec) if timeout_sec else None
+    except Exception:
+        timeout_eff = None
+
     control_dir = _tui_managed_control_dir()
     if control_dir is not None:
         return await run_tui_managed_interactive_command(
@@ -3318,6 +3459,7 @@ async def run_interactive_command(
             control_dir=control_dir,
             mode=mode,
             allowed_dirs=allowed_dirs,
+            timeout_sec=timeout_eff,
         )
 
     try:
@@ -3327,14 +3469,90 @@ async def run_interactive_command(
         print(f"  {CB}{'─' * 50}{RESET}")
         print(f"  {GREY}You are now in control. Complete the prompts below.{RESET}\n")
 
-        exit_code = await asyncio.get_event_loop().run_in_executor(
-            None,
-            lambda: subprocess.run(
-                command,
-                shell=True,
-                cwd=cwd,
-            ).returncode,
-        )
+        def _run() -> int:
+            """Run an interactive command in the user's terminal.
+
+            Important: some interactive CLIs (notably ones using full-screen / raw-mode UIs)
+            can leave the TTY in a state where Ctrl+C no longer generates SIGINT if they are
+            killed abruptly. We therefore snapshot and restore terminal attributes on exit.
+            """
+            fd = None
+            old_term = None
+            try:
+                if not IS_WINDOWS:
+                    try:
+                        if sys.stdin is not None and sys.stdin.isatty():
+                            fd = sys.stdin.fileno()
+                            old_term = termios.tcgetattr(fd)
+                    except Exception:
+                        fd = None
+                        old_term = None
+
+                popen_kwargs: dict[str, Any] = {"shell": True, "cwd": cwd}
+                if not IS_WINDOWS:
+                    popen_kwargs["start_new_session"] = True
+                proc = subprocess.Popen(command, **popen_kwargs)
+                try:
+                    proc.wait(timeout=timeout_eff if timeout_eff and timeout_eff > 0 else None)
+                    return int(proc.returncode or 0)
+                except subprocess.TimeoutExpired:
+                    # Timeout: terminate the whole process group so the runtime can continue.
+                    if not IS_WINDOWS:
+                        try:
+                            os.killpg(proc.pid, signal.SIGINT)
+                            time.sleep(0.3)
+                        except Exception:
+                            pass
+                        try:
+                            os.killpg(proc.pid, signal.SIGTERM)
+                            time.sleep(0.3)
+                        except Exception:
+                            pass
+                        try:
+                            os.killpg(proc.pid, signal.SIGKILL)
+                        except Exception:
+                            pass
+                    else:
+                        try:
+                            proc.terminate()
+                        except Exception:
+                            pass
+                        time.sleep(0.3)
+                        try:
+                            proc.kill()
+                        except Exception:
+                            pass
+                    try:
+                        proc.wait(timeout=2)
+                    except Exception:
+                        pass
+                    return -1
+            finally:
+                if old_term is not None and fd is not None:
+                    try:
+                        termios.tcsetattr(fd, termios.TCSADRAIN, old_term)
+                    except Exception:
+                        pass
+
+                # Restore cursor visibility + cursor style (some interactive CLIs switch to a
+                # block cursor or hide it and don't restore on abrupt termination).
+                # - Show cursor: DECTCEM
+                # - Reset cursor style to a bar cursor (DECSCUSR)
+                try:
+                    if fd is not None:
+                        os.write(fd, b"\x1b[?25h")  # show cursor
+                        os.write(fd, b"\x1b[0 q")   # restore terminal default cursor style
+                except Exception:
+                    pass
+
+        exit_code = await asyncio.get_event_loop().run_in_executor(None, _run)
+
+        if exit_code == -1 and timeout_eff:
+            return {
+                "stdout": "",
+                "stderr": f"Interactive command timed out after {timeout_eff}s and was terminated.",
+                "exit_code": -1,
+            }
 
         print(f"\n  {CB}{'─' * 50}{RESET}")
         status = f"{GREEN}OK{RESET}" if exit_code == 0 else f"{RED}exit {exit_code}{RESET}"
@@ -4013,7 +4231,8 @@ async def run_tui_managed_interactive_command(
     control_dir: Path,
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
-) -> dict:
+    timeout_sec: int | None = None,
+ ) -> dict:
     if mode == "restricted" and allowed_dirs:
         ok, reason = validate_command(command, allowed_dirs)
         if not ok:
@@ -4041,7 +4260,31 @@ async def run_tui_managed_interactive_command(
             pty_proc = PTYProcess(session_id, command, 120, 40)
         await pty_proc.start(bridge, cwd=cwd)
         input_task = asyncio.create_task(bridge.pump_inputs(pty_proc))
-        exit_code = await bridge.wait()
+
+        try:
+            if timeout_sec and timeout_sec > 0:
+                exit_code = await asyncio.wait_for(bridge.wait(), timeout=float(timeout_sec))
+            else:
+                exit_code = await bridge.wait()
+        except asyncio.TimeoutError:
+            # Timeout: terminate the PTY session so the runtime isn't blocked.
+            msg = f"[Interactive timeout] Command timed out after {timeout_sec}s; terminating.\r\n"
+            bridge.append_output(msg)
+            try:
+                bridge._write_status(
+                    active=False,
+                    ended_at=datetime.now().isoformat(),
+                    exit_code=-1,
+                    error=f"timeout_after_{timeout_sec}s",
+                )
+            except Exception:
+                pass
+            return {
+                "stdout": "",
+                "stderr": f"Interactive command timed out after {timeout_sec}s and was terminated.",
+                "exit_code": -1,
+            }
+
         return {
             "stdout": "(interactive session completed)",
             "stderr": "",
@@ -4245,18 +4488,25 @@ async def connect(
     pending_lock = asyncio.Lock()
     pending_event = asyncio.Event()
 
-    command_queue: asyncio.Queue[tuple[str, str]] = asyncio.Queue(maxsize=64)
+    command_queue: asyncio.Queue[tuple[str, str, int]] = asyncio.Queue(maxsize=64)
     cmd_state: dict[str, Any] = {"running": False, "command": None}
 
     async def _command_worker() -> None:
         while True:
-            request_id, command = await command_queue.get()
+            request_id, command, timeout_sec = await command_queue.get()
             result_msg: dict[str, Any] | None = None
             cmd_state["running"] = True
             cmd_state["command"] = command
             try:
+                # If no timeout is provided (or it's invalid), default to 30s.
+                try:
+                    timeout_eff = int(timeout_sec) if timeout_sec else 30
+                except Exception:
+                    timeout_eff = 30
+
                 result = await run_command(
                     command,
+                    timeout=timeout_eff,
                     mode=mode,
                     allowed_dirs=allowed_dirs,
                 )
@@ -4374,7 +4624,7 @@ async def _connect_once(
     relogin_email: str | None = None,
     relogin_password: str | None = None,
     *,
-    command_queue: asyncio.Queue[tuple[str, str]],
+    command_queue: asyncio.Queue[tuple[str, str, int]],
     pending_results: deque[dict[str, Any]],
     pending_lock: asyncio.Lock,
     pending_event: asyncio.Event,
@@ -4550,8 +4800,30 @@ async def _connect_once(
                         command = msg.get("command", "")
                         print_cmd_log(request_id, f"$ {BOLD}{command}{RESET}")
 
+                        interactive_hint = _looks_interactive_oneoff(str(command))
+                        if interactive_hint:
+                            err = (
+                                f"This command looks interactive ({interactive_hint}) and can't be run as a one-off. "
+                                "Re-run with interactive=true, or start a session (session_id='new')."
+                            )
+                            print_cmd_log(request_id, f"{RED}FAILED{RESET}", False)
+                            await ws.send(json.dumps({
+                                "type": "result",
+                                "request_id": request_id,
+                                "stdout": "",
+                                "stderr": err,
+                                "exit_code": 1,
+                            }))
+                            continue
+
                         try:
-                            command_queue.put_nowait((str(request_id), str(command)))
+                            # Allow the server to pass a per-command timeout.
+                            # If missing/invalid, default to 30s.
+                            try:
+                                timeout_sec = int(msg.get("timeout_sec", 30) or 30)
+                            except Exception:
+                                timeout_sec = 30
+                            command_queue.put_nowait((str(request_id), str(command), timeout_sec))
                         except asyncio.QueueFull:
                             err = "Runtime command queue full; please retry."
                             print_cmd_log(request_id, f"{RED}FAILED{RESET}", False)
@@ -4569,8 +4841,16 @@ async def _connect_once(
                         command = msg.get("command", "")
                         print_cmd_log(request_id, f"$ {BOLD}{command}{RESET} {GREY}(interactive){RESET}")
 
+                        # Support per-command timeouts for interactive runs as well.
+                        # If missing/invalid, default to 120s (interactive flows can take time).
+                        try:
+                            timeout_sec = int(msg.get("timeout_sec", 120) or 120)
+                        except Exception:
+                            timeout_sec = 120
+
                         result = await run_interactive_command(
                             command,
+                            timeout_sec=timeout_sec,
                             mode=mode,
                             allowed_dirs=allowed_dirs,
                             request_id=request_id,

{kiwi_code-0.0.445 → kiwi_code-0.0.447}/src/kiwi_tui/__init__.py

@@ -1,3 +1,3 @@
 """Autobots TUI - A textual-based terminal user interface."""
 
-__version__ = "0.0.445"
+__version__ = "0.0.447"

{kiwi_code-0.0.445 → kiwi_code-0.0.447}/tests/test_tui_interactive_runtime.py

@@ -267,14 +267,28 @@ def test_run_interactive_command_preserves_standalone_path(monkeypatch: pytest.M
 
     calls: list[dict[str, object]] = []
 
-    class _Result:
-        returncode = 0
+    class _FakePopen:
+        def __init__(self, pid: int = 12345):
+            self.pid = pid
+            self.returncode = 0
 
-    def _fake_run(command: str, *, shell: bool, cwd: str | None = None):
-        calls.append({"command": command, "shell": shell, "cwd": cwd})
-        return _Result()
+        def wait(self, timeout: float | None = None):
+            # Immediately succeed (standalone path).
+            self.returncode = 0
+            return 0
 
-    monkeypatch.setattr(runtime_main.subprocess, "run", _fake_run)
+        def terminate(self):
+            self.returncode = -15
+
+        def kill(self):
+            self.returncode = -9
+
+    def _fake_popen(command: str, **kwargs):
+        calls.append({"command": command, **kwargs})
+        return _FakePopen()
+
+    # Standalone interactive path currently uses subprocess.Popen (not subprocess.run).
+    monkeypatch.setattr(runtime_main.subprocess, "Popen", _fake_popen)
 
     result = asyncio.run(
         runtime_main.run_interactive_command(
@@ -290,8 +304,10 @@ def test_run_interactive_command_preserves_standalone_path(monkeypatch: pytest.M
         "stderr": "",
         "exit_code": 0,
     }
-    assert calls == [{"command": "printf 'ok'", "shell": True, "cwd": "/tmp"}]
-
+    assert calls, "Expected subprocess.Popen to be called in standalone interactive mode"
+    assert calls[0]["command"] == "printf 'ok'"
+    assert calls[0].get("shell") is True
+    assert calls[0].get("cwd") == "/tmp"
 
 @pytest.mark.asyncio
 async def test_ctrl_o_opens_live_console_from_dashboard(