gobby 0.2.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

gobby/servers/websocket.py

@@ -14,7 +14,7 @@ import os
 from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
 from datetime import UTC, datetime
-from typing import Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol
 from uuid import uuid4
 
 from websockets.asyncio.server import serve
@@ -25,6 +25,9 @@ from websockets.http11 import Response
 from gobby.agents.registry import get_running_agent_registry
 from gobby.mcp_proxy.manager import MCPClientManager
 
+if TYPE_CHECKING:
+    from gobby.llm import LLMService
+
 logger = logging.getLogger(__name__)
 
 
@@ -79,6 +82,7 @@ class WebSocketServer:
         mcp_manager: MCPClientManager,
         auth_callback: Callable[[str], Coroutine[Any, Any, str | None]] | None = None,
         stop_registry: Any = None,
+        llm_service: "LLMService | None" = None,
     ):
         """
         Initialize WebSocket server.
@@ -89,15 +93,20 @@ class WebSocketServer:
             auth_callback: Optional async function that validates token and returns user_id.
                           If None, all connections are accepted (local-first mode).
             stop_registry: Optional StopRegistry for handling stop requests from clients.
+            llm_service: Optional LLM service for chat message handling.
         """
         self.config = config
         self.mcp_manager = mcp_manager
         self.auth_callback = auth_callback
         self.stop_registry = stop_registry
+        self.llm_service = llm_service
 
         # Connected clients: {websocket: client_metadata}
         self.clients: dict[Any, dict[str, Any]] = {}
 
+        # Chat conversation history per client (simple in-memory for now)
+        self._chat_history: dict[str, list[dict[str, str]]] = {}
+
         # Server instance (set when started)
         self._server: Any = None
         self._serve_task: asyncio.Task[None] | None = None
@@ -225,6 +234,7 @@ class WebSocketServer:
         finally:
             # Always cleanup client state
             self.clients.pop(websocket, None)
+            self._chat_history.pop(client_id, None)
             logger.debug(f"Client {client_id} cleaned up. Remaining clients: {len(self.clients)}")
 
     async def _handle_message(self, websocket: Any, message: str) -> None:
@@ -261,6 +271,9 @@ class WebSocketServer:
         elif msg_type == "terminal_input":
             await self._handle_terminal_input(websocket, data)
 
+        elif msg_type == "chat_message":
+            await self._handle_chat_message(websocket, data)
+
         else:
             logger.warning(f"Unknown message type: {msg_type}")
             await self._send_error(websocket, f"Unknown message type: {msg_type}")
@@ -557,6 +570,215 @@ class WebSocketServer:
         except OSError as e:
             logger.warning(f"Failed to write to agent {run_id} PTY: {e}")
 
