kiwi-code 0.0.4__tar.gz → 0.0.6__tar.gz

{kiwi_code-0.0.4 → kiwi_code-0.0.6}/.gitignore

@@ -29,4 +29,4 @@ Thumbs.db
 *.log
 
 # Local config & tokens
-.autobots-tui/
+.kiwi/

kiwi_code-0.0.6/CLAUDE.md

@@ -0,0 +1,79 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Kiwi Code is a TUI + CLI client for the Kiwi AI platform. It provides a chat interface (Textual) and CLI tools (Typer) for managing AI actions, action graphs, and their runs. A WebSocket-based runtime agent executes shell commands on behalf of the LLM.
+
+## Build & Run Commands
+
+```bash
+# Package manager: uv | Build backend: hatchling | Python: 3.13+
+uv sync                    # Install/sync dependencies
+uv build                   # Build package
+
+# Run
+make run                   # Launch TUI (kiwi)
+make dev                   # TUI with live reload
+make serve                 # Serve TUI in browser (port 8566)
+make cli                   # Run CLI (kiwicli)
+make runtime ARGS="..."    # Run runtime agent with args
+
+# Test
+make test-hello            # Test backend API connection
+uv run python test_hello.py  # Same, without make
+
+# Clean
+make clean                 # Remove caches and build artifacts
+```
+
+There are three entry points defined in pyproject.toml:
+- `kiwi` → `kiwi_tui.main:main` (TUI)
+- `kiwicli` → `kiwi_cli.cli:cli` (CLI)
+- `kiwi-runtime` → `kiwi_runtime.main:main` (WebSocket agent)
+
+## Architecture
+
+```
+┌─────────────────────────────────┐
+│      Shared Libraries           │
+│  commands.py · client.py        │
+│  auth.py · models.py · config.py│
+└──────────┬──────────┬───────────┘
+           │          │
+    ┌──────▼──────┐   └──────────────┐
+    │ kiwi (TUI)  │   kiwicli (CLI)  │
+    │ Textual app │   Typer CLI      │
+    └──────┬──────┘   └──────────────┘
+           │ auto-starts
+    ┌──────▼──────────────────┐
+    │ kiwi-runtime            │
+    │ WebSocket agent         │
+    │ One per working dir     │
+    │ Survives TUI restarts   │
+    └─────────────────────────┘
+```
+
+**Key design decisions:**
+- Shared infrastructure lives in `kiwi_cli`; TUI imports from it via absolute imports (e.g., `from kiwi_cli.auth import TokenManager`)
+- One runtime agent per working directory, managed via `runtime_manager.py`
+- Runtime state stored in `~/.kiwi/runtimes/<key>/` (pid, log, cwd, tokens)
+- Auth tokens stored in `~/.kiwi/tokens.json` with 0600 permissions
+- Config stored in `~/.kiwi/config.json`
+
+## Three Source Packages
+
+- **`src/kiwi_cli/`** — Typer CLI app and shared infrastructure: auth, client, config, commands, models, runtime_manager, logger. Both `kiwi_tui` and the CLI entry point depend on this package.
+- **`src/kiwi_tui/`** — Textual TUI app, screens, and widgets. Imports shared modules from `kiwi_cli`.
+- **`src/kiwi_runtime/`** — Standalone WebSocket agent (~43KB `main.py`) that connects to Kiwi server and executes shell commands, sandboxed to CWD by default
+
+## Server Presets (runtime)
+
+- `app` → `https://api.meetkiwi.ai` (production)
+- `dev` → `https://dev.api.myautobots.com` (default for TUI)
+- `local` → `http://localhost:8000`
+
+## CI/CD
+
+GitHub Actions (`publish.yml`): triggered by manual dispatch or `v*.*.*` tags. Runs smoke tests (`kiwicli --help`, `kiwi-runtime --help`, `kiwicli runtime status`), builds, and publishes to PyPI.

{kiwi_code-0.0.4 → kiwi_code-0.0.6}/Makefile

@@ -1,4 +1,4 @@
-.PHONY: run dev cli runtime test-hello install sync clean help
+.PHONY: run dev serve cli runtime test-hello install sync clean help
 
 # Run the Kiwi TUI application
 run:
