kiwi-code 0.0.40__tar.gz → 0.0.42__tar.gz

{kiwi_code-0.0.40 → kiwi_code-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.40
+Version: 0.0.42
 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.40 → kiwi_code-0.0.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.40"
+version = "0.0.42"
 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.40 → kiwi_code-0.0.42}/src/kiwi_runtime/main.py

@@ -1713,6 +1713,7 @@ async def run_interactive_command(
     command: str,
     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."""
     if mode == "restricted" and allowed_dirs:
@@ -1720,6 +1721,16 @@ async def run_interactive_command(
         if not ok:
             return {"stdout": "", "stderr": reason, "exit_code": 1}
 
+    control_dir = _tui_managed_control_dir()
+    if control_dir is not None:
+        return await run_tui_managed_interactive_command(
+            command,
+            request_id=request_id or str(uuid.uuid4()),
+            control_dir=control_dir,
+            mode=mode,
+            allowed_dirs=allowed_dirs,
+        )
+
     try:
         cwd = allowed_dirs[0] if allowed_dirs else None
         print(f"\n  {CB}{'─' * 50}{RESET}")
@@ -2262,6 +2273,220 @@ def _ensure_windows_persistent_completion(data: str) -> str:
 
     return f"{base} & echo {_SENTINEL}!ERRORLEVEL!{_SENTINEL}\r\n"
 
+
+def _tui_managed_control_dir() -> Path | None:
+    raw_flag = os.environ.get("KIWI_TUI_MANAGED", "").strip().lower()
+    if raw_flag not in {"1", "true", "yes", "on"}:
+        return None
+    raw_path = os.environ.get("KIWI_RUNTIME_CONTROL_DIR", "").strip()
+    if not raw_path:
+        return None
+    return Path(raw_path)
+
+
+class _LocalInteractivePTYBridge:
+    def __init__(self, *, control_dir: Path, request_id: str, command: str) -> None:
+        self.control_dir = control_dir
+        self.request_id = request_id
+        self.command = command
+        self.session_dir = control_dir / "interactive"
+        self.status_path = self.session_dir / "status.json"
+        self.input_path = self.session_dir / "input.jsonl"
+        self.output_path = self.session_dir / "output.log"
+        self._input_offset = 0
+        self._input_buffer = ""
+        self.exit_code: int | None = None
+        self.error: str | None = None
+        self._done = asyncio.Event()
+
+    def activate(self) -> None:
+        self.session_dir.mkdir(parents=True, exist_ok=True)
+        self.output_path.write_text("", encoding="utf-8")
+        self.input_path.write_text("", encoding="utf-8")
+        self._input_offset = 0
+        self._input_buffer = ""
+        self._write_status(
+            active=True,
+            request_id=self.request_id,
+            command=self.command,
+            output_path=str(self.output_path),
+            input_path=str(self.input_path),
+            started_at=datetime.now().isoformat(),
+            ended_at=None,
+            exit_code=None,
+            error=None,
+        )
+
+    def _write_status(self, **updates: Any) -> None:
+        status: dict[str, Any] = {}
+        if self.status_path.exists():
+            try:
+                status = json.loads(self.status_path.read_text(encoding="utf-8") or "{}")
+            except Exception:
+                status = {}
+        status.update(updates)
+        self.status_path.write_text(json.dumps(status, indent=2, default=str), encoding="utf-8")
+
+    def append_output(self, data: str) -> None:
+        if not data:
+            return
+        with open(self.output_path, "a", encoding="utf-8", errors="replace") as fp:
+            fp.write(data)
+            fp.flush()
+
+    async def send(self, payload: str) -> None:
+        msg = json.loads(payload)
+        msg_type = msg.get("type")
+        if msg_type == "pty_started":
+            self._write_status(active=True, pty_started=True, session_id=msg.get("session_id"))
+            return
+        if msg_type == "pty_output":
+            self.append_output(str(msg.get("data", "")))
+            return
+        if msg_type == "pty_exited":
+            try:
+                self.exit_code = int(msg.get("exit_code", -1))
+            except Exception:
+                self.exit_code = -1
+            self._write_status(
+                active=False,
+                ended_at=datetime.now().isoformat(),
+                exit_code=self.exit_code,
+            )
+            self._done.set()
+            return
+        if msg_type == "pty_error":
+            self.error = str(msg.get("error", ""))
+            if self.error:
+                self.append_output(f"\r\n[PTY error] {self.error}\r\n")
+            self._write_status(
+                active=False,
+                ended_at=datetime.now().isoformat(),
+                exit_code=-1,
+                error=self.error,
+            )
+            self._done.set()
+
+    def _read_new_events(self) -> list[dict[str, Any]]:
+        if not self.input_path.exists():
+            return []
+        try:
+            with open(self.input_path, "r", encoding="utf-8", errors="replace") as fp:
+                fp.seek(self._input_offset)
+                chunk = fp.read()
+                self._input_offset = fp.tell()
+        except Exception:
+            return []
+
+        if not chunk:
+            return []
+
+        events: list[dict[str, Any]] = []
+        data = self._input_buffer + chunk
+        self._input_buffer = ""
+        for line in data.splitlines(keepends=True):
+            if not line.endswith("\n"):
+                self._input_buffer = line
+                continue
+            raw = line.strip()
+            if not raw:
+                continue
+            try:
+                parsed = json.loads(raw)
+            except Exception:
+                continue
+            if isinstance(parsed, dict):
+                events.append(parsed)
+        return events
+
+    async def pump_inputs(self, pty_proc: Any) -> None:
+        while not self._done.is_set():
+            if getattr(getattr(pty_proc, "proc", None), "returncode", None) is not None:
+                break
+            for event in self._read_new_events():
+                event_type = str(event.get("type", "")).strip().lower()
+                if event_type == "input":
+                    data = str(event.get("data", ""))
+                    if data:
+                        await pty_proc.send_input(data)
+                elif event_type == "interrupt":
+                    await pty_proc.interrupt()
+                elif event_type == "close":
+                    await pty_proc.close()
+            await asyncio.sleep(0.1)
+
+    async def wait(self) -> int:
+        await self._done.wait()
+        return self.exit_code if self.exit_code is not None else -1
+
+
+async def run_tui_managed_interactive_command(
+    command: str,
+    *,
+    request_id: str,
+    control_dir: Path,
+    mode: str = "restricted",
+    allowed_dirs: list[str] | None = None,
+) -> dict:
+    if mode == "restricted" and allowed_dirs:
+        ok, reason = validate_command(command, allowed_dirs)
+        if not ok:
+            return {"stdout": "", "stderr": reason, "exit_code": 1}
+
+    cwd = allowed_dirs[0] if allowed_dirs else None
+    bridge = _LocalInteractivePTYBridge(control_dir=control_dir, request_id=request_id, command=command)
+    bridge.activate()
+    bridge.append_output(f"$ {command}\r\n")
+
+    session_id = request_id or str(uuid.uuid4())
+    input_task: asyncio.Task[Any] | None = None
+    pty_proc = None
+    try:
+        if IS_WINDOWS:
+            pty_proc = PipeProcess(
+                session_id,
+                command,
+                120,
+                40,
+                mode=mode,
+                allowed_dirs=allowed_dirs,
+            )
+        else:
+            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()
+        return {
+            "stdout": "(interactive session completed)",
+            "stderr": "",
+            "exit_code": exit_code,
+        }
+    except Exception as e:
+        message = str(e)
+        bridge.append_output(f"\r\n[Interactive error] {message}\r\n")
+        bridge._write_status(
+            active=False,
+            ended_at=datetime.now().isoformat(),
+            exit_code=-1,
+            error=message,
+        )
+        return {"stdout": "", "stderr": message, "exit_code": -1}
+    finally:
+        if input_task and not input_task.done():
+            input_task.cancel()
+            try:
+                await input_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+        if pty_proc is not None:
+            try:
+                await pty_proc.close()
+            except Exception:
+                pass
+
+
 def _zip_directory(resolved, tmp_path, mode, allowed_dirs):
     """Synchronous helper to zip a directory (run via asyncio.to_thread)."""
     import zipfile
@@ -2520,6 +2745,7 @@ async def connect(
                             command,
                             mode=mode,
                             allowed_dirs=allowed_dirs,
+                            request_id=request_id,
                         )
                         exit_code = result["exit_code"]
                         success = exit_code == 0

{kiwi_code-0.0.40 → kiwi_code-0.0.42}/src/kiwi_tui/main.py

@@ -610,11 +610,12 @@ class AutobotsTUI(App):
         #     runtime_manager.save_refresh_token(tokens.refresh_token)
 
     def _refresh_token_if_needed(self, force: bool = False) -> bool:
-        """Synchronize auth state from disk and refresh only when needed.
+        """Synchronize auth state from disk and refresh when needed.
 
         Args:
-            force: If True, re-check disk state immediately and refresh only if
-                the shared on-disk access token is still expired.
+            force: If True, attempt a refresh-token exchange immediately even if
+                the current access token does not appear expired on disk. This is
+                used after an HTTP 401/403 from the server.
         """
         with self.token_manager.file_lock():
             tokens = self.token_manager.load_tokens()
@@ -622,7 +623,7 @@ class AutobotsTUI(App):
                 logger.debug("No tokens to refresh")
                 return False
 
-            if not tokens.is_expired():
+            if not force and not tokens.is_expired():
                 logger.debug("Token on disk is valid; synchronizing in-memory auth state")
                 if getattr(tokens, "access_token", None):
                     self.autobots_client.update_token(tokens.access_token)
@@ -683,6 +684,55 @@ class AutobotsTUI(App):
         except Exception:
             pass
 
+    def _handle_auth_expired(self, reason: str | None = None) -> None:
+        """Clear auth state and return the user to the login screen.
+
+        Used when the server rejects the current session (401/403) and a forced
+        token refresh cannot recover it.
+        """
+        logger.warning(f"Authentication expired; redirecting to login. Reason: {reason or 'unknown'}")
+
+        try:
+            screen = self.screen
+            if hasattr(screen, "reset_for_auth_expired"):
+                screen.reset_for_auth_expired()
+        except Exception:
+            pass
+
+        timer = getattr(self, "_token_refresh_timer", None)
+        if timer is not None:
+            try:
+                timer.stop()
+            except Exception:
+                pass
+            self._token_refresh_timer = None
+
+        self.pending_runtime_id = None
+        self.token_manager.clear_tokens()
+        self._kiwi_token = None
+
+        self.autobots_client = AutobotsClientWrapper(
+            base_url=self.config.backend_url,
+            api_key=self.config.api_key,
+        )
+
+        try:
+            already_on_login = type(self.screen).__name__ == "LoginScreen"
+        except Exception:
+            already_on_login = False
+
+        if not already_on_login:
+            try:
+                self.switch_screen("login")
+            except IndexError:
+                self.push_screen("login")
+
+        self.notify(
+            reason or "Your session expired. Please log in again.",
+            severity="error",
+            title="Authentication required",
+        )
+
     def action_logout(self) -> None:
         """Logout user and return to login screen."""
         logger.info("User logout requested")

{kiwi_code-0.0.40 → kiwi_code-0.0.42}/src/kiwi_tui/runtime_agent.py

@@ -57,6 +57,7 @@ class RuntimeConnectArgs:
 RUNTIMES_DIR = Path.home() / ".kiwi" / "runtimes"
 BY_RUN_DIR = RUNTIMES_DIR / "by-run"
 PENDING_DIR = RUNTIMES_DIR / "pending"
+CONTROL_DIR = RUNTIMES_DIR / "control"
 
 
 # Runtime log truncation
@@ -282,6 +283,11 @@ def _runtime_dir_for_pending(pending_id: str) -> Path:
     d.mkdir(parents=True, exist_ok=True)
     return d
 
+def _control_dir_for_runtime(control_id: str) -> Path:
+    d = CONTROL_DIR / control_id
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
 
 def pid_path_for_run(run_id: str) -> Path:
     return _runtime_dir_for_run(run_id) / "pid"
@@ -336,6 +342,19 @@ def meta_path_for_pending(pending_id: str) -> Path:
     return _runtime_dir_for_pending(pending_id) / "meta.json"
 
 
+def control_dir_from_meta(meta_path: Path) -> Path | None:
+    if not meta_path.exists():
+        return None
+    try:
+        meta = json.loads(meta_path.read_text(encoding="utf-8") or "{}")
+    except Exception:
+        return None
+
+    control_dir = meta.get("control_dir")
+    if isinstance(control_dir, str) and control_dir.strip():
+        return Path(control_dir)
+    return None
+
 def get_running_pid_for_run(run_id: str) -> int | None:
     pid = _read_pid(pid_path_for_run(run_id))
     if not pid:
@@ -434,6 +453,11 @@ def _spawn_runtime(
     env.setdefault("PYTHONUTF8", "1")
     env.setdefault("PYTHONIOENCODING", "utf-8:replace")
 
+    control_id = str(uuid.uuid4())
+    control_dir = _control_dir_for_runtime(control_id)
+    env["KIWI_TUI_MANAGED"] = "1"
+    env["KIWI_RUNTIME_CONTROL_DIR"] = str(control_dir)
+
     try:
         log_path.parent.mkdir(parents=True, exist_ok=True)
         log_fp = open(log_path, "a", encoding="utf-8", errors="replace")
@@ -471,6 +495,9 @@ def _spawn_runtime(
         "allow": list(args.allow_dirs),
         "email": args.email,
         "pid": proc.pid,
+        "tui_managed": True,
+        "control_id": control_id,
+        "control_dir": str(control_dir),
     }
     try:
         meta["create_time"] = psutil.Process(proc.pid).create_time()