kiwi-code 0.0.511__tar.gz → 0.0.513__tar.gz

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kiwi-code
-Version: 0.0.511
+Version: 0.0.513
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://kiwicode.ai
 Author-email: Anurag <anurag@meetkiwi.co>

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.511"
+version = "0.0.513"
 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.511 → kiwi_code-0.0.513}/src/kiwi_cli/autocode.py

@@ -8,6 +8,11 @@ contains "autocode" in any spelling: "Autocode", "AutoCodeClaude",
 When two of them have the same name ignoring case, spaces and punctuation
 ("AutocodeClaude" and "AutoCodeClaude", "Autocode OpenAI Flash" and
 "AutocodeOpenaiFlash"), only the most recently created one is kept.
+
+Which one a new session starts with depends on the account (``default_id_for``):
+Work (Enterprise, api.meetkiwi.ai) starts with "Autocode OpenAI Flash", Personal
+(Subscription, api.runkai.ai) and every other server with "Autocode". The VS Code
+extension makes the same choice (src/defaultAgent.ts).
 """
 
 import re
@@ -17,11 +22,17 @@ from datetime import datetime, timezone
 from pykiwiai import AuthenticatedClient
 from pykiwiai.api.actions import list_system_actions_v1_actions_system_actions_get
 
+from kiwi_cli.server import SERVER_PRESETS
+
 # Fetch every system action in one page: paging with offset is not reliable on
 # the servers (offset > 0 returns an empty page).
 _SYSTEM_ACTIONS_LIMIT = 500
 
 
+#: The default on the Work (Enterprise) server, compared as _normalize compares names.
+_ENTERPRISE_DEFAULT = "autocodeopenaiflash"
+
+
 def _normalize(name: object) -> str:
     return re.sub(r"[^a-z0-9]", "", str(name or "").lower())
 
@@ -64,6 +75,28 @@ class AutocodeActions:
                 return action.id
         return self.actions[0].id if self.actions else None
 
+    def name_of(self, action_id: object) -> str | None:
+        """The name of the AutoCode action ``action_id``, or None if it is not one."""
+        for action in self.actions:
+            if action.id == action_id:
+                return action.name
+        return None
+
+    def default_id_for(self, backend_url: object) -> str | None:
+        """The action a new session starts with on ``backend_url``: "Autocode OpenAI
+        Flash" on the Work (Enterprise) server when it has one, else ``default_id``."""
+        if is_enterprise_backend(backend_url):
+            for action in self.actions:
+                if _normalize(action.name) == _ENTERPRISE_DEFAULT:
+                    return action.id
+        return self.default_id
+
+
+def is_enterprise_backend(backend_url: object) -> bool:
+    """True for the Work (Enterprise) server, api.meetkiwi.ai."""
+    url = str(backend_url or "").strip().rstrip("/").lower()
+    return url == SERVER_PRESETS["work"]["http"]
+
 
 def _created(action: AutocodeAction) -> datetime:
     """When the action was created. Falls back to the timestamp in its ObjectId."""

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/src/kiwi_cli/terminal_mode.py

@@ -227,10 +227,11 @@ def _default_action_id(session: _TerminalSession) -> str:
     found = fetch_autocode_actions(session.client.client)
     if found.status_code in (401, 403) and _refresh_tokens(session):
         found = fetch_autocode_actions(session.client.client)
-    if found.default_id is None:
+    default_id = found.default_id_for(session.backend_url)
+    if default_id is None:
         detail = "no AutoCode actions on this server" if found.ok else f"HTTP {found.status_code}"
         raise TerminalModeError(f"Could not find the AutoCode action ({detail}). Pass --action-id to choose one.")
-    return found.default_id
+    return default_id
 
 
 def _build_authenticated_session(server: str | None) -> _TerminalSession:

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/src/kiwi_runtime/commands.py

@@ -1,6 +1,8 @@
 """One-off and interactive commands."""
 import asyncio
+import json
 import os