@@ -8,6 +8,10 @@ run:
 dev:
 	uv run --dev kiwi
 
+# Serve the Kiwi TUI in the browser via textual serve (e.g. make serve PORT=8566)
+serve:
+	uv run textual serve --port $(or $(PORT),8566) -c "python -m kiwi_tui.main"
+
 # Run the Kiwi CLI
 cli:
 	uv run kiwicli
@@ -53,6 +57,7 @@ help:
 	@echo "Commands:"
 	@echo "  run          - Run the Kiwi TUI application (kiwi)"
 	@echo "  dev          - Run TUI in development mode (with live reload)"
+	@echo "  serve        - Serve the TUI in the browser (PORT=8566 make serve)"
 	@echo "  cli          - Run the Kiwi CLI (kiwicli)"
 	@echo "  runtime      - Run the Kiwi Runtime agent (kiwi-runtime)"
 	@echo "                 e.g. make runtime ARGS=\"connect --server app\""

{kiwi_code-0.0.4 → kiwi_code-0.0.6}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.4
+Version: 0.0.6
 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>
-License: MIT
+License: Proprietary
 Keywords: cli,terminal,textual,tui
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <4.0,>=3.13
@@ -77,7 +77,7 @@ Kiwi Code has three entry points, but they are **not three services** — they a
 - **`kiwi` automatically spawns `kiwi-runtime`** when you log in. The runtime runs as an independent process — quitting or restarting the TUI does **not** kill it.
 - **One runtime per directory.** Each working directory gets its own runtime, scoped to that directory. Opening the TUI in two different project folders runs two independent runtimes.
 - **`kiwicli` is for headless/scripting use.** It provides the same query commands (actions, runs, graphs) as the TUI, but as standalone CLI commands.
-- **Authentication is shared.** Both use `TokenManager` to read/write tokens from `~/.autobots-tui/tokens.json`, so logging in via one works for the other.
+- **Authentication is shared.** Both use `TokenManager` to read/write tokens from `~/.kiwi/tokens.json`, so logging in via one works for the other.
 - **Runtime lifecycle is independent.** The runtime persists across TUI restarts. Use `kiwicli runtime stop` to explicitly stop it.
 
 ## Installation
@@ -207,7 +207,7 @@ In **restricted mode** (default), commands are sandboxed to the current working
 
 ## Configuration
 
-Stored at `~/.autobots-tui/config.json`:
+Stored at `~/.kiwi/config.json`:
 
 ```json
 {
@@ -218,7 +218,7 @@ Stored at `~/.autobots-tui/config.json`:
 }
 ```
 
-Logs are written to `~/.autobots-tui/autobots_tui.log`.
+Logs are written to `~/.kiwi/kiwi_tui.log`.
 
 ## Development
 
@@ -231,4 +231,4 @@ uv run kiwi
 
 ## License
 
-MIT
+Proprietary. All rights reserved.

{kiwi_code-0.0.4 → kiwi_code-0.0.6}/README.md

@@ -51,7 +51,7 @@ Kiwi Code has three entry points, but they are **not three services** — they a
 - **`kiwi` automatically spawns `kiwi-runtime`** when you log in. The runtime runs as an independent process — quitting or restarting the TUI does **not** kill it.
 - **One runtime per directory.** Each working directory gets its own runtime, scoped to that directory. Opening the TUI in two different project folders runs two independent runtimes.
 - **`kiwicli` is for headless/scripting use.** It provides the same query commands (actions, runs, graphs) as the TUI, but as standalone CLI commands.
-- **Authentication is shared.** Both use `TokenManager` to read/write tokens from `~/.autobots-tui/tokens.json`, so logging in via one works for the other.
+- **Authentication is shared.** Both use `TokenManager` to read/write tokens from `~/.kiwi/tokens.json`, so logging in via one works for the other.
 - **Runtime lifecycle is independent.** The runtime persists across TUI restarts. Use `kiwicli runtime stop` to explicitly stop it.
 
 ## Installation
