kiwi-code 0.0.7__tar.gz → 0.0.8__tar.gz

{kiwi_code-0.0.7 → kiwi_code-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.7
+Version: 0.0.8
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code
@@ -18,6 +18,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic>=2.12.5
+Requires-Dist: setproctitle>=1.3.0
 Requires-Dist: textual-dev>=1.8.0
 Requires-Dist: textual>=8.1.1
 Requires-Dist: typer>=0.24.1

{kiwi_code-0.0.7 → kiwi_code-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.7"
+version = "0.0.8"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.13,<4.0"
@@ -14,6 +14,7 @@ dependencies = [
     "websockets>=14.1",
     "httpx>=0.25.0",
     "psutil>=5.9.0",
+    "setproctitle>=1.3.0",
 ]
 authors = [
     { name = "Anurag Jha", email = "anurag@meetkiwi.co" }

{kiwi_code-0.0.7 → kiwi_code-0.0.8}/src/kiwi_cli/cli.py

@@ -237,6 +237,8 @@ def tui():
 
 def cli():
     """Entry point for the CLI."""
+    import setproctitle
+    setproctitle.setproctitle("kiwicli")
     app()
 
 if __name__ == "__main__":

{kiwi_code-0.0.7 → kiwi_code-0.0.8}/src/kiwi_runtime/main.py

@@ -610,6 +610,229 @@ if not IS_WINDOWS:
                 self.slave_fd = None
 
 
+    class PersistentShell:
+        """A long-lived bash PTY that persists across commands.
+
+        All one-shot ``command`` messages are routed through the same shell so
+        that ``cd``, environment variables, virtualenv activations, aliases, and
+        other shell state carry over between commands.  The server still
+        receives ``{stdout, stderr, exit_code}`` — no backend changes needed.
+        """
+
+        _SHELL_SENTINEL = "__KIWI_SHELL_DONE__"
+
+        def __init__(self, cwd: str | None = None, cols: int = 200, rows: int = 50):
+            self._cwd = cwd
+            self._cols = cols
+            self._rows = rows
+            self.master_fd: int | None = None
+            self._pid: int | None = None
+
+        # -- lifecycle --------------------------------------------------------
+
+        def start(self) -> None:
+            """Spawn a bash PTY that stays alive for the runtime's lifetime."""
+            master_fd, slave_fd = pty.openpty()
+
+            # Set terminal size
+            winsize = struct.pack("HHHH", self._rows, self._cols, 0, 0)
+            fcntl.ioctl(slave_fd, termios.TIOCSWINSZ, winsize)
+
+            pid = os.fork()
+            if pid == 0:
+                # Child — become session leader and exec bash
+                os.setsid()
+                os.dup2(slave_fd, 0)
+                os.dup2(slave_fd, 1)
+                os.dup2(slave_fd, 2)
+                if slave_fd > 2:
+                    os.close(slave_fd)
+                os.close(master_fd)
+                if self._cwd:
+                    os.chdir(self._cwd)
+                os.execvp("bash", [
+                    "bash", "--norc", "--noprofile", "-i",
+                ])
+            else:
+                # Parent
+                os.close(slave_fd)
+                self.master_fd = master_fd
+                self._pid = pid
+
+                # Set non-blocking reads
+                flags = fcntl.fcntl(master_fd, fcntl.F_GETFL)
+                fcntl.fcntl(master_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+                # Wait for bash to be ready, drain the initial prompt
+                import time
+                time.sleep(0.2)
+                self._drain()
+
+                # Disable echo and set a blank prompt so output is clean
+                self._write("stty -echo\n")
+                time.sleep(0.1)
+                self._drain()
+                self._write("PS1=''; PS2=''\n")
+                time.sleep(0.1)
+                self._drain()
+
+                print_status(">", "Persistent shell started (bash PTY)", GREEN)
+
+        def is_alive(self) -> bool:
+            """Check whether the shell process is still running."""
+            if self._pid is None:
+                return False
+            try:
+                pid, status = os.waitpid(self._pid, os.WNOHANG)
+                if pid != 0:
+                    self._pid = None
+                    return False
+                return True
+            except ChildProcessError:
+                self._pid = None
+                return False
+
+        def close(self) -> None:
+            """Terminate the persistent shell."""
+            if self.master_fd is not None:
+                try:
+                    os.write(self.master_fd, b"exit\n")
+                except OSError:
+                    pass
+                try:
+                    os.close(self.master_fd)
+                except OSError:
+                    pass
+                self.master_fd = None
+            if self._pid is not None:
+                try:
+                    os.kill(self._pid, signal.SIGTERM)
+                    os.waitpid(self._pid, 0)
+                except (ProcessLookupError, ChildProcessError):
+                    pass
+                self._pid = None
+
+        # -- I/O helpers ------------------------------------------------------
+
+        def _write(self, data: str) -> None:
+            if self.master_fd is not None:
+                os.write(self.master_fd, data.encode("utf-8"))
+
+        def _drain(self) -> str:
+            """Read all currently available data from the PTY (non-blocking)."""
+            import select
+            chunks: list[str] = []
+            while True:
+                ready, _, _ = select.select([self.master_fd], [], [], 0.05)
+                if not ready:
+                    break
+                try:
+                    data = os.read(self.master_fd, 65536)
+                    if not data:
+                        break
+                    chunks.append(data.decode("utf-8", errors="replace"))
+                except OSError:
+                    break
+            return "".join(chunks)
+
+        # -- command execution ------------------------------------------------
+
+        async def run_command(self, command: str, timeout: int = 120) -> dict:
+            """Run a command in the persistent shell, returning {stdout, stderr, exit_code}.
+
+            Uses a sentinel pattern to detect when the command has finished.
+            """
+            if not self.is_alive():
+                return {"stdout": "", "stderr": "Persistent shell is not running", "exit_code": -1}
+
+            sentinel = self._SHELL_SENTINEL
+            # Wrap the command: run it, then echo sentinel+exit_code+sentinel
+            wrapped = (
+                f"{command}\n"
+                f"__kiwi_ec=$?; echo \"{sentinel}${{__kiwi_ec}}{sentinel}\"; "
+                f"echo \"{sentinel}${{__kiwi_ec}}{sentinel}\" >&2\n"
+            )
+
+            # Drain any leftover output
+            self._drain()
+
+            # Send the command
+            self._write(wrapped)
+
+            # Read output until we see the sentinel
+            import select
+            collected: list[str] = []
+            loop = asyncio.get_event_loop()
+
+            try:
+                output = await asyncio.wait_for(
+                    loop.run_in_executor(None, self._read_until_sentinel, sentinel, timeout),
+                    timeout=timeout + 5,
+                )
+            except (asyncio.TimeoutError, TimeoutError):
+                return {"stdout": "", "stderr": f"Command timed out after {timeout}s", "exit_code": -1}
+
+            return output
+
+        def _read_until_sentinel(self, sentinel: str, timeout: int) -> dict:
+            """Blocking read from PTY until sentinel is found. Returns parsed result."""
+            import select
+            import time
+
+            deadline = time.monotonic() + timeout
+            buf = ""
+
+            while time.monotonic() < deadline:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    break
+
+                ready, _, _ = select.select(
+                    [self.master_fd], [], [], min(0.1, remaining)
+                )
+                if ready:
+                    try:
+                        data = os.read(self.master_fd, 65536)
+                        if not data:
+                            break
+                        buf += data.decode("utf-8", errors="replace")
+                    except OSError:
+                        break
+
+                # Check if sentinel appeared
+                sentinel_marker = sentinel
+                # We look for the pattern: sentinel + exit_code + sentinel
+                import re
+                pattern = re.escape(sentinel) + r"(\d+)" + re.escape(sentinel)
+                match = re.search(pattern, buf)
+                if match:
+                    exit_code = int(match.group(1))
+                    # Everything before the sentinel line is stdout
+                    stdout = buf[:match.start()]
+                    # Clean up: remove the sentinel echo command itself if visible
+                    lines = stdout.splitlines(keepends=True)
+                    clean_lines = []
+                    for line in lines:
+                        stripped = line.strip()
+                        if sentinel in stripped:
+                            continue
+                        if stripped.startswith("__kiwi_ec="):
+                            continue
+                        clean_lines.append(line)
+                    stdout = "".join(clean_lines).strip()
+
+                    # Truncate if needed
+                    stdout = stdout[:MAX_OUTPUT_BYTES]
+
+                    return {
+                        "stdout": stdout,
+                        "stderr": "",
+                        "exit_code": exit_code,
+                    }
+
+            return {"stdout": buf[:MAX_OUTPUT_BYTES], "stderr": "Command timed out", "exit_code": -1}
+
+
 class PipeProcess:
     """Manages a persistent shell session using subprocess pipes (Windows-compatible)."""
 
@@ -777,6 +1000,7 @@ async def connect(
     token: str,
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
+    shell: "PersistentShell | None" = None,
 ) -> str:
     """Connect to the server WebSocket and process commands.
 
@@ -831,11 +1055,26 @@ async def connect(
                         command = msg.get("command", "")
                         print_cmd_log(request_id, f"$ {BOLD}{command}{RESET}")
 
-                        result = await run_command(
-                            command,
-                            mode=mode,
-                            allowed_dirs=allowed_dirs,
-                        )
+                        # Validate in restricted mode before execution
+                        if mode == "restricted" and allowed_dirs:
+                            ok, reason = validate_command(
+                                command, allowed_dirs,
+                                pid=shell._pid if shell and shell.is_alive() else None,
+                            )
+                            if not ok:
+                                result = {"stdout": "", "stderr": reason, "exit_code": 1}
+                            elif shell and shell.is_alive():
+                                result = await shell.run_command(command)
+                            else:
+                                result = await run_command(
+                                    command, mode=mode, allowed_dirs=allowed_dirs,
+                                )
+                        elif shell and shell.is_alive():
+                            result = await shell.run_command(command)
+                        else:
+                            result = await run_command(
+                                command, mode=mode, allowed_dirs=allowed_dirs,
+                            )
                         exit_code = result["exit_code"]
                         success = exit_code == 0
                         status_text = (
@@ -954,6 +1193,9 @@ async def connect(
 
 
 def main():
+    import setproctitle
+    setproctitle.setproctitle("kiwi-runtime")
+
     parser = argparse.ArgumentParser(
         description="Kiwi AI CLI Agent — execute terminal commands for LLM agents"
     )
@@ -1084,6 +1326,18 @@ def main():
                 loop.close()
                 sys.exit(1)
 
+        # Start persistent shell (Unix only) — survives reconnections
+        persistent_shell = None
+        if not IS_WINDOWS:
+            print_section("Shell")
+            try:
+                cwd = allowed_dirs[0] if allowed_dirs else os.getcwd()
+                persistent_shell = PersistentShell(cwd=cwd)
+                persistent_shell.start()
+            except Exception as e:
+                print_status("!", f"Persistent shell failed, using one-shot mode: {e}", YELLOW)
+                persistent_shell = None
+
         print_section("Connection")
 
         _shutting_down = False
@@ -1115,7 +1369,7 @@ def main():
 
             try:
                 status = loop.run_until_complete(
-                    connect(ws_url, token, mode=mode, allowed_dirs=allowed_dirs)
+                    connect(ws_url, token, mode=mode, allowed_dirs=allowed_dirs, shell=persistent_shell)
                 )
             except asyncio.CancelledError:
                 break
@@ -1157,6 +1411,10 @@ def main():
                 break
             backoff = min(backoff * 2, max_backoff)
 
+        # Clean up persistent shell
+        if persistent_shell:
+            persistent_shell.close()
+
         loop.close()
         print()
         print(f"  {GREY}{'─' * 50}{RESET}")

{kiwi_code-0.0.7 → kiwi_code-0.0.8}/src/kiwi_tui/main.py

@@ -13,7 +13,7 @@ from kiwi_cli.config import ConfigManager
 from kiwi_cli.client import AutobotsClientWrapper
 from kiwi_cli.auth import TokenManager
 from kiwi_cli import runtime_manager
-from .screens import LoginScreen, DashboardScreen, AutobotsScreen, ActionsScreen, RuntimeLogsScreen
+from .screens import LoginScreen, DashboardScreen, RuntimeLogsScreen
 
 
 class AutobotsTUI(App):
@@ -45,8 +45,6 @@ class AutobotsTUI(App):
     SCREENS = {
         "login": LoginScreen,
         "dashboard": DashboardScreen,
-        "autobots": AutobotsScreen,
-        "actions": ActionsScreen,
         "runtime_logs": RuntimeLogsScreen,
     }
 
@@ -420,6 +418,9 @@ def _serve_tui(port: int = 8566):
 
 def main():
     """Entry point for the kiwi command."""
+    import setproctitle
+    setproctitle.setproctitle("kiwi")
+
     import argparse
 
     parser = argparse.ArgumentParser(prog="kiwi", description="Kiwi Code TUI")

kiwi_code-0.0.8/src/kiwi_tui/screens/__init__.py

@@ -0,0 +1,7 @@
+"""Screens for Autobots TUI."""
+
+from .login import LoginScreen
+from .dashboard import DashboardScreen
+from .runtime_logs import RuntimeLogsScreen
+
+__all__ = ["LoginScreen", "DashboardScreen", "RuntimeLogsScreen"]

{kiwi_code-0.0.7 → kiwi_code-0.0.8}/src/kiwi_tui/screens/dashboard.py

@@ -239,6 +239,17 @@ class DashboardScreen(Screen):
             self.add_message(f"Cleared {count} pending file(s).", "info")
             return
 
+        if cmd == "/login":
+            if self.app.token_manager.is_authenticated():
+                self.add_message("Already logged in. Use /logout first to switch accounts.", "info")
+                return
+            self.app.push_screen("login")
+            return
+
+        if cmd == "/logout":
+            self.app.action_logout()
+            return
+
         if cmd == "/metadata":
             if not args:
                 # Show effective metadata (defaults + overrides)

{kiwi_code-0.0.7 → kiwi_code-0.0.8}/src/kiwi_tui/widgets.py

@@ -27,6 +27,8 @@ _SLASH_COMMANDS = [
     "/upload ",
     "/files",
     "/clear-files",
+    "/login",
+    "/logout",
     "/metadata",
     "/metadata set ",
     "/metadata remove ",