voice-vibecoder 2.6.0__tar.gz → 2.8.0__tar.gz

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 <!-- version list -->
 
+## v2.8.0 (2026-02-20)
+
+### Features
+
+- Add OpenClaw code provider
+  ([`910dc31`](https://github.com/snokam/voice-vibecoder/commit/910dc311df6a49f0e36e6bb53c98c2ea94753a25))
+
+- **server**: Add text message support
+  ([`86873ca`](https://github.com/snokam/voice-vibecoder/commit/86873cade8ec8feaa8479d120b86222fe106abdc))
+
+
+## v2.7.0 (2026-02-20)
+
+
 ## v2.6.0 (2026-02-20)
 
 ### Features

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.6.0
+Version: 2.8.0
 Summary: Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code
 Project-URL: Homepage, https://github.com/snokam/voice-vibecoder
 Project-URL: Repository, https://github.com/snokam/voice-vibecoder

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.6.0"
+version = "2.8.0"
 description = "Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/__init__.py

@@ -3,7 +3,7 @@
 A voice-controlled coding assistant using OpenAI Realtime API + Claude Code.
 """
 
-__version__ = "2.6.0"
+__version__ = "2.8.0"
 
 from voice_vibecoder.app_config import VoiceConfig
 from voice_vibecoder.ui.screen import VoiceCodingScreen

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/app_config.py

@@ -72,3 +72,7 @@ class VoiceConfig:
     # Raises ValueError on validation failure.
     # When None, auth is disabled (no auth frame expected from clients).
     authenticate: Callable[[str], Awaitable[tuple[str, str]]] | None = None
+
+    # Default agent type for new instances ("claude", "cursor", "openclaw").
+    # Can be overridden per-instance via send_to_agent/send_to_session.
+    default_agent: str = "claude"

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/code_providers/claude.py

@@ -242,6 +242,7 @@ class ClaudeRunner:
     ) -> AgentResult:
         result_text = ""
         result_session_id: str | None = None
+        got_content = False
 
         async def _prompt():
             yield {
@@ -251,54 +252,61 @@ class ClaudeRunner:
                 "session_id": session_id,
             }
 
-        async for msg in query(prompt=_prompt(), options=options):
-            if isinstance(msg, AssistantMessage):
-                for block in msg.content:
-                    if isinstance(block, TextBlock):
-                        text = block.text.strip()
-                        if text and on_output:
-                            for line in text.splitlines():
-                                if line.strip():
-                                    on_output(AgentOutput(
-                                        category="text", content=line,
-                                    ))
-
-                    elif isinstance(block, ToolUseBlock):
-                        if not block.name:
-                            continue
-                        desc = describe_tool_call(block.name, block.input)
-                        if on_output:
-                            category = (
-                                "file_edit" if block.name in ("Edit", "Write")
-                                else "bash" if block.name == "Bash"
-                                else "tool_call"
-                            )
-                            on_output(AgentOutput(
-                                category=category, content=desc,
-                            ))
-                            if block.name in ("Edit", "Write"):
-                                _emit_edit_diff(on_output, block.name, block.input)
-
-                    elif isinstance(block, ToolResultBlock):
-                        content = block.content or ""
-                        if isinstance(content, str) and content.strip() and on_output:
-                            preview = content[:200] + ("..." if len(content) > 200 else "")
-                            on_output(AgentOutput(
-                                category="tool_result", content=preview,
-                            ))
-
-            elif isinstance(msg, UserMessage):
-                if isinstance(msg.content, list):
+        try:
+            async for msg in query(prompt=_prompt(), options=options):
+                if isinstance(msg, AssistantMessage):
                     for block in msg.content:
-                        if isinstance(block, ToolResultBlock):
+                        if isinstance(block, TextBlock):
+                            text = block.text.strip()
+                            if text and on_output:
+                                got_content = True
+                                for line in text.splitlines():
+                                    if line.strip():
+                                        on_output(AgentOutput(
+                                            category="text", content=line,
+                                        ))
+
+                        elif isinstance(block, ToolUseBlock):
+                            if not block.name:
+                                continue
+                            got_content = True
+                            desc = describe_tool_call(block.name, block.input)
+                            if on_output:
+                                category = (
+                                    "file_edit" if block.name in ("Edit", "Write")
+                                    else "bash" if block.name == "Bash"
+                                    else "tool_call"
+                                )
+                                on_output(AgentOutput(
+                                    category=category, content=desc,
+                                ))
+                                if block.name in ("Edit", "Write"):
+                                    _emit_edit_diff(on_output, block.name, block.input)
+
+                        elif isinstance(block, ToolResultBlock):
                             content = block.content or ""
-                            if isinstance(content, str) and content.strip():
-                                pass  # Already routed via AssistantMessage
-
-            elif isinstance(msg, ResultMessage):
-                result_text = msg.result or ""
-                if msg.session_id:
-                    result_session_id = msg.session_id
+                            if isinstance(content, str) and content.strip() and on_output:
+                                preview = content[:200] + ("..." if len(content) > 200 else "")
+                                on_output(AgentOutput(
+                                    category="tool_result", content=preview,
+                                ))
+
+                elif isinstance(msg, UserMessage):
+                    if isinstance(msg.content, list):
+                        for block in msg.content:
+                            if isinstance(block, ToolResultBlock):
+                                content = block.content or ""
+                                if isinstance(content, str) and content.strip():
+                                    pass  # Already routed via AssistantMessage
+
+                elif isinstance(msg, ResultMessage):
+                    result_text = msg.result or ""
+                    if msg.session_id:
+                        result_session_id = msg.session_id
+        except ProcessError:
+            if not got_content and not result_text:
+                raise
+            logger.warning("CLI process error after content was already streamed")
 
         return AgentResult(text=result_text, session_id=result_session_id)
 

voice_vibecoder-2.8.0/src/voice_vibecoder/code_providers/openclaw.py

@@ -0,0 +1,369 @@
+"""OpenClaw Agent code provider.
+
+Implements the AgentRunner protocol using the OpenClaw Gateway WebSocket
+for streaming code agent interactions. Routes coding tasks to the
+OpenClaw gateway which can use any configured model and tools.
+
+This provider enables voice-vibecoder to use OpenClaw (Olaf) as the
+coding agent instead of Claude Code CLI. Benefits:
+- Same agent identity across all channels (Slack, voice, web)
+- Access to all MCP tools (Jira, GitHub, CVPartner, Snøkam APIs)
+- Persistent memory and context
+- Any model backend (Claude, GPT-4, etc.)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+import secrets
+import uuid
+from typing import Any, Awaitable, Callable
+
+from voice_vibecoder.code_providers import AgentOutput, AgentResult
+
+logger = logging.getLogger(__name__)
+
+# Default OpenClaw Gateway URL (loopback)
+DEFAULT_GATEWAY_URL = "ws://localhost:18789"
+
+
+def _extract_tool_info(line: str) -> tuple[str, str] | None:
+    """Extract tool name and description from agent output lines."""
+    match = re.match(r"^\[(\w+)\]\s*(.*)$", line.strip())
+    if match:
+        return match.group(1), match.group(2)
+    return None
+
+
+class OpenClawRunner:
+    """AgentRunner implementation using OpenClaw Gateway WebSocket.
+    
+    This provider routes coding tasks to OpenClaw, which can:
+    - Use any configured model (Claude, GPT-4, etc.)
+    - Access all MCP tools (Jira, GitHub, CVPartner, etc.)
+    - Maintain conversation context across sessions
+    - Use the same identity/persona as the main agent
+    """
+
+    def __init__(
+        self,
+        session_id: str | None = None,
+        agent_id: str | None = None,
+        env: dict[str, str] | None = None,
+        gateway_url: str | None = None,
+        gateway_token: str | None = None,
+        **_kwargs,
+    ) -> None:
+        self._session_id = session_id or f"voice-{uuid.uuid4().hex[:8]}"
+        self._agent_id = agent_id
+        self._env = env
+        self._gateway_url = gateway_url or os.environ.get("OPENCLAW_GATEWAY_URL", DEFAULT_GATEWAY_URL)
+        self._gateway_token = gateway_token or os.environ.get("OPENCLAW_GATEWAY_TOKEN")
+        self._task: asyncio.Task | None = None
+        self._ws = None
+
+    async def run(
+        self,
+        message: str,
+        cwd: str,
+        session_id: str | None = None,
+        on_output: Callable[[AgentOutput], None] | None = None,
+        can_use_tool: Callable[[str, dict, Any], Awaitable[Any]] | None = None,
+    ) -> AgentResult:
+        """Run a coding task via OpenClaw Gateway WebSocket."""
+        self._task = asyncio.current_task()
+        effective_session = session_id or self._session_id
+        
+        # Add working directory context
+        full_message = f"[Working directory: {cwd}]\n\n{message}"
+        
+        if on_output:
+            on_output(AgentOutput(
+                category="text",
+                content=f"🦞 Connecting to OpenClaw...",
+            ))
+
+        try:
+            # Try WebSocket first, fall back to CLI if it fails
+            result = await self._run_via_websocket(
+                full_message, effective_session, on_output, can_use_tool
+            )
+        except Exception as ws_error:
+            logger.warning("WebSocket connection failed, falling back to CLI: %s", ws_error)
+            if on_output:
+                on_output(AgentOutput(
+                    category="text", 
+                    content="WebSocket unavailable, using CLI...",
+                ))
+            result = await self._run_via_cli(
+                full_message, cwd, effective_session, on_output
+            )
+        
+        return result
+
+    async def _run_via_websocket(
+        self,
+        message: str,
+        session_id: str,
+        on_output: Callable[[AgentOutput], None] | None,
+        can_use_tool: Callable[[str, dict, Any], Awaitable[Any]] | None,
+    ) -> AgentResult:
+        """Connect to OpenClaw Gateway via WebSocket and stream the response."""
+        import websockets
+        
+        result_text = ""
+        result_session_id = session_id
+        
+        async with websockets.connect(self._gateway_url) as ws:
+            self._ws = ws
+            
+            # Wait for challenge
+            challenge_raw = await asyncio.wait_for(ws.recv(), timeout=5.0)
+            challenge = json.loads(challenge_raw)
+            
+            if challenge.get("event") != "connect.challenge":
+                raise ValueError(f"Expected connect.challenge, got: {challenge}")
+            
+            # Generate device identity
+            device_id = f"voice-vibecoder-{uuid.uuid4().hex[:8]}"
+            
+            # Send connect request
+            connect_req = {
+                "type": "req",
+                "id": secrets.token_hex(8),
+                "method": "connect",
+                "params": {
+                    "minProtocol": 3,
+                    "maxProtocol": 3,
+                    "client": {
+                        "id": "voice-vibecoder",
+                        "version": "1.0.0",
+                        "platform": "linux",
+                        "mode": "operator",
+                    },
+                    "role": "operator",
+                    "scopes": ["operator.read", "operator.write"],
+                    "caps": [],
+                    "commands": [],
+                    "permissions": {},
+                    "auth": {"token": self._gateway_token} if self._gateway_token else {},
+                    "locale": "en-US",
+                    "userAgent": "voice-vibecoder/1.0.0",
+                    "device": {
+                        "id": device_id,
+                    },
+                },
+            }
+            await ws.send(json.dumps(connect_req))
+            
+            # Wait for hello-ok
+            hello_raw = await asyncio.wait_for(ws.recv(), timeout=5.0)
+            hello = json.loads(hello_raw)
+            
+            if not hello.get("ok"):
+                error = hello.get("error", {}).get("message", "Unknown error")
+                raise ValueError(f"Connect failed: {error}")
+            
+            if on_output:
+                on_output(AgentOutput(category="text", content="Connected to OpenClaw"))
+            
+            # Send chat message
+            chat_req = {
+                "type": "req",
+                "id": secrets.token_hex(8),
+                "method": "chat.send",
+                "params": {
+                    "message": message,
+                    "sessionKey": session_id,
+                },
+            }
+            
+            if self._agent_id:
+                chat_req["params"]["agentId"] = self._agent_id
+            
+            await ws.send(json.dumps(chat_req))
+            
+            # Stream response
+            while True:
+                try:
+                    msg_raw = await asyncio.wait_for(ws.recv(), timeout=600.0)
+                    msg = json.loads(msg_raw)
+                except asyncio.TimeoutError:
+                    break
+                
+                msg_type = msg.get("type")
+                
+                if msg_type == "event":
+                    event = msg.get("event", "")
+                    payload = msg.get("payload", {})
+                    
+                    if event == "chat.chunk":
+                        # Streaming text chunk
+                        text = payload.get("text", "")
+                        if text and on_output:
+                            for line in text.splitlines():
+                                if line.strip():
+                                    tool_info = _extract_tool_info(line)
+                                    if tool_info:
+                                        tool_name, tool_desc = tool_info
+                                        category = (
+                                            "file_edit" if tool_name in ("Edit", "Write")
+                                            else "bash" if tool_name == "Bash"
+                                            else "tool_call"
+                                        )
+                                        on_output(AgentOutput(category=category, content=line))
+                                    else:
+                                        on_output(AgentOutput(category="text", content=line))
+                        result_text += text
+                    
+                    elif event == "chat.done":
+                        # Final response
+                        result_text = payload.get("text", result_text)
+                        result_session_id = payload.get("sessionKey", session_id)
+                        break
+                    
+                    elif event == "chat.error":
+                        error = payload.get("message", "Unknown error")
+                        raise RuntimeError(f"OpenClaw error: {error}")
+                
+                elif msg_type == "res":
+                    # Response to our request
+                    if not msg.get("ok"):
+                        error = msg.get("error", {}).get("message", "Unknown error")
+                        raise RuntimeError(f"Request failed: {error}")
+                    
+                    # chat.send returns immediately, response comes via events
+                    payload = msg.get("payload", {})
+                    if "text" in payload:
+                        result_text = payload["text"]
+                        break
+        
+        self._ws = None
+        
+        return AgentResult(
+            text=result_text,
+            session_id=result_session_id,
+        )
+
+    async def _run_via_cli(
+        self,
+        message: str,
+        cwd: str,
+        session_id: str,
+        on_output: Callable[[AgentOutput], None] | None,
+    ) -> AgentResult:
+        """Fallback: run via openclaw CLI."""
+        cmd = [
+            "openclaw", "agent",
+            "--session-id", session_id,
+            "--message", message,
+            "--json",
+            "--local",
+        ]
+        
+        if self._agent_id:
+            cmd.extend(["--agent", self._agent_id])
+        
+        env = os.environ.copy()
+        if self._env:
+            env.update(self._env)
+        if self._gateway_token:
+            env["OPENCLAW_GATEWAY_TOKEN"] = self._gateway_token
+        
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+            cwd=cwd,
+        )
+        
+        result_text = ""
+        
+        async def read_stdout():
+            nonlocal result_text
+            assert process.stdout
+            
+            buffer = ""
+            while True:
+                chunk = await process.stdout.read(1024)
+                if not chunk:
+                    break
+                
+                text = chunk.decode("utf-8", errors="replace")
+                buffer += text
+                
+                while "\n" in buffer:
+                    line, buffer = buffer.split("\n", 1)
+                    line = line.strip()
+                    
+                    if not line:
+                        continue
+                    
+                    try:
+                        data = json.loads(line)
+                        if isinstance(data, dict):
+                            if "result" in data:
+                                result_text = data["result"]
+                            elif "text" in data:
+                                result_text = data["text"]
+                        continue
+                    except json.JSONDecodeError:
+                        pass
+                    
+                    if on_output:
+                        tool_info = _extract_tool_info(line)
+                        if tool_info:
+                            tool_name, tool_desc = tool_info
+                            category = (
+                                "file_edit" if tool_name in ("Edit", "Write")
+                                else "bash" if tool_name == "Bash"
+                                else "tool_call"
+                            )
+                            on_output(AgentOutput(category=category, content=f"[{tool_name}] {tool_desc}"))
+                        else:
+                            on_output(AgentOutput(category="text", content=line))
+            
+            if buffer.strip():
+                try:
+                    data = json.loads(buffer)
+                    if isinstance(data, dict) and "result" in data:
+                        result_text = data["result"]
+                except json.JSONDecodeError:
+                    if on_output:
+                        on_output(AgentOutput(category="text", content=buffer.strip()))
+        
+        async def read_stderr():
+            assert process.stderr
+            async for line in process.stderr:
+                text = line.decode("utf-8", errors="replace").strip()
+                if text and on_output:
+                    on_output(AgentOutput(category="text", content=f"[stderr] {text}"))
+        
+        await asyncio.gather(read_stdout(), read_stderr())
+        await process.wait()
+        
+        if process.returncode != 0 and not result_text:
+            raise RuntimeError(f"OpenClaw CLI failed with exit code {process.returncode}")
+        
+        return AgentResult(
+            text=result_text,
+            session_id=session_id,
+        )
+
+    def cancel(self) -> bool:
+        """Cancel the running task."""
+        if self._ws:
+            asyncio.create_task(self._ws.close())
+            return True
+        
+        task = self._task
+        if task and not task.done():
+            task.cancel()
+            return True
+        
+        return False

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/code_providers/registry.py

@@ -34,6 +34,11 @@ def _make_cursor_runner(**_kw):
     return CursorRunner()
 
 
+def _make_openclaw_runner(session_id: str | None = None, agent_id: str | None = None, env: dict | None = None, **_kw):
+    from voice_vibecoder.code_providers.openclaw import OpenClawRunner
+    return OpenClawRunner(session_id=session_id, agent_id=agent_id, env=env)
+
+
 AGENTS: dict[str, AgentInfo] = {
     "claude": AgentInfo(
         id="claude",
@@ -49,6 +54,13 @@ AGENTS: dict[str, AgentInfo] = {
         color="green",
         runner_factory=_make_cursor_runner,
     ),
+    "openclaw": AgentInfo(
+        id="openclaw",
+        label="OpenClaw",
+        cli_command="openclaw",
+        color="red",
+        runner_factory=_make_openclaw_runner,
+    ),
 }
 
 

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/config.py

@@ -15,7 +15,7 @@ CHUNK_SIZE = AUDIO_SAMPLE_RATE * CHUNK_DURATION_MS // 1000
 Language = Literal["no", "en", "sv"]
 PermissionMode = Literal["bypass", "acceptEdits", "default"]
 InputMode = Literal["vad", "ptt"]
-AgentType = Literal["claude", "cursor"]
+AgentType = Literal["claude", "cursor", "openclaw"]
 
 
 def _agent_names(enabled: list[str] | None = None) -> str:

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/instances.py

@@ -125,6 +125,9 @@ class InstanceRegistry:
             self.on_status_change(instance.instance_id, instance.status)
         if self.on_instance_change:
             self.on_instance_change()
+        # Show file tree immediately when panel appears
+        from voice_vibecoder.tools.file_tree import start_file_tree_updates
+        start_file_tree_updates(instance.instance_id, worktree_path, self)
         return instance
 
     def create_session(self, name: str, agent_type: str = "claude") -> AgentInstance:
@@ -416,4 +419,11 @@ class InstanceRegistry:
                 self._branch_index[branch] = instance.instance_id
                 loaded.append(instance)
 
+        # Start file tree updates for restored code instances
+        from voice_vibecoder.tools.file_tree import start_file_tree_updates
+        for inst in loaded:
+            if inst.instance_type == InstanceType.SESSION:
+                continue
+            start_file_tree_updates(inst.instance_id, inst.worktree_path, self)
+
         return loaded

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/server.py

@@ -136,6 +136,12 @@ class WebSocketBridge:
                 elif msg_type == "audio.commit":
                     if self._session:
                         await self._session.commit_audio()
+                elif msg_type == "text":
+                    # Text-only mode: inject user message directly
+                    text = msg.get("text", "") or msg.get("message", "")
+                    if text and self._session:
+                        self._send({"type": "transcript", "role": "user", "text": text})
+                        await self._session.inject_user_message(text)
                 elif msg_type == "sync_state":
                     # Frontend requests full state sync from backend
                     self._send({"type": "status", "status": "syncing"})

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/tools/dispatch.py

@@ -97,7 +97,9 @@ def configure(
 
 
 def _default_agent_type() -> str:
-    """Return the first enabled agent type."""
+    """Return the default agent type from config, or first enabled agent."""
+    if _voice_config and _voice_config.default_agent:
+        return _voice_config.default_agent
     return _enabled_agents[0] if _enabled_agents else "claude"
 
 

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/tools/file_tree.py

@@ -188,14 +188,18 @@ def get_file_tree(worktree_path: str) -> dict:
             if status in summary:
                 summary[status] += 1
 
-        return {"root": root, "tree": tree, "summary": summary}
+        # Flat entries list for the TUI sidebar
+        entries = [{"path": p, "status": s} for p, s in sorted(all_paths.items())]
+
+        return {"root": root, "tree": tree, "summary": summary, "entries": entries}
 
     except Exception as e:
         logger.warning("Failed to build file tree: %s", e)
         return {
             "root": "unknown",
             "tree": {"name": "unknown", "path": "", "type": "folder", "children": [], "expanded": True},
-            "summary": {"modified": 0, "new": 0, "deleted": 0, "unchanged": 0}
+            "summary": {"modified": 0, "new": 0, "deleted": 0, "unchanged": 0},
+            "entries": [],
         }
 
 

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/tools/handlers.py

@@ -395,7 +395,8 @@ def _handle_show_diff(branch: str | None = None, file: str | None = None) -> str
         return f"No changes on '{instance.branch}' vs main."
     if matched_file:
         return f"Showing diff for '{matched_file}' on '{instance.branch}'."
-    return f"Showing diff for '{instance.branch}': {file_count} file{'s' if file_count != 1 else ''} changed."
+    file_list = ", ".join(f.path for f in files[:15])
+    return f"Showing diff for '{instance.branch}': {file_count} changed file(s): {file_list}"
 
 
 def _handle_show_output(branch: str | None = None, session_name: str | None = None) -> str:

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/ui/callbacks.py

@@ -47,7 +47,7 @@ class CallbackMixin:
             return
 
         inst = self._session.registry.get_by_id(instance_id)
-        if not inst or not inst.output_widget:
+        if not inst:
             return
 
         category = None
@@ -71,9 +71,27 @@ class CallbackMixin:
         styled = _format_output_line(category, display_line, inst.agent_type, show_badge=show_badge)
 
         self._state.add_instance_line(inst.display_key, styled)
-        self.app.call_from_thread(self._write_to_output, inst.output_widget, styled)
+        self.app.call_from_thread(self._ensure_output, instance_id, inst, styled)
         self._write_log_file(f"[{inst.display_key}] {display_line}")
 
+    def _ensure_output(self, instance_id: str, inst, styled: str) -> None:
+        """Write output to panel, recovering the widget reference if needed."""
+        recovered = False
+        if not inst.output_widget:
+            # Widget reference lost (e.g. after restore) — recover from DOM
+            try:
+                inst.output_widget = self.query_one(f"#output-{instance_id}", RichLog)
+                recovered = True
+            except Exception:
+                # Panel doesn't exist yet — create it
+                self._create_instance_panel(instance_id, inst.display_key)
+                recovered = True
+            if not inst.output_widget:
+                return
+        if recovered:
+            self._write_to_output(inst.output_widget, "[dim]─── session resumed ───[/dim]")
+        self._write_to_output(inst.output_widget, styled)
+
     def _write_to_output(self, widget: RichLog, text: str) -> None:
         try:
             widget.write(text)

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/ui/panels.py

@@ -4,13 +4,16 @@ Handles creating, updating, toggling fullscreen, and removing agent
 instance panels in the grid layout.
 """
 
+import logging
 import math
 
+logger = logging.getLogger(__name__)
+
 from textual.containers import Grid, Horizontal, Vertical
-from textual.widgets import Static, RichLog
+from textual.widgets import Static, RichLog, Tree
 
 from voice_vibecoder.code_providers.registry import get_badge
-from voice_vibecoder.instances import AgentInstance, InstanceStatus
+from voice_vibecoder.instances import AgentInstance, InstanceStatus, InstanceType
 from voice_vibecoder.ui.styles import _STATUS_ICONS
 
 
@@ -29,30 +32,68 @@ _FILE_STATUS_COLORS = {
 }
 
 
-def _format_file_tree(entries: list[dict]) -> str:
-    """Format file tree entries into Rich markup for the TUI sidebar."""
-    # Group by directory
-    tree: dict[str, list[tuple[str, str]]] = {}  # dir -> [(filename, status)]
-    for entry in entries:
-        path = entry.get("path", "")
-        status = entry.get("status", "unchanged")
-        if "/" in path:
-            folder, name = path.rsplit("/", 1)
+class FileTreeWidget(Tree):
+    """Interactive file tree sidebar with clickable expand/collapse folders."""
+
+    show_root = False
+
+    DEFAULT_CSS = """
+    FileTreeWidget {
+        scrollbar-size: 1 1;
+    }
+    """
+
+    def __init__(self, tree_data: dict, **kwargs):
+        super().__init__(tree_data.get("name", "files"), **kwargs)
+        self._user_toggled: dict[str, bool] = {}
+        self._rebuilding = False
+        self._build_from_data(tree_data)
+
+    def _build_from_data(self, tree_data: dict) -> None:
+        self._rebuilding = True
+        self.clear()
+        self.root.expand()
+        for child in tree_data.get("children", []):
+            self._insert_node(self.root, child)
+        self._rebuilding = False
+
+    def _insert_node(self, parent, node_data: dict) -> None:
+        path = node_data.get("path", "")
+        name = node_data.get("name", "")
+
+        if node_data["type"] == "folder":
+            if path in self._user_toggled:
+                should_expand = self._user_toggled[path]
+            else:
+                should_expand = node_data.get("expanded", False)
+
+            label = f"[bold dim]{name}/[/bold dim]"
+            folder_node = parent.add(label, data={"path": path, "type": "folder"}, expand=should_expand)
+
+            for child in node_data.get("children", []):
+                self._insert_node(folder_node, child)
         else:
-            folder, name = "", path
-        tree.setdefault(folder, []).append((name, status))
-
-    lines = []
-    for folder in sorted(tree.keys()):
-        if folder:
-            lines.append(f"[bold dim]{folder}/[/bold dim]")
-        for name, status in sorted(tree[folder], key=lambda x: x[0]):
-            icon = _FILE_STATUS_ICONS.get(status, "[dim]?[/dim]")
+            status = node_data.get("status", "unchanged")
+            icon = _FILE_STATUS_ICONS.get(status, "[dim]·[/dim]")
             color = _FILE_STATUS_COLORS.get(status, "dim")
-            indent = "  " if folder else ""
-            lines.append(f"{indent}{icon} [{color}]{name}[/{color}]")
+            label = f"{icon} [{color}]{name}[/{color}]"
+            parent.add_leaf(label, data={"path": path, "type": "file", "status": status})
+
+    def rebuild(self, tree_data: dict) -> None:
+        """Rebuild tree from new data, preserving user expand/collapse state."""
+        self._build_from_data(tree_data)
+
+    def on_tree_node_expanded(self, event) -> None:
+        if self._rebuilding:
+            return
+        if event.node.data and event.node.data.get("type") == "folder":
+            self._user_toggled[event.node.data["path"]] = True
 
-    return "\n".join(lines)
+    def on_tree_node_collapsed(self, event) -> None:
+        if self._rebuilding:
+            return
+        if event.node.data and event.node.data.get("type") == "folder":
+            self._user_toggled[event.node.data["path"]] = False
 
 
 def _format_header(inst: AgentInstance, status: InstanceStatus | None = None) -> str:
@@ -125,14 +166,31 @@ class PanelMixin:
                 classes="agent-output",
                 id=f"output-{inst.instance_id}",
             )
+            inst.header_widget = header
+            inst.output_widget = output
+
+            if inst.instance_type == InstanceType.CODE:
+                _empty_tree = {"name": "", "path": "", "type": "folder", "children": [], "expanded": True}
+                tree_widget = FileTreeWidget(
+                    _empty_tree,
+                    classes="file-tree-sidebar",
+                    id=f"file-tree-{inst.instance_id}",
+                )
+                body = Horizontal(
+                    tree_widget,
+                    output,
+                    classes="file-tree-container",
+                    id=f"file-tree-wrap-{inst.instance_id}",
+                )
+            else:
+                body = output
+
             panel = Vertical(
                 header,
-                output,
+                body,
                 classes="agent-panel",
                 id=f"panel-{inst.instance_id}",
             )
-            inst.header_widget = header
-            inst.output_widget = output
             panels.append(panel)
 
         try:
@@ -159,17 +217,35 @@ class PanelMixin:
             classes="agent-output",
             id=f"output-{instance_id}",
         )
+
+        if inst:
+            inst.header_widget = header
+            inst.output_widget = output
+
+        is_code = inst and inst.instance_type == InstanceType.CODE
+        if is_code:
+            _empty_tree = {"name": "", "path": "", "type": "folder", "children": [], "expanded": True}
+            tree_widget = FileTreeWidget(
+                _empty_tree,
+                classes="file-tree-sidebar",
+                id=f"file-tree-{instance_id}",
+            )
+            body = Horizontal(
+                tree_widget,
+                output,
+                classes="file-tree-container",
+                id=f"file-tree-wrap-{instance_id}",
+            )
+        else:
+            body = output
+
         panel = Vertical(
             header,
-            output,
+            body,
             classes="agent-panel",
             id=f"panel-{instance_id}",
         )
 
-        if inst:
-            inst.header_widget = header
-            inst.output_widget = output
-
         try:
             grid = self.query_one("#agent-grid", Grid)
             grid.styles.display = "block"
@@ -284,61 +360,17 @@ class PanelMixin:
             grid.styles.grid_size_rows = 1
 
     def _update_file_tree(self, instance_id: str, data: dict) -> None:
-        """Update (or create) the file tree sidebar in a panel."""
-        if not self._session:
-            return
-        inst = self._session.registry.get_by_id(instance_id)
-        if not inst:
-            return
-
-        entries = data.get("entries", [])
-        if not entries:
+        """Update the file tree sidebar for a code instance panel."""
+        tree_data = data.get("tree")
+        if not tree_data or not tree_data.get("children"):
             return
 
-        formatted = _format_file_tree(entries)
-        sidebar_id = f"file-tree-{instance_id}"
-
-        # Try to update existing sidebar
         try:
-            sidebar = self.query_one(f"#{sidebar_id}", Static)
-            sidebar.update(formatted)
-            return
+            tree_widget = self.query_one(f"#file-tree-{instance_id}", FileTreeWidget)
+            tree_widget.rebuild(tree_data)
         except Exception:
             pass
 
-        # First time — wrap output in a Horizontal with tree sidebar
-        if not inst.output_widget:
-            return
-
-        try:
-            panel = self.query_one(f"#panel-{instance_id}")
-        except Exception:
-            return
-
-        sidebar = Static(
-            formatted,
-            classes="file-tree-sidebar",
-            id=sidebar_id,
-        )
-
-        # Remove output from panel, wrap in Horizontal, re-mount
-        output = inst.output_widget
-        try:
-            output.remove()
-            container = Horizontal(
-                sidebar,
-                output,
-                classes="file-tree-container",
-                id=f"file-tree-wrap-{instance_id}",
-            )
-            panel.mount(container)
-        except Exception:
-            # If something fails, try to restore output directly
-            try:
-                panel.mount(output)
-            except Exception:
-                pass
-
     def _remove_instance_panel(self, instance_id: str) -> None:
         """Remove a panel from the grid."""
         if self._session:

{voice_vibecoder-2.6.0 → voice_vibecoder-2.8.0}/src/voice_vibecoder/ui/screen.py

@@ -361,6 +361,13 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
         asyncio.set_event_loop(self._loop)
         self._loop.run_until_complete(self._session_lifecycle())
 
+    def _call_ui(self, callback, *args) -> None:
+        """Safely call a UI callback from a background thread."""
+        try:
+            self.app.call_from_thread(callback, *args)
+        except Exception:
+            pass  # App not active (shutting down or not yet ready)
+
     async def _session_lifecycle(self) -> None:
         try:
             await self._session.connect()
@@ -371,12 +378,10 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
             self._audio = AudioManager(on_audio_chunk=self._send_audio_chunk)
             self._audio.start()
 
-            self.app.call_from_thread(self._log, "[green]Connected — start speaking[/green]")
+            self._call_ui(self._log, "[green]Connected — start speaking[/green]")
             if self._log_path:
-                self.app.call_from_thread(
-                    self._log, f"[dim]Log: {self._log_path}[/dim]"
-                )
-            self.app.call_from_thread(self._update_status_bar, "ready")
+                self._call_ui(self._log, f"[dim]Log: {self._log_path}[/dim]")
+            self._call_ui(self._update_status_bar, "ready")
 
             # Run custom startup callback if configured
             if self._config.on_startup:
@@ -384,10 +389,10 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
 
             await self._session.handle_messages()
         except Exception as e:
-            self.app.call_from_thread(
+            self._call_ui(
                 self._log, f"[bold red]Connection error: {e}[/bold red]"
             )
-            self.app.call_from_thread(
+            self._call_ui(
                 self._set_status,
                 f"[red]Error[/red]  |  [dim]s[/dim] settings  |  [dim]q[/dim] quit",
             )