+    async def _handle_chat_message(self, websocket: Any, data: dict[str, Any]) -> None:
+        """
+        Handle chat_message and stream LLM response with MCP tool support.
+
+        Message format:
+        {
+            "type": "chat_message",
+            "content": "user message",
+            "message_id": "client-generated-id",
+            "use_tools": true  // optional, enables MCP tools
+        }
+
+        Response format (streamed):
+        {
+            "type": "chat_stream",
+            "message_id": "assistant-uuid",
+            "content": "chunk of text",
+            "done": false
+        }
+
+        Tool status format:
+        {
+            "type": "tool_status",
+            "message_id": "assistant-uuid",
+            "tool_call_id": "unique-id",
+            "status": "calling" | "completed" | "error",
+            "tool_name": "mcp__gobby-tasks__create_task",
+            "server_name": "gobby-tasks",
+            "arguments": {...},
+            "result": {...},  // when completed
+            "error": "..."    // when error
+        }
+
+        Args:
+            websocket: Client WebSocket connection
+            data: Parsed chat message
+        """
+        content = data.get("content")
+        user_message_id = data.get("message_id")
+        use_tools = data.get("use_tools", True)  # Default to using tools
+        model = data.get("model")  # Optional model override
+
+        if not content or not isinstance(content, str):
+            await self._send_error(websocket, "Missing or invalid 'content' field")
+            return
+
+        if not self.llm_service:
+            await websocket.send(
+                json.dumps(
+                    {
+                        "type": "chat_error",
+                        "message_id": user_message_id,
+                        "error": "LLM service not configured",
+                    }
+                )
+            )
+            return
+
+        # Get or create conversation history for this client
+        client_info = self.clients.get(websocket)
+        if not client_info:
+            logger.warning("Chat message from unregistered client")
+            return
+        client_id = client_info["id"]
+
+        if client_id not in self._chat_history:
+            self._chat_history[client_id] = []
+
+        history = self._chat_history[client_id]
+
+        # Add user message to history
+        history.append({"role": "user", "content": content})
+
+        # Generate assistant message ID
+        assistant_message_id = f"assistant-{uuid4().hex[:12]}"
+
+        try:
+            # Build messages for LLM
+            system_prompt = (
+                "You are Gobby, a helpful AI assistant with access to tools. "
+                "You help users with coding, development tasks, and general questions. "
+                "You can use tools to manage tasks, store memories, and access session info. "
+                "Be concise and helpful."
+            )
+
+            messages = [{"role": "system", "content": system_prompt}] + history[
+                -20:
+            ]  # Last 20 messages
+
+            full_response = ""
+            tool_calls_count = 0
+
+            if use_tools:
+                # Stream with MCP tools
+                from gobby.llm.claude import (
+                    DoneEvent,
+                    TextChunk,
+                    ToolCallEvent,
+                    ToolResultEvent,
+                )
+
+                # Default allowed tools - gobby MCP server from .mcp.json
+                # The server name is "gobby" which exposes all gobby tools
+                allowed_tools = [
+                    "mcp__gobby__*",
+                ]
+
+                async for event in self.llm_service.stream_chat_with_tools(
+                    messages, allowed_tools, model=model
+                ):
+                    if isinstance(event, TextChunk):
+                        full_response += event.content
+                        await websocket.send(
+                            json.dumps(
+                                {
+                                    "type": "chat_stream",
+                                    "message_id": assistant_message_id,
+                                    "content": event.content,
+                                    "done": False,
+                                }
+                            )
+                        )
+                    elif isinstance(event, ToolCallEvent):
+                        await websocket.send(
+                            json.dumps(
+                                {
+                                    "type": "tool_status",
+                                    "message_id": assistant_message_id,
+                                    "tool_call_id": event.tool_call_id,
+                                    "status": "calling",
+                                    "tool_name": event.tool_name,
+                                    "server_name": event.server_name,
+                                    "arguments": event.arguments,
+                                }
+                            )
+                        )
+                    elif isinstance(event, ToolResultEvent):
+                        await websocket.send(
+                            json.dumps(
+                                {
+                                    "type": "tool_status",
+                                    "message_id": assistant_message_id,
+                                    "tool_call_id": event.tool_call_id,
+                                    "status": "completed" if event.success else "error",
+                                    "result": event.result,
+                                    "error": event.error,
+                                }
+                            )
+                        )
+                    elif isinstance(event, DoneEvent):
+                        tool_calls_count = event.tool_calls_count
+                        # Send final done message
+                        await websocket.send(
+                            json.dumps(
+                                {
+                                    "type": "chat_stream",
+                                    "message_id": assistant_message_id,
+                                    "content": "",
+                                    "done": True,
+                                    "tool_calls_count": tool_calls_count,
+                                }
+                            )
+                        )
+            else:
+                # Stream without tools (original behavior)
+                async for chunk in self.llm_service.stream_chat(messages):
+                    full_response += chunk
+                    await websocket.send(
+                        json.dumps(
+                            {
+                                "type": "chat_stream",
+                                "message_id": assistant_message_id,
+                                "content": chunk,
+                                "done": False,
+                            }
+                        )
+                    )
+
+                # Send final done message
+                await websocket.send(
+                    json.dumps(
+                        {
+                            "type": "chat_stream",
+                            "message_id": assistant_message_id,
+                            "content": "",
+                            "done": True,
+                        }
+                    )
+                )
+
+            # Add assistant response to history
+            history.append({"role": "assistant", "content": full_response})
+
+            # Trim history if too long
+            if len(history) > 100:
+                self._chat_history[client_id] = history[-50:]
+
+        except Exception:
+            logger.exception(f"Chat error for client {client_id}")
+            await websocket.send(
+                json.dumps(
+                    {
+                        "type": "chat_error",
+                        "message_id": assistant_message_id,
+                        "error": "An internal error occurred",
+                    }
+                )
+            )
+
     async def broadcast(self, message: dict[str, Any]) -> None:
         """
         Broadcast message to all connected clients.
@@ -724,6 +946,97 @@ class WebSocketServer:
 
         await self.broadcast(message)
 
+    async def broadcast_pipeline_event(
+        self,
+        event: str,
+        execution_id: str,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Broadcast pipeline execution event to subscribed clients.
+
+        Used for real-time pipeline execution updates:
+        - pipeline_started: Execution began
+        - pipeline_completed: Execution finished successfully
+        - pipeline_failed: Execution failed with error
+        - step_started: A step began executing
+        - step_completed: A step finished successfully
+        - step_failed: A step failed with error
+        - step_output: Streaming output from a step
+        - approval_required: Step is waiting for approval
+
+        Args:
+            event: Event type
+            execution_id: Pipeline execution ID
+            **kwargs: Additional event data (step_id, output, error, etc.)
+        """
+        if not self.clients:
+            return  # No clients connected
+
+        message = {
+            "type": "pipeline_event",
+            "event": event,
+            "execution_id": execution_id,
+            "timestamp": datetime.now(UTC).isoformat(),
+            **kwargs,
+        }
+
+        message_str = json.dumps(message)
+
+        for websocket in list(self.clients.keys()):
+            try:
+                # Only send to clients subscribed to pipeline_event or *
+                subs = getattr(websocket, "subscriptions", None)
+                if subs is not None:
+                    if "pipeline_event" not in subs and "*" not in subs:
+                        continue
+
+                await websocket.send(message_str)
+            except ConnectionClosed:
+                pass
+            except Exception as e:
+                logger.warning(f"Pipeline event broadcast failed: {e}")
+
+    async def broadcast_terminal_output(
+        self,
+        run_id: str,
+        data: str,
+    ) -> None:
+        """
+        Broadcast terminal output to subscribed clients.
+
+        Used for streaming PTY output from embedded agents to web terminals.
+
+        Args:
+            run_id: Agent run ID
+            data: Raw terminal output data
+        """
+        if not self.clients:
+            return  # No clients connected
+
+        message = {
+            "type": "terminal_output",
+            "run_id": run_id,
+            "data": data,
+            "timestamp": datetime.now(UTC).isoformat(),
+        }
+
+        message_str = json.dumps(message)
+
+        for websocket in list(self.clients.keys()):
+            try:
+                # Only send to clients subscribed to terminal_output or *
+                subs = getattr(websocket, "subscriptions", None)
+                if subs is not None:
+                    if "terminal_output" not in subs and "*" not in subs:
+                        continue
+
+                await websocket.send(message_str)
+            except ConnectionClosed:
+                pass
+            except Exception as e:
+                logger.warning(f"Terminal broadcast failed: {e}")
+
     async def start(self) -> None:
         """
         Start WebSocket server.

gobby/sessions/analyzer.py

@@ -226,10 +226,46 @@ class TranscriptAnalyzer:
         tool_name = block.get("name", "unknown")
         tool_input = block.get("input", {})
 
-        # MCP tool calls - show server.tool
+        # MCP tool calls - show server.tool with details for gobby-tasks
         if tool_name in ("mcp__gobby__call_tool", "mcp_call_tool"):
             server = tool_input.get("server_name", "unknown")
             tool = tool_input.get("tool_name", "unknown")
+            args = tool_input.get("arguments", {})
+
+            # Enhanced formatting for gobby-tasks operations
+            if server == "gobby-tasks":
+                if tool == "create_task":
+                    title = args.get("title", "Untitled")
+                    parent = args.get("parent_task_id", "")
+                    if parent:
+                        return f"Created task: {title} (parent: {parent})"
+                    return f"Created task: {title}"
+                elif tool == "update_task":
+                    task_id = args.get("task_id", "?")
+                    status = args.get("status")
+                    if status:
+                        return f"Updated task {task_id}: status → {status}"
+                    return f"Updated task {task_id}"
+                elif tool == "close_task":
+                    task_id = args.get("task_id", "?")
+                    reason = args.get("reason", "")
+                    if reason:
+                        # Truncate long reasons
+                        if len(reason) > 40:
+                            reason = reason[:37] + "..."
+                        return f"Closed task {task_id}: {reason}"
+                    return f"Closed task {task_id}"
+                elif tool == "claim_task":
+                    task_id = args.get("task_id", "?")
+                    return f"Claimed task {task_id}"
+                elif tool == "get_task":
+                    task_id = args.get("task_id", "?")
+                    return f"Fetched task {task_id}"
+
+            # Generic MCP call formatting - extract meaningful context from args
+            context = self._extract_mcp_context(args)
+            if context:
+                return f"{server}.{tool}: {context}"
             return f"Called {server}.{tool}"
 
         # Bash - show the command (truncated)
@@ -287,6 +323,56 @@ class TranscriptAnalyzer:
         # Default - just show the tool name
         return f"Called {tool_name}"
 
+    def _extract_mcp_context(self, args: dict[str, Any]) -> str:
+        """
+        Extract meaningful context from MCP tool arguments.
+
+        Looks for common argument patterns and returns the most relevant value
+        to describe what the tool call is doing.
+
+        Args:
+            args: Tool arguments dict
+
+        Returns:
+            Extracted context string (truncated to 100 chars) or empty string
+        """
+        if not args:
+            return ""
+
+        # Priority order for extracting context
+        # 1. Search/query related - what are we looking for?
+        for key in ("query", "search", "pattern", "topic"):
+            if key in args and args[key]:
+                return self._truncate(str(args[key]), 100)
+
+        # 2. Identity/naming - what entity are we working with?
+        for key in ("title", "name", "task_id", "id", "ref"):
+            if key in args and args[key]:
+                return self._truncate(str(args[key]), 100)
+
+        # 3. Resource paths - what file/resource?
+        for key in ("path", "file_path", "uri", "url", "file"):
+            if key in args and args[key]:
+                return self._truncate(str(args[key]), 100)
+
+        # 4. Descriptive content - why/what?
+        for key in ("description", "reason", "message", "content"):
+            if key in args and args[key]:
+                return self._truncate(str(args[key]), 100)
+
+        # 5. Fallback: first non-empty string value
+        for key, value in args.items():
+            if isinstance(value, str) and value and key not in ("session_id", "server_name"):
+                return self._truncate(value, 100)
+
+        return ""
+
+    def _truncate(self, text: str, max_len: int) -> str:
+        """Truncate text to max_len, adding ellipsis if needed."""
+        if len(text) <= max_len:
+            return text
+        return text[: max_len - 3] + "..."
+
     def _extract_todowrite(self, turns: list[dict[str, Any]]) -> list[dict[str, Any]]:
         """
         Extract the most recent TodoWrite state from transcript.