@@ -181,7 +181,7 @@ In **restricted mode** (default), commands are sandboxed to the current working
 
 ## Configuration
 
-Stored at `~/.autobots-tui/config.json`:
+Stored at `~/.kiwi/config.json`:
 
 ```json
 {
@@ -192,7 +192,7 @@ Stored at `~/.autobots-tui/config.json`:
 }
 ```
 
-Logs are written to `~/.autobots-tui/autobots_tui.log`.
+Logs are written to `~/.kiwi/kiwi_tui.log`.
 
 ## Development
 
@@ -205,4 +205,4 @@ uv run kiwi
 
 ## License
 
-MIT
+Proprietary. All rights reserved.

{kiwi_code-0.0.4 → kiwi_code-0.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.4"
+version = "0.0.6"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.13,<4.0"
@@ -18,12 +18,12 @@ dependencies = [
 authors = [
     { name = "Anurag Jha", email = "anurag@meetkiwi.co" }
 ]
-license = { text = "MIT" }
+license = { text = "Proprietary" }
 keywords = ["tui", "textual", "terminal", "cli"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
+    "License :: Other/Proprietary License",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.13",
 ]
@@ -34,11 +34,11 @@ Repository = "https://github.com/jetoslabs/kiwi-code"
 
 [project.scripts]
 kiwi = "kiwi_tui.main:main"
-kiwicli = "kiwi_tui.cli:cli"
+kiwicli = "kiwi_cli.cli:cli"
 kiwi-runtime = "kiwi_runtime.main:main"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/kiwi_tui", "src/kiwi_runtime"]
+packages = ["src/kiwi_cli", "src/kiwi_tui", "src/kiwi_runtime"]
 
 [build-system]
 requires = ["hatchling"]

kiwi_code-0.0.6/src/kiwi_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Kiwi CLI - command-line interface and shared infrastructure modules."""
+
+__version__ = "0.1.0"

{kiwi_code-0.0.4/src/kiwi_tui → kiwi_code-0.0.6/src/kiwi_cli}/auth.py

@@ -15,10 +15,10 @@ class TokenManager:
         """Initialize token manager.
 
         Args:
-            token_path: Path to token file, defaults to ~/.autobots-tui/tokens.json
+            token_path: Path to token file, defaults to ~/.kiwi/tokens.json
         """
         if token_path is None:
-            token_path = Path.home() / ".autobots-tui" / "tokens.json"
+            token_path = Path.home() / ".kiwi" / "tokens.json"
 
         self.token_path = token_path
         self._tokens: Optional[AuthTokens] = None

{kiwi_code-0.0.4/src/kiwi_tui → kiwi_code-0.0.6/src/kiwi_cli}/cli.py

@@ -231,7 +231,7 @@ def whoami():
 @app.command()
 def tui():
     """Launch the interactive TUI."""
-    from .main import main
+    from kiwi_tui.main import main
     main()
 
 

{kiwi_code-0.0.4/src/kiwi_tui → kiwi_code-0.0.6/src/kiwi_cli}/client.py

@@ -229,39 +229,110 @@ class AutobotsClientWrapper:
             logger.error(error_msg)
             return False, None, error_msg
 
-    def run_action_async(self, action_id: str, user_input: str, action_result_id: Optional[str] = None) -> tuple[bool, Optional[str], str]:
+    def upload_files(self, file_paths: list[str]) -> tuple[bool, list[str], str]:
+        """Upload files via /v1/files/ API and return their URLs.
+
+        Args:
+            file_paths: List of local file paths to upload
+
+        Returns:
+            Tuple of (success, urls, message)
+        """
+        try:
+            if not isinstance(self.client, AuthenticatedClient):
+                return False, [], "Authentication required"
+
+            import mimetypes
+            from pathlib import Path
+            from autobots_client.api.files import upload_files_v1_files_post
+            from autobots_client.models.body_upload_files_v1_files_post import BodyUploadFilesV1FilesPost
+
+            # Validate all files exist first
+            paths = []
+            for fp in file_paths:
+                p = Path(fp).expanduser().resolve()
+                if not p.exists():
+                    return False, [], f"File not found: {fp}"
+                paths.append(p)
+
+            # The SDK's BodyUploadFilesV1FilesPost.to_multipart() sends files as
+            # text/plain strings, which doesn't work for binary uploads.
+            # Use the SDK's endpoint URL but build the multipart manually.
+            multipart_files = []
+            file_handles = []
+            for p in paths:
+                mime = mimetypes.guess_type(str(p))[0] or "application/octet-stream"
+                fh = open(p, "rb")
+                file_handles.append(fh)
+                multipart_files.append(("files", (p.name, fh, mime)))
+
+            http_client = self.client.get_httpx_client()
+            response = http_client.request(
+                method="POST",
+                url="/v1/files/public/",
+                files=multipart_files,
+            )
+
+            # Close opened file handles
+            for fh in file_handles:
+                fh.close()
+
+            if response.status_code == 200:
+                result = response.json()
+                urls = [item["url"] for item in result if "url" in item]
+                names = [item.get("name", "?") for item in result]
+                logger.info(f"Uploaded {len(urls)} file(s): {names}")
+                return True, urls, f"Uploaded {len(urls)} file(s)"
+            else:
+                error_msg = f"Upload failed: HTTP {response.status_code}"
+                logger.error(error_msg)
+                return False, [], error_msg
+
+        except Exception as e:
+            error_msg = f"Upload error: {e}"
+            logger.error(error_msg)
+            return False, [], error_msg
+
+    def run_action_async(self, action_id: str, user_input: str, action_result_id: Optional[str] = None, urls: Optional[list[str]] = None, metadata: Optional[dict] = None) -> tuple[bool, Optional[str], str]:
         """Run an action asynchronously and return the run ID.
 
         Args:
             action_id: ID of the action to run
             user_input: User input text for the action
             action_result_id: Optional ID to continue an existing conversation
+            urls: Optional list of file URLs to attach
+            metadata: Optional metadata dict to merge into the DataBlock
 
         Returns:
             Tuple of (success, run_id, message)
         """
         try:
             if action_result_id:
-                logger.info(f"Running action {action_id} with input: {user_input}, continuing run_id: {action_result_id}")
+                logger.info(f"Running action {action_id} with input: {user_input}, urls: {urls}, continuing run_id: {action_result_id}")
             else:
-                logger.info(f"Running action {action_id} with input: {user_input}")
+                logger.info(f"Running action {action_id} with input: {user_input}, urls: {urls}")
 
             if not isinstance(self.client, AuthenticatedClient):
                 return False, None, "Authentication required"
 
             # Create input body - DataBlock structure
+            default_metadata = {
+                "process_url_in_text": False,
+                "process_attachment_url": True,
+                "attachment_requested": 0
+            }
+            if metadata:
+                default_metadata.update(metadata)
+
             input_data = BodyAsyncRunActionV1ActionsIdAsyncRunPostInput()
             input_data.additional_properties = {
                 "text": user_input,
-                "urls": [],
-                "metadata": {
-                    "process_url_in_text": False,
-                    "process_attachment_url": True,
-                    "attachment_requested": 0
-                }
+                "urls": urls or [],
+                "metadata": default_metadata
             }
 
             body = BodyAsyncRunActionV1ActionsIdAsyncRunPost(input_=input_data)
+            logger.info(f"Request body: {body.to_dict()}")
 
             # Import UNSET for optional parameter
             from autobots_client.types import UNSET

{kiwi_code-0.0.4/src/kiwi_tui → kiwi_code-0.0.6/src/kiwi_cli}/commands.py

@@ -296,6 +296,26 @@ 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
+  /files                Show pending file uploads
+  /clear-files          Clear pending file uploads
+
+Metadata (persistent across runs):
+  /metadata             Show current metadata
+  /metadata set <k> <v> Set a metadata field
+  /metadata remove <k>  Remove a metadata field
+  /metadata clear       Clear all metadata
+
+Runtime:
+  /runtime status       Show runtime status
+  /runtime start        Start runtime
+  /runtime stop         Stop runtime
+  /runtime restart      Restart runtime
+  /runtime list         List all runtimes
+  /runtime logs         Show runtime logs
 
 Query:
   /actions list [--name NAME] [--limit N]

{kiwi_code-0.0.4/src/kiwi_tui → kiwi_code-0.0.6/src/kiwi_cli}/config.py

@@ -14,10 +14,10 @@ class ConfigManager:
         """Initialize config manager.
 
         Args:
-            config_path: Path to config file, defaults to ~/.autobots-tui/config.json
+            config_path: Path to config file, defaults to ~/.kiwi/config.json
         """
         if config_path is None:
-            config_path = Path.home() / ".autobots-tui" / "config.json"
+            config_path = Path.home() / ".kiwi" / "config.json"
 
         self.config_path = config_path
         self._config: Optional[AppConfig] = None

{kiwi_code-0.0.4/src/kiwi_tui → kiwi_code-0.0.6/src/kiwi_cli}/logger.py

@@ -16,7 +16,7 @@ def setup_logging(log_level: str = "INFO", log_file: str = "kiwi_tui.log") -> No
     logger.remove()
 
     # Only log to file, not to console (to avoid interference with Textual UI)
-    log_path = Path.home() / ".autobots-tui" / log_file
+    log_path = Path.home() / ".kiwi" / log_file
     log_path.parent.mkdir(parents=True, exist_ok=True)
 
     logger.add(

{kiwi_code-0.0.4/src/kiwi_tui → kiwi_code-0.0.6/src/kiwi_cli}/runtime_manager.py

@@ -1,7 +1,7 @@
 """Shared helpers for managing per-directory kiwi-runtime processes.
 
 Each working directory gets its own runtime, identified by a hash of the
-absolute path.  State is stored under ~/.autobots-tui/runtimes/<key>/:
+absolute path.  State is stored under ~/.kiwi/runtimes/<key>/:
     pid  — PID of the running process
     log  — stdout/stderr of the runtime
     cwd  — the working directory this runtime is scoped to
@@ -13,7 +13,7 @@ import signal
 import time
 from pathlib import Path
 
-RUNTIMES_DIR = Path.home() / ".autobots-tui" / "runtimes"
+RUNTIMES_DIR = Path.home() / ".kiwi" / "runtimes"
 
 
 def runtime_key(cwd: str | None = None) -> str:
@@ -58,6 +58,52 @@ def log_path(cwd: str | None = None) -> Path:
     return runtime_dir(cwd) / "log"
 
 
+def token_path(cwd: str | None = None) -> Path:
+    """Return the shared token file path for a directory's runtime."""
+    return runtime_dir(cwd) / "token"
+
+
+def refresh_token_path(cwd: str | None = None) -> Path:
+    """Return the shared refresh token file path for a directory's runtime."""
+    return runtime_dir(cwd) / "refresh_token"
+
+
+def save_token(token: str, cwd: str | None = None) -> None:
+    """Write a refreshed access token so the runtime can pick it up."""
+    tp = token_path(cwd)
+    tp.write_text(token)
+    tp.chmod(0o600)
+
+
+def save_refresh_token(token: str, cwd: str | None = None) -> None:
+    """Write the refresh token so the runtime can refresh on its own."""
+    tp = refresh_token_path(cwd)
+    tp.write_text(token)
+    tp.chmod(0o600)
+
+
+def read_token(cwd: str | None = None) -> str | None:
+    """Read the shared access token (returns None if missing)."""
+    tp = token_path(cwd)
+    if not tp.exists():
+        return None
+    try:
+        return tp.read_text().strip() or None
+    except OSError:
+        return None
+
+
+def read_refresh_token(cwd: str | None = None) -> str | None:
+    """Read the shared refresh token (returns None if missing)."""
+    tp = refresh_token_path(cwd)
+    if not tp.exists():
+        return None
+    try:
+        return tp.read_text().strip() or None
+    except OSError:
+        return None
+
+
 def stop_runtime(cwd: str | None = None) -> bool:
     """Stop the runtime for a directory. Returns True if a process was stopped."""
     pid = get_running_pid(cwd)