+import re
 import shlex
 import signal
 import subprocess
@@ -9,6 +11,7 @@ import time
 import uuid
 from collections import deque
 from typing import Any
+from urllib.parse import unquote, urlsplit
 
 from kiwi_runtime.constants import (
     IS_WINDOWS,
@@ -222,13 +225,94 @@ async def _kill_command(proc: asyncio.subprocess.Process) -> None:
         pass
 
 
+#: Values shorter than this are not masked: too likely to match ordinary output.
+_MIN_MASKED_LEN = 6
+#: What a forwarded variable's name may be; anything else is refused.
+_ENV_NAME = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+#: At most this many forwarded variables, each at most this long.
+_MAX_ENV_VARS = 64
+_MAX_ENV_VALUE = 16_384
+
+
+def command_env(value: Any) -> dict[str, str] | None:
+    """
+    The `env` a one-off or interactive command message carries (connection credentials
+    the backend resolved for it), checked: string names a shell accepts, string values, a
+    bounded number. Anything else is dropped rather than half-applied. None when there is none.
+    """
+    if not isinstance(value, dict) or not value:
+        return None
+    env: dict[str, str] = {}
+    for key, val in list(value.items())[:_MAX_ENV_VARS]:
+        if isinstance(key, str) and _ENV_NAME.match(key) and isinstance(val, str) and len(val) <= _MAX_ENV_VALUE:
+            env[key] = val
+    return env or None
+
+
+#: Strings in a JSON credential (a service account's private key and the like) shorter
+#: than this are not masked on their own: field names, types, project ids.
+_MIN_JSON_SECRET_LEN = 16
+
+
+def _secret_parts(value: str) -> list[str]:
+    """
+    What of a forwarded value a command could print and must not: the value itself; for a
+    header like "Bearer <token>", the token; for a database connection string, its
+    password; for a JSON credential (BigQuery), its long string fields (a private key).
+    Kept in step with the backend's terminal_tool._secret_parts and the extension's
+    runtime/commandEnv.ts.
+    """
+    parts = [value]
+    _, _, token = value.partition(" ")
+    parts.append(token)
+    if "://" in value:
+        try:
+            password = urlsplit(value).password
+        except ValueError:
+            password = None
+        if password:
+            parts += [password, unquote(password)]
+    if value.lstrip().startswith("{"):
+        try:
+            loaded = json.loads(value)
+        except ValueError:
+            loaded = None
+        if isinstance(loaded, dict):
+            for field in loaded.values():
+                if isinstance(field, str) and len(field) >= _MIN_JSON_SECRET_LEN:
+                    parts += [field, field.replace("\n", "\\n")]
+    return parts
+
+
+def mask_secrets(text: str, env: dict[str, str] | None) -> str:
+    """
+    Every forwarded value in `text` replaced by its variable's name, in case the command
+    printed one: each value whole, and the parts of it that are secrets on their own
+    (`_secret_parts`). (The backend masks again; this keeps it from leaving the machine
+    at all.)
+    """
+    if not text or not env:
+        return text
+    pairs = [
+        (part, key)
+        for key, value in env.items()
+        for part in _secret_parts(value)
+        if len(part) >= _MIN_MASKED_LEN
+    ]
+    for value, key in sorted(pairs, key=lambda p: len(p[0]), reverse=True):
+        text = text.replace(value, f"[{key}]")
+    return text
+
+
 async def run_command(
     command: str,
     timeout: int = 30,
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
+    env: dict[str, str] | None = None,
 ) -> dict:
-    """Execute a shell command and return stdout, stderr, exit_code."""
+    """Execute a shell command and return stdout, stderr, exit_code. `env` is added to this
+    command's environment only, on top of the runtime's own; it is not logged."""
     # Validate in restricted mode
     if mode == "restricted" and allowed_dirs:
         ok, reason = validate_command(command, allowed_dirs)
@@ -248,6 +332,8 @@ async def run_command(
             "stdin": asyncio.subprocess.DEVNULL,
             "cwd": cwd,
         }
+        if env:
+            popen_kwargs["env"] = {**os.environ, **env}
         if not IS_WINDOWS:
             popen_kwargs["start_new_session"] = True
 
@@ -294,8 +380,11 @@ async def run_interactive_command(
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
     request_id: str | None = None,
+    env: dict[str, str] | None = None,
 ) -> dict:
-    """Execute a command with the user's terminal attached for interactive I/O."""
+    """Execute a command with the user's terminal attached for interactive I/O. `env` is
+    added to this command's environment only, as for run_command. What the command prints
+    goes to the user's terminal, never to the server: the server gets only the exit code."""
     if mode == "restricted" and allowed_dirs:
         ok, reason = validate_command(command, allowed_dirs)
         if not ok:
@@ -317,6 +406,8 @@ async def run_interactive_command(
             mode=mode,
             allowed_dirs=allowed_dirs,
             timeout_sec=timeout_eff,
+            env=env,
+            mask=(lambda text: mask_secrets(text, env)) if env else None,
         )
 
     try:
@@ -346,6 +437,8 @@ async def run_interactive_command(
                         old_term = None
 
                 popen_kwargs: dict[str, Any] = {"shell": True, "cwd": cwd}
+                if env:
+                    popen_kwargs["env"] = {**os.environ, **env}
                 if not IS_WINDOWS:
                     popen_kwargs["start_new_session"] = True
                 # The command writes to the terminal directly; what was printed goes first.

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/src/kiwi_runtime/handlers.py

@@ -5,7 +5,7 @@ import sys
 from typing import Any, Awaitable, Callable
 
 from kiwi_runtime.checkpoints import _set_current_run_id
-from kiwi_runtime.commands import _looks_interactive_oneoff, run_interactive_command
+from kiwi_runtime.commands import _looks_interactive_oneoff, command_env, run_interactive_command
 from kiwi_runtime.constants import IS_WINDOWS
 from kiwi_runtime.fs.handler import FS_HANDLERS, handle_fs_request
 from kiwi_runtime.restricted import validate_command
@@ -79,8 +79,10 @@ async def _command(state: _RuntimeState, msg: dict[str, Any]) -> None:
         timeout_sec = int(msg.get("timeout_sec", 30) or 30)
     except Exception:
         timeout_sec = 30
+    # App connection credentials for this command only (the "command_env" capability).
+    env = command_env(msg.get("env"))
     try:
-        state.command_queue.put_nowait((str(request_id), str(command), timeout_sec))
+        state.command_queue.put_nowait((str(request_id), str(command), timeout_sec, env))
     except asyncio.QueueFull:
         print_cmd_log(request_id, f"{RED}FAILED{RESET}", False)
         await state.reply(_command_result(request_id, "Runtime command queue full; please retry."))
@@ -90,6 +92,8 @@ async def _interactive(state: _RuntimeState, msg: dict[str, Any]) -> None:
     request_id = msg.get("request_id", "")
     command = msg.get("command", "")
     print_cmd_log(request_id, f"$ {BOLD}{command}{RESET} {GREY}(interactive){RESET}")
+    # Connection credentials for this command only; never logged.
+    env = command_env(msg.get("env"))
 
     try:
         timeout_sec = int(msg.get("timeout_sec", 120) or 120)
@@ -103,6 +107,7 @@ async def _interactive(state: _RuntimeState, msg: dict[str, Any]) -> None:
             mode=state.mode,
             allowed_dirs=state.allowed_dirs,
             request_id=request_id,
+            env=env,
         )
         exit_code = result["exit_code"]
         success = exit_code == 0

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/src/kiwi_runtime/link.py

@@ -11,7 +11,7 @@ from pathlib import Path
 import websockets
 
 from kiwi_runtime.auth import _get_valid_access_token, login
-from kiwi_runtime.commands import run_command
+from kiwi_runtime.commands import mask_secrets, run_command
 from kiwi_runtime.constants import MAX_INBOUND_FRAME_BYTES
 from kiwi_runtime.fs.handler import FS_MAX_CONCURRENCY
 from kiwi_runtime.handlers import handle_message
@@ -32,7 +32,10 @@ from kiwi_runtime.ui import (
 #   goodbye      sends {"type": "goodbye"} before an intentional exit
 #   outbox       keeps what it could not send and delivers it after reconnecting
 #   pty_survive  keeps its PTY sessions across a reconnect and lists them at auth
-RUNTIME_CAPABILITIES = ["goodbye", "outbox", "pty_survive"]
+#   command_env  takes an `env` mapping on a one-off or interactive command (connection
+#                credentials), adds it to that command's environment only, and masks it in
+#                the output
+RUNTIME_CAPABILITIES = ["goodbye", "outbox", "pty_survive", "command_env"]
 
 RECONNECT_BASE_DELAY_SEC = 1.5
 RECONNECT_MAX_DELAY_SEC = 30.0
@@ -89,11 +92,11 @@ async def _command_worker(state: _RuntimeState, mode: str, allowed_dirs: list[st
     """Runs one-off commands from the queue; a result outlives the connection it was asked
     on. Each command is its own shell, so several workers run them side by side."""
     while True:
-        request_id, command, timeout_sec = await state.command_queue.get()
+        request_id, command, timeout_sec, env = await state.command_queue.get()
         state.running_commands.append(command)
         try:
             result = await run_command(
-                command, timeout=timeout_sec or 30, mode=mode, allowed_dirs=allowed_dirs
+                command, timeout=timeout_sec or 30, mode=mode, allowed_dirs=allowed_dirs, env=env
             )
             try:
                 exit_code = int(result.get("exit_code", 0))
@@ -111,6 +114,14 @@ async def _command_worker(state: _RuntimeState, mode: str, allowed_dirs: list[st
         finally:
             state.running_commands.remove(command)
             state.command_queue.task_done()
+        if env:
+            # A credential the command printed must not reach the server, the model or the
+            # chat: each value is replaced by its variable's name.
+            result = {
+                **result,
+                "stdout": mask_secrets(result.get("stdout", ""), env),
+                "stderr": mask_secrets(result.get("stderr", ""), env),
+            }
         await state.link.send(json.dumps({"type": "result", "request_id": request_id, **result}))
 
 

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/src/kiwi_runtime/sessions.py

@@ -149,9 +149,12 @@ if not IS_WINDOWS:
             cols: int = 120,
             rows: int = 40,
             on_exit: Callable[[], None] | None = None,
+            env: dict[str, str] | None = None,
         ):
             self.session_id = session_id
             self.command = command
+            # Added to this process's environment only (connection credentials); not logged.
+            self.env = env
             self.cols = cols
             self.rows = rows
             self.master_fd = None
@@ -190,6 +193,7 @@ if not IS_WINDOWS:
                 stderr=self.slave_fd,
                 preexec_fn=_own_terminal,
                 cwd=cwd,
+                env={**os.environ, **self.env} if self.env else None,
             )
 
             os.close(self.slave_fd)
@@ -422,9 +426,12 @@ class PipeProcess:
         rows: int = 40,
         mode: str = "restricted",
         allowed_dirs: list[str] | None = None,
+        env: dict[str, str] | None = None,
     ):
         self.session_id = session_id
         self.command = command
+        # Added to this process's environment only (connection credentials); not logged.
+        self.env = env
         self.cols = cols
         self.rows = rows
         self.proc = None
@@ -444,6 +451,7 @@ class PipeProcess:
         self.cwd = cwd
         self.ws = ws
         self._sentinel_buffer = ""
+        env = {**os.environ, **self.env} if self.env else None
 
         if IS_WINDOWS:
             shell = os.environ.get("COMSPEC", "cmd.exe")
@@ -457,6 +465,7 @@ class PipeProcess:
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.STDOUT,
                 cwd=cwd,
+                env=env,
                 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
             )
         else:
@@ -467,6 +476,7 @@ class PipeProcess:
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.STDOUT,
                 cwd=cwd,
+                env=env,
             )
 
         self._read_task = asyncio.create_task(self._read_loop(ws))

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/src/kiwi_runtime/tui_bridge.py

@@ -5,7 +5,7 @@ import os
 import uuid
 from datetime import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from kiwi_runtime.constants import (
     IS_WINDOWS,
@@ -30,8 +30,17 @@ def _tui_managed_control_dir() -> Path | None:
 
 
 class _LocalInteractivePTYBridge:
-    def __init__(self, *, control_dir: Path, request_id: str, command: str) -> None:
+    def __init__(
+        self,
+        *,
+        control_dir: Path,
+        request_id: str,
+        command: str,
+        mask: Callable[[str], str] | None = None,
+    ) -> None:
         self.control_dir = control_dir
+        # Hides forwarded credentials in what is written to output.log for the TUI to show.
+        self._mask = mask
         self.request_id = request_id
         self.command = command
         self.session_dir = control_dir / "interactive"
@@ -75,6 +84,10 @@ class _LocalInteractivePTYBridge:
     def append_output(self, data: str) -> None:
         if not data:
             return
+        if self._mask is not None:
+            # Chunk by chunk: a value split across two reads is not caught. The file stays on
+            # this machine and nothing of it is sent to the server.
+            data = self._mask(data)
         with open(self.output_path, "a", encoding="utf-8", errors="replace") as fp:
             fp.write(data)
             fp.flush()
@@ -179,6 +192,8 @@ async def run_tui_managed_interactive_command(
     mode: str = "restricted",
     allowed_dirs: list[str] | None = None,
     timeout_sec: int | None = None,
+    env: dict[str, str] | None = None,
+    mask: Callable[[str], str] | None = None,
 ) -> dict:
     if mode == "restricted" and allowed_dirs:
         ok, reason = validate_command(command, allowed_dirs)
@@ -186,7 +201,9 @@ async def run_tui_managed_interactive_command(
             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 = _LocalInteractivePTYBridge(
+        control_dir=control_dir, request_id=request_id, command=command, mask=mask
+    )
     await asyncio.to_thread(bridge.activate)
     await asyncio.to_thread(bridge.append_output, f"$ {command}\r\n")
 
@@ -202,9 +219,10 @@ async def run_tui_managed_interactive_command(
                 40,
                 mode=mode,
                 allowed_dirs=allowed_dirs,
+                env=env,
             )
         else:
-            pty_proc = PTYProcess(session_id, command, 120, 40)
+            pty_proc = PTYProcess(session_id, command, 120, 40, env=env)
         await pty_proc.start(bridge, cwd=cwd)
         input_task = asyncio.create_task(bridge.pump_inputs(pty_proc))
 

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/src/kiwi_tui/screens/term_dashboard.py

@@ -1503,7 +1503,8 @@ class TermDashboardScreen(Screen):
             cwd = str(Path.cwd())
             cwd_short = cwd if len(cwd) <= 44 else f"{cwd[:20]}…{cwd[-20:]}"
 
-            action = self.current_action_name or self.current_action_id or ""
+            # While its name loads, an action shows as "…", not as its id.
+            action = self.current_action_name or ("…" if self.current_action_id else "")
             action = str(action)
             action_short = action if len(action) <= 16 else (action[:12] + "…")
 
@@ -1643,7 +1644,7 @@ class TermDashboardScreen(Screen):
     def _refresh_welcome_meta(self) -> None:
         """Update action name + run id displayed in the welcome header."""
         try:
-            action = self.current_action_name or self.current_action_id or "—"
+            action = self.current_action_name or ("…" if self.current_action_id else "—")
             run = self.current_run_id or "—"
             self.query_one("#term-welcome-account", Static).update(self._account_text())
             self.query_one("#term-welcome-action", Static).update(f"Action: {action}")
@@ -1764,9 +1765,14 @@ class TermDashboardScreen(Screen):
         except Exception as e:
             logger.debug(f"Loading AutoCode actions failed: {e}")
         if not self.current_action_id and self._autocode is not None:
-            self.current_action_id = self._autocode.default_id or ""
+            self.current_action_id = self._autocode.default_id_for(self._autocode_backend) or ""
         requested_id = self.current_action_id
-        if not requested_id:
+        # An AutoCode action's name is already in the list just fetched: show it with the
+        # id, rather than the id first and the name a request later.
+        known = self._autocode.name_of(requested_id) if self._autocode is not None and requested_id else None
+        if known and not self.current_action_name:
+            self.current_action_name = known
+        if not requested_id or known:
             self._refresh_top_bar()
             self._refresh_hint_model()
             self._refresh_input_label()
@@ -1779,7 +1785,8 @@ class TermDashboardScreen(Screen):
         if resp.status_code == 200 and resp.parsed:
             self.current_action_name = getattr(resp.parsed, "name", None) or requested_id
         else:
-            self.current_action_name = None
+            # The name could not be found: the id is all there is to show.
+            self.current_action_name = requested_id
         self._refresh_top_bar()
         self._refresh_hint_model()
         self._refresh_input_label()

{kiwi_code-0.0.511 → kiwi_code-0.0.513}/tests/test_autocode_actions.py

@@ -154,3 +154,52 @@ def test_the_default_autocode_is_also_the_latest_one(monkeypatch):
     )
     found = fetch_autocode_actions(client=None)
     assert [a.id for a in found.actions] == ["new"] and found.default_id == "new"
+
+
+# The default by account: Work (Enterprise, api.meetkiwi.ai) starts with Autocode OpenAI
+# Flash, Personal (Subscription, api.runkai.ai) and every other server with Autocode. The
+# VS Code extension makes the same choice (src/defaultAgent.ts).
+
+WORK = "https://api.meetkiwi.ai"
+PERSONAL = "https://api.runkai.ai"
+
+
+def _flash_and_autocode(monkeypatch):
+    _respond(
+        monkeypatch,
+        200,
+        [
+            _doc("a", "Autocode"),
+            _doc("f1", "Autocode OpenAI Flash", created_at=datetime(2026, 5, 1)),
+            _doc("f2", "AutocodeOpenaiFlash", created_at=datetime(2026, 10, 24)),
+            _doc("c", "AutoCodeClaude", "claude"),
+        ],
+    )
+    return fetch_autocode_actions(client=None)
+
+
+@pytest.mark.parametrize("url", [WORK, WORK + "/", "https://API.meetkiwi.ai"])
+def test_work_starts_with_the_latest_flash(monkeypatch, url):
+    assert _flash_and_autocode(monkeypatch).default_id_for(url) == "f2"
+
+
+@pytest.mark.parametrize("url", [PERSONAL, "https://dev.api.myautobots.com", "http://localhost:8000", "", None])
+def test_personal_and_other_servers_start_with_autocode(monkeypatch, url):
+    assert _flash_and_autocode(monkeypatch).default_id_for(url) == "a"
+
+
+def test_work_without_flash_starts_with_autocode(monkeypatch):
+    _respond(monkeypatch, 200, [_doc("a", "Autocode"), _doc("c", "AutoCodeClaude", "claude")])
+    assert fetch_autocode_actions(client=None).default_id_for(WORK) == "a"
+
+
+def test_no_actions_means_no_default_on_work_either():
+    assert AutocodeActions(status_code=200).default_id_for(WORK) is None
+
+
+def test_name_of_gives_an_autocode_actions_name(monkeypatch):
+    found = _flash_and_autocode(monkeypatch)
+    assert found.name_of("f2") == "AutocodeOpenaiFlash"
+    assert found.name_of("a") == "Autocode"
+    assert found.name_of("unknown") is None
+    assert found.name_of(None) is None