gobby/sessions/manager.py

@@ -91,7 +91,7 @@ class SessionManager:
         Args:
             external_id: External session identifier (e.g., Claude Code session ID)
             machine_id: Machine identifier
-            source: CLI source identifier (e.g., "claude", "gemini", "codex") - REQUIRED
+            source: CLI source identifier (e.g., "claude", "gemini", "codex", "cursor", "windsurf", "copilot") - REQUIRED
             project_id: Project ID (required - sessions must belong to a project)
             parent_session_id: Optional parent session ID for handoff
             jsonl_path: Optional path to session transcript JSONL file
@@ -179,7 +179,7 @@ class SessionManager:
 
         Args:
             machine_id: Machine identifier
-            source: CLI source identifier (e.g., "claude", "gemini", "codex") - REQUIRED
+            source: CLI source identifier (e.g., "claude", "gemini", "codex", "cursor", "windsurf", "copilot") - REQUIRED
             project_id: Project ID (required for matching)
             max_attempts: Maximum polling attempts (1 per second)
 
@@ -274,7 +274,7 @@ class SessionManager:
 
         Args:
             external_id: External session identifier
-            source: CLI source identifier (e.g., "claude", "gemini", "codex")
+            source: CLI source identifier (e.g., "claude", "gemini", "codex", "cursor", "windsurf", "copilot")
             machine_id: Machine identifier
             project_id: Project identifier
 
