voice-vibecoder 2.8.1__tar.gz → 2.9.1__tar.gz

{voice_vibecoder-2.8.1 → voice_vibecoder-2.9.1}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v2.9.1 (2026-02-21)
+
+### Bug Fixes
+
+- Correct connect params for gateway protocol
+  ([`89589e2`](https://github.com/snokam/voice-vibecoder/commit/89589e2d732d21f2f3225b005eff7c33b8f18d77))
+
+
+## v2.9.0 (2026-02-21)
+
+### Features
+
+- Add WebSocket streaming support to OpenClaw provider
+  ([`97e107a`](https://github.com/snokam/voice-vibecoder/commit/97e107a8371a02783b51258bc75c0d64807b3964))
+
+
 ## v2.8.1 (2026-02-21)
 
 ### Bug Fixes

{voice_vibecoder-2.8.1 → voice_vibecoder-2.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.8.1
+Version: 2.9.1
 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
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Requires-Python: >=3.10
 Requires-Dist: claude-agent-sdk>=0.1.30
+Requires-Dist: cryptography>=42.0
 Requires-Dist: numpy>=1.24
 Requires-Dist: platformdirs>=4.0
 Requires-Dist: rich>=13.0

{voice_vibecoder-2.8.1 → voice_vibecoder-2.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.8.1"
+version = "2.9.1"
 description = "Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -24,6 +24,7 @@ classifiers = [
     "Topic :: Software Development",
 ]
 dependencies = [
+    "cryptography>=42.0",
     "textual>=0.50",
     "rich>=13.0",
     "websockets>=12",

{voice_vibecoder-2.8.1 → voice_vibecoder-2.9.1}/src/voice_vibecoder/__init__.py

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

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

@@ -0,0 +1,315 @@
+"""OpenClaw Agent code provider.
+
+Routes coding tasks to OpenClaw Gateway via WebSocket for streaming output.
+Falls back to CLI if WebSocket connection fails.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import logging
+import os
+import uuid
+from typing import Any, Awaitable, Callable
+
+from voice_vibecoder.code_providers import AgentOutput, AgentResult
+
+logger = logging.getLogger(__name__)
+
+try:
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+    HAS_CRYPTO = True
+except ImportError:
+    HAS_CRYPTO = False
+    logger.warning("cryptography not installed, WebSocket auth will not work")
+
+
+def _load_device_keys(state_dir: str) -> tuple[str, Ed25519PrivateKey | None, str | None]:
+    """Load device identity from OpenClaw state directory."""
+    device_path = os.path.join(state_dir, "identity", "device.json")
+    auth_path = os.path.join(state_dir, "identity", "device-auth.json")
+    
+    device_id = None
+    private_key = None
+    token = None
+    
+    try:
+        with open(device_path) as f:
+            device = json.load(f)
+            device_id = device["deviceId"]
+            if HAS_CRYPTO:
+                pem = device["privateKeyPem"].encode()
+                private_key = serialization.load_pem_private_key(pem, password=None)
+    except Exception as e:
+        logger.debug("Could not load device.json: %s", e)
+    
+    try:
+        with open(auth_path) as f:
+            auth = json.load(f)
+            if "tokens" in auth and "operator" in auth["tokens"]:
+                token = auth["tokens"]["operator"]["token"]
+    except Exception as e:
+        logger.debug("Could not load device-auth.json: %s", e)
+    
+    return device_id, private_key, token
+
+
+def _sign_challenge(private_key: Ed25519PrivateKey, nonce: str, ts: int) -> tuple[str, int]:
+    """Sign the gateway challenge."""
+    message = f"{nonce}:{ts}".encode()
+    signature = private_key.sign(message)
+    return base64.urlsafe_b64encode(signature).decode().rstrip("="), ts
+
+
+class OpenClawRunner:
+    """AgentRunner implementation using OpenClaw Gateway WebSocket."""
+
+    def __init__(
+        self,
+        session_id: str | None = None,
+        agent_id: str | None = None,
+        env: dict[str, str] | None = None,
+        gateway_url: str | None = None,
+        state_dir: 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 or {}
+        self._gateway_url = gateway_url or os.environ.get("OPENCLAW_GATEWAY_URL", "ws://127.0.0.1:18789")
+        self._state_dir = state_dir or os.environ.get("OPENCLAW_STATE_DIR", "/data/olaf")
+        self._task: asyncio.Task | None = None
+        self._ws = None
+        
+        self._device_id, self._private_key, self._device_token = _load_device_keys(self._state_dir)
+
+    async def _connect_websocket(self) -> Any:
+        """Connect to OpenClaw Gateway via WebSocket."""
+        try:
+            import websockets
+        except ImportError:
+            logger.warning("websockets not installed")
+            return None
+        
+        if not self._device_id or not self._private_key:
+            logger.warning("No device identity found, cannot connect via WebSocket")
+            return None
+        
+        try:
+            ws = await asyncio.wait_for(
+                websockets.connect(self._gateway_url),
+                timeout=5.0
+            )
+            
+            # Wait for challenge
+            challenge_msg = await asyncio.wait_for(ws.recv(), timeout=5.0)
+            challenge = json.loads(challenge_msg)
+            
+            if challenge.get("event") != "connect.challenge":
+                logger.warning("Unexpected challenge: %s", challenge)
+                await ws.close()
+                return None
+            
+            nonce = challenge["payload"]["nonce"]
+            ts = challenge["payload"]["ts"]
+            
+            # Sign challenge
+            signature, signed_at = _sign_challenge(self._private_key, nonce, ts)
+            
+            # Get public key in base64
+            public_key_bytes = self._private_key.public_key().public_bytes(
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PublicFormat.Raw
+            )
+            public_key_b64 = base64.urlsafe_b64encode(public_key_bytes).decode().rstrip("=")
+            
+            # Send connect request - match CLI format exactly
+            connect_req = {
+                "type": "req",
+                "id": str(uuid.uuid4()),
+                "method": "connect",
+                "params": {
+                    "minProtocol": 3,
+                    "maxProtocol": 3,
+                    "client": {
+                        "id": "cli",  # Must be "cli" for operator role
+                        "version": "1.0.0",
+                        "platform": "linux",
+                        "mode": "operator"  # Must be "operator"
+                    },
+                    "role": "operator",
+                    "scopes": ["operator.read", "operator.write"],
+                    "caps": [],
+                    "commands": [],
+                    "permissions": {},
+                    "auth": {"token": self._device_token} if self._device_token else {},
+                    "locale": "en-US",
+                    "userAgent": "voice-server/1.0.0",
+                    "device": {
+                        "id": self._device_id,
+                        "publicKey": public_key_b64,
+                        "signature": signature,
+                        "signedAt": signed_at,
+                        "nonce": nonce
+                    }
+                }
+            }
+            
+            await ws.send(json.dumps(connect_req))
+            
+            # Wait for response
+            response_msg = await asyncio.wait_for(ws.recv(), timeout=5.0)
+            response = json.loads(response_msg)
+            
+            if not response.get("ok"):
+                error = response.get("error", {}).get("message", "Unknown error")
+                logger.warning("Gateway connect failed: %s", error)
+                await ws.close()
+                return None
+            
+            logger.info("Connected to OpenClaw Gateway via WebSocket")
+            return ws
+            
+        except Exception as e:
+            logger.warning("WebSocket connection failed: %s", e)
+            return None
+
+    async def _run_via_websocket(
+        self,
+        ws,
+        message: str,
+        cwd: str,
+        session_id: str,
+        on_output: Callable[[AgentOutput], None] | None = None,
+    ) -> AgentResult | None:
+        """Run agent via WebSocket for streaming output."""
+        try:
+            req_id = str(uuid.uuid4())
+            agent_req = {
+                "type": "req",
+                "id": req_id,
+                "method": "agent.run",
+                "params": {
+                    "sessionId": session_id,
+                    "message": message,
+                    "cwd": cwd,
+                    "local": True
+                }
+            }
+            
+            await ws.send(json.dumps(agent_req))
+            
+            result_text = ""
+            
+            while True:
+                msg = await asyncio.wait_for(ws.recv(), timeout=300.0)
+                data = json.loads(msg)
+                
+                if data.get("type") == "event":
+                    event = data.get("event", "")
+                    payload = data.get("payload", {})
+                    
+                    if event == "agent.output":
+                        text = payload.get("text", "")
+                        if text and on_output:
+                            on_output(AgentOutput(category="text", content=text))
+                    elif event == "agent.tool":
+                        tool = payload.get("tool", "")
+                        if on_output:
+                            on_output(AgentOutput(category="tool_call", content=f"[{tool}]"))
+                
+                elif data.get("type") == "res" and data.get("id") == req_id:
+                    if data.get("ok"):
+                        result_text = data.get("payload", {}).get("result", "")
+                    else:
+                        error = data.get("error", {}).get("message", "Unknown error")
+                        raise RuntimeError(f"Agent error: {error}")
+                    break
+            
+            return AgentResult(text=result_text.strip(), session_id=session_id)
+            
+        except Exception as e:
+            logger.warning("WebSocket agent run failed: %s", e)
+            return None
+
+    async def _run_via_cli(
+        self,
+        message: str,
+        cwd: str,
+        session_id: str,
+        on_output: Callable[[AgentOutput], None] | None = None,
+    ) -> AgentResult:
+        """Fallback: run agent via CLI."""
+        if on_output:
+            on_output(AgentOutput(category="text", content="🦞 Running via CLI..."))
+        
+        full_message = f"[Working directory: {cwd}]\n\n{message}"
+        
+        cmd = [
+            "openclaw", "agent",
+            "--session-id", session_id,
+            "--message", full_message,
+            "--local",
+        ]
+        
+        env = os.environ.copy()
+        env["PATH"] = f"/home/olaf/.npm-global/bin:/home/olaf/.local/bin:{env.get('PATH', '')}"
+        env["OPENCLAW_STATE_DIR"] = self._state_dir
+        if self._env:
+            env.update(self._env)
+        
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+            cwd=cwd,
+        )
+        
+        stdout, stderr = await process.communicate()
+        result_text = stdout.decode("utf-8", errors="replace").strip()
+        
+        if process.returncode != 0 and not result_text:
+            raise RuntimeError(f"CLI failed: {stderr.decode()}")
+        
+        return AgentResult(text=result_text, session_id=session_id)
+
+    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."""
+        self._task = asyncio.current_task()
+        effective_session = session_id or self._session_id
+        
+        if on_output:
+            on_output(AgentOutput(category="text", content="🦞 Connecting to OpenClaw..."))
+        
+        ws = await self._connect_websocket()
+        if ws:
+            try:
+                result = await self._run_via_websocket(ws, message, cwd, effective_session, on_output)
+                if result:
+                    return result
+            finally:
+                await ws.close()
+        
+        if on_output:
+            on_output(AgentOutput(category="text", content="WebSocket unavailable, using CLI..."))
+        
+        return await self._run_via_cli(message, cwd, effective_session, on_output)
+
+    def cancel(self) -> bool:
+        """Cancel the running task."""
+        task = self._task
+        if task and not task.done():
+            task.cancel()
+            return True
+        return False

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

@@ -1,183 +0,0 @@
-"""OpenClaw Agent code provider.
-
-Routes coding tasks to OpenClaw via CLI. Uses `openclaw agent --local`
-for embedded agent execution with full tool access.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import os
-import re
-import uuid
-from typing import Any, Awaitable, Callable
-
-from voice_vibecoder.code_providers import AgentOutput, AgentResult
-
-logger = logging.getLogger(__name__)
-
-
-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 CLI."""
-
-    def __init__(
-        self,
-        session_id: str | None = None,
-        agent_id: str | None = None,
-        env: dict[str, 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._task: asyncio.Task | None = None
-        self._process: asyncio.subprocess.Process | None = 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 CLI."""
-        self._task = asyncio.current_task()
-        effective_session = session_id or self._session_id
-        
-        full_message = f"[Working directory: {cwd}]\n\n{message}"
-        
-        if on_output:
-            on_output(AgentOutput(category="text", content="🦞 Running via OpenClaw..."))
-
-        cmd = [
-            "openclaw", "agent",
-            "--session-id", effective_session,
-            "--message", full_message,
-            "--local",
-        ]
-        
-        if self._agent_id:
-            cmd.extend(["--agent", self._agent_id])
-        
-        env = os.environ.copy()
-        env["PATH"] = f"/home/olaf/.npm-global/bin:/home/olaf/.local/bin:{env.get('PATH', '')}"
-        if self._env:
-            env.update(self._env)
-        
-        try:
-            self._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 self._process and self._process.stdout
-                
-                buffer = ""
-                while True:
-                    chunk = await self._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
-                        
-                        result_text += line + "\n"
-                        
-                        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:
-                        result_text += buffer
-            
-            async def read_stderr():
-                assert self._process and self._process.stderr
-                async for line in self._process.stderr:
-                    text = line.decode("utf-8", errors="replace").strip()
-                    if text:
-                        logger.debug("stderr: %s", text)
-            
-            await asyncio.gather(read_stdout(), read_stderr())
-            await self._process.wait()
-            
-            if self._process.returncode != 0 and not result_text:
-                raise RuntimeError(f"OpenClaw CLI failed with exit code {self._process.returncode}")
-            
-            return AgentResult(
-                text=result_text.strip(),
-                session_id=effective_session,
-            )
-            
-        except asyncio.CancelledError:
-            if self._process:
-                self._process.terminate()
-                try:
-                    await asyncio.wait_for(self._process.wait(), timeout=5.0)
-                except asyncio.TimeoutError:
-                    self._process.kill()
-            raise
-        finally:
-            self._process = None
-
-    def cancel(self) -> bool:
-        """Cancel the running task."""
-        if self._process:
-            self._process.terminate()
-            return True
-        
-        task = self._task
-        if task and not task.done():
-            task.cancel()
-            return True
-        
-        return False