@@ -343,7 +343,7 @@ class SessionManager:
 
         Args:
             external_id: External session identifier
-            source: CLI source identifier (e.g., "claude", "gemini", "codex")
+            source: CLI source identifier (e.g., "claude", "gemini", "codex", "cursor", "windsurf", "copilot")
 
         Returns:
             session_id or None if not cached
@@ -357,7 +357,7 @@ class SessionManager:
 
         Args:
             external_id: External session identifier
-            source: CLI source identifier (e.g., "claude", "gemini", "codex")
+            source: CLI source identifier (e.g., "claude", "gemini", "codex", "cursor", "windsurf", "copilot")
             session_id: Database session ID
         """
         with self._session_mapping_lock:

gobby/sessions/transcripts/__init__.py

@@ -24,6 +24,9 @@ PARSER_REGISTRY: dict[str, type[TranscriptParser]] = {
     "gemini": GeminiTranscriptParser,
     "antigravity": GeminiTranscriptParser,
     "codex": CodexTranscriptParser,
+    "cursor": ClaudeTranscriptParser,
+    "windsurf": ClaudeTranscriptParser,
+    "copilot": ClaudeTranscriptParser,
 }
 
 

gobby/sessions/transcripts/claude.py

@@ -289,6 +289,11 @@ class ClaudeTranscriptParser:
             self.logger.warning(f"Invalid JSON at line {index}")
             return None
 
+        # Ensure data is a dict (JSON could be a string, number, etc.)
+        if not isinstance(data, dict):
+            self.logger.debug(f"Skipping non-object JSON at line {index}")
+            return None
+
         # Extract basic fields
         msg_type = data.get("type", "unknown")
         timestamp_str = data.get("timestamp") or datetime.now(UTC).isoformat()

gobby/sessions/transcripts/codex.py

@@ -60,6 +60,11 @@ class CodexTranscriptParser:
             self.logger.warning(f"Invalid JSON at line {index}")
             return None
 
+        # Ensure data is a dict (JSON could be a string, number, etc.)
+        if not isinstance(data, dict):
+            self.logger.debug(f"Skipping non-object JSON at line {index}")
+            return None
+
         timestamp = datetime.now(UTC)
         if "timestamp" in data:
             try:

gobby/sessions/transcripts/gemini.py

@@ -116,6 +116,11 @@ class GeminiTranscriptParser:
             self.logger.warning(f"Invalid JSON at line {index}")
             return None
 
+        # Ensure data is a dict (JSON could be a string, number, etc.)
+        if not isinstance(data, dict):
+            self.logger.debug(f"Skipping non-object JSON at line {index}")
+            return None
+
         # Extract timestamp
         timestamp_str = data.get("timestamp") or datetime.now(UTC).isoformat()
         try:

gobby/skills/hubs/__init__.py

@@ -0,0 +1,25 @@
+"""Skill hub providers for searching and installing skills from registries."""
+
+from gobby.skills.hubs.base import (
+    DownloadResult,
+    HubProvider,
+    HubSkillDetails,
+    HubSkillInfo,
+)
+from gobby.skills.hubs.claude_plugins import ClaudePluginsProvider
+from gobby.skills.hubs.clawdhub import ClawdHubProvider
+from gobby.skills.hubs.github_collection import GitHubCollectionProvider
+from gobby.skills.hubs.manager import HubManager
+from gobby.skills.hubs.skillhub import SkillHubProvider
+
+__all__ = [
+    "ClaudePluginsProvider",
+    "ClawdHubProvider",
+    "DownloadResult",
+    "GitHubCollectionProvider",
+    "HubManager",
+    "HubProvider",
+    "HubSkillDetails",
+    "HubSkillInfo",
+    "SkillHubProvider",
+]