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

gobby/__init__.py

@@ -1,3 +1,3 @@
 """Gobby - Local-first daemon for multi-CLI session management."""
 
-__version__ = "0.2.7"
+__version__ = "0.2.11"

gobby/adapters/__init__.py

@@ -19,7 +19,10 @@ from gobby.adapters.base import BaseAdapter
 from gobby.adapters.claude_code import ClaudeCodeAdapter
 from gobby.adapters.codex_impl.adapter import CodexAdapter, CodexNotifyAdapter
 from gobby.adapters.codex_impl.client import CodexAppServerClient
+from gobby.adapters.copilot import CopilotAdapter
+from gobby.adapters.cursor import CursorAdapter
 from gobby.adapters.gemini import GeminiAdapter
+from gobby.adapters.windsurf import WindsurfAdapter
 
 __all__ = [
     "BaseAdapter",
@@ -27,5 +30,8 @@ __all__ = [
     "CodexAdapter",
     "CodexAppServerClient",
     "CodexNotifyAdapter",
+    "CopilotAdapter",
+    "CursorAdapter",
     "GeminiAdapter",
+    "WindsurfAdapter",
 ]

gobby/adapters/base.py

@@ -68,8 +68,9 @@ class BaseAdapter(ABC):
 
         This method handles the full round-trip:
         1. Translate native event to HookEvent
-        2. Process through HookManager
-        3. Translate response back to native format
+        2. Inject daemon's machine_id if not provided by CLI
+        3. Process through HookManager
+        4. Translate response back to native format
 
         Note: This method is synchronous for Phase 2A-2B compatibility.
         In Phase 2C+, when HookManager.handle() is async, subclasses may
@@ -89,5 +90,13 @@ class BaseAdapter(ABC):
         if hook_event is None:
             # Event ignored by adapter
             return {}
+
+        # Inject daemon's machine_id if CLI didn't provide it
+        # This centralizes machine_id handling - adapters don't generate IDs
+        if not hook_event.machine_id:
+            from gobby.utils.machine_id import get_machine_id
+
+            hook_event.machine_id = get_machine_id()
+
         hook_response = hook_manager.handle(hook_event)
         return self.translate_from_hook_response(hook_response)

gobby/adapters/claude_code.py

@@ -61,13 +61,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         """Initialize the Claude Code adapter.
 
         Args:
-            hook_manager: Reference to HookManager for strangler fig delegation.
+            hook_manager: Reference to HookManager for delegation.
                          If None, the adapter can only translate (not handle events).
         """
         self._hook_manager = hook_manager
-        # Phase 2C: Use new handle() path with unified HookEvent model
-        # Note: systemMessage handoff notification bug exists in both paths (see plan-multi-cli.md)
-        self._use_legacy = False
 
     def translate_to_hook_event(self, native_event: dict[str, Any]) -> HookEvent:
         """Convert Claude Code native event to unified HookEvent.
@@ -295,8 +292,8 @@ class ClaudeCodeAdapter(BaseAdapter):
 
         # Build hookSpecificOutput if we have any context to inject
         # Only include hookSpecificOutput for hook types that Claude Code's schema accepts
-        # Valid hookEventName values: PreToolUse, UserPromptSubmit, PostToolUse
-        valid_hook_event_names = {"PreToolUse", "UserPromptSubmit", "PostToolUse"}
+        # Valid hookEventName values: PreToolUse, UserPromptSubmit, PostToolUse, SessionStart
+        valid_hook_event_names = {"PreToolUse", "UserPromptSubmit", "PostToolUse", "SessionStart"}
         if additional_context_parts and hook_event_name in valid_hook_event_names:
             result["hookSpecificOutput"] = {
                 "hookEventName": hook_event_name,
@@ -310,14 +307,6 @@ class ClaudeCodeAdapter(BaseAdapter):
     ) -> dict[str, Any]:
         """Main entry point for HTTP endpoint.
 
-        Strangler fig pattern:
-        - Phase 2A-2B: Delegates to existing execute() — validates translation only
-        - Phase 2C+: Calls new handle() with HookEvent
-
-        Note: This method is synchronous for Phase 2A-2B compatibility with
-        the existing execute() method. In Phase 2C+, it will become async
-        when handle() is implemented as async.
-
         Args:
             native_event: Raw payload from Claude Code's hook_dispatcher.py
             hook_manager: HookManager instance for processing.
@@ -325,22 +314,10 @@ class ClaudeCodeAdapter(BaseAdapter):
         Returns:
             Response dict in Claude Code's expected format.
         """
-        # Always translate (validates our mapping is correct)
+        # Translate to HookEvent
         hook_event = self.translate_to_hook_event(native_event)
 
-        # Phase 2C+: Use new HookEvent-based handler
-        # Legacy execute() path removed as HookManager.execute is deprecated/removed.
+        # Use HookEvent-based handler
         hook_type = native_event.get("hook_type", "")
         hook_response = hook_manager.handle(hook_event)
         return self.translate_from_hook_response(hook_response, hook_type=hook_type)
-
-    def set_legacy_mode(self, use_legacy: bool) -> None:
-        """Toggle between legacy and new code paths.
-
-        This method is used during the strangler fig migration to switch
-        between delegating to execute() and calling handle() directly.
-
-        Args:
-            use_legacy: If True, use legacy execute() path. If False, use new handle() path.
-        """
-        self._use_legacy = use_legacy

gobby/adapters/codex_impl/adapter.py

@@ -40,46 +40,26 @@ logger = logging.getLogger(__name__)
 # =============================================================================
 
 
-def _get_machine_id() -> str:
-    """Get or generate a stable machine identifier.
+def _get_daemon_machine_id() -> str | None:
+    """Get machine ID from the daemon's centralized utility.
 
-    Priority:
-    1. Hostname (if available)
-    2. MAC address (if real, not random)
-    3. Persisted UUID file (created on first run)
+    This adapter runs in the daemon process, so we use the centralized
+    machine_id management from utils.machine_id.
     """
-    from pathlib import Path
+    from gobby.utils.machine_id import get_machine_id
+
+    return get_machine_id()
+
+
+def _get_machine_id() -> str:
+    """Generate a machine identifier.
 
-    # Try hostname first
+    Used by Codex adapters when no machine_id is provided.
+    """
     node = platform.node()
     if node:
         return str(uuid.uuid5(uuid.NAMESPACE_DNS, node))
-
-    # Try MAC address - getnode() returns random value with multicast bit set if unavailable
-    mac = uuid.getnode()
-    # Check if MAC is real (multicast bit / bit 0 of first octet is 0)
-    if not (mac >> 40) & 1:
-        return str(uuid.uuid5(uuid.NAMESPACE_DNS, str(mac)))
-
-    # Fall back to persisted ID file for stability across restarts
-    machine_id_file = Path.home() / ".gobby" / ".machine_id"
-    try:
-        if machine_id_file.exists():
-            stored_id = machine_id_file.read_text().strip()
-            if stored_id:
-                return stored_id
-    except OSError:
-        pass  # Fall through to generate new ID
-
-    # Generate and persist a new ID
-    new_id = str(uuid.uuid4())
-    try:
-        machine_id_file.parent.mkdir(parents=True, exist_ok=True)
-        machine_id_file.write_text(new_id)
-    except OSError:
-        pass  # Use the generated ID even if we can't persist it
-
-    return new_id
+    return str(uuid.uuid4())
 
 
 # =============================================================================
@@ -163,8 +143,8 @@ class CodexAdapter(BaseAdapter):
         """
         self._hook_manager = hook_manager
         self._codex_client: CodexAppServerClient | None = None
-        self._machine_id: str | None = None
         self._attached = False
+        self._machine_id: str | None = None
 
     @staticmethod
     def is_codex_available() -> bool:
@@ -177,10 +157,18 @@ class CodexAdapter(BaseAdapter):
 
         return shutil.which("codex") is not None
 
-    def _get_machine_id(self) -> str:
-        """Get or generate a machine identifier."""
-        if self._machine_id is None:
+    def _get_machine_id(self) -> str | None:
+        """Get machine ID with caching and daemon fallback."""
+        if self._machine_id:
+            return self._machine_id
+
+        # Try daemon first
+        self._machine_id = _get_daemon_machine_id()
+
+        # Fallback to generated if daemon not available
+        if not self._machine_id:
             self._machine_id = _get_machine_id()
+
         return self._machine_id
 
     def normalize_tool_name(self, codex_tool_name: str) -> str:
@@ -532,15 +520,23 @@ class CodexNotifyAdapter(BaseAdapter):
             max_seen_threads: Max threads to track (default 1000). Oldest evicted when full.
         """
         self._hook_manager = hook_manager
-        self._machine_id: str | None = None
         # Track threads we've seen using LRU cache to avoid unbounded growth
         self._max_seen_threads = max_seen_threads or self.DEFAULT_MAX_SEEN_THREADS
         self._seen_threads: OrderedDict[str, bool] = OrderedDict()
+        self._machine_id: str | None = None
+
+    def _get_machine_id(self) -> str | None:
+        """Get machine ID with caching and daemon fallback."""
+        if self._machine_id:
+            return self._machine_id
 
-    def _get_machine_id(self) -> str:
-        """Get or generate a machine identifier."""
-        if self._machine_id is None:
+        # Try daemon first
+        self._machine_id = _get_daemon_machine_id()
+
+        # Fallback to generated if daemon not available
+        if not self._machine_id:
             self._machine_id = _get_machine_id()
+
         return self._machine_id
 
     def _mark_thread_seen(self, thread_id: str) -> None:
@@ -716,7 +712,6 @@ class CodexNotifyAdapter(BaseAdapter):
 
 
 __all__ = [
-    "_get_machine_id",
     "CodexAdapter",
     "CodexNotifyAdapter",
 ]

gobby/adapters/copilot.py

@@ -0,0 +1,324 @@
+"""Copilot adapter for hook translation.
+
+This adapter translates between GitHub Copilot CLI's hook format and the unified
+HookEvent/HookResponse models.
+
+Copilot Hook Types (similar to Claude Code but with camelCase):
+- sessionStart, sessionEnd: Session lifecycle
+- userPromptSubmitted: Before user prompt validation
+- preToolUse, postToolUse: Tool execution lifecycle
+- errorOccurred: Error notifications
+
+Key differences from Claude Code:
+- Uses camelCase hook names (preToolUse vs pre-tool-use)
+- Uses `toolName` instead of `tool_name`
+- Uses `toolArgs` instead of `tool_input`
+- Uses `toolResult.textResultForLlm` for tool output
+- Response uses `permissionDecision` (allow/deny) instead of continue/decision
+"""
+
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+from gobby.adapters.base import BaseAdapter
+from gobby.hooks.events import HookEvent, HookEventType, HookResponse, SessionSource
+
+if TYPE_CHECKING:
+    from gobby.hooks.hook_manager import HookManager
+
+
+class CopilotAdapter(BaseAdapter):
+    """Adapter for GitHub Copilot CLI hook translation.
+
+    This adapter:
+    1. Translates Copilot's camelCase hook payloads to unified HookEvent
+    2. Translates HookResponse back to Copilot's expected format
+    3. Normalizes tool names and arguments to standard format
+    """
+
+    source = SessionSource.COPILOT
+
+    # Event type mapping: Copilot hook names -> unified HookEventType
+    # Copilot uses camelCase hook names in the payload's "hook_type" field
+    EVENT_MAP: dict[str, HookEventType] = {
+        "sessionStart": HookEventType.SESSION_START,
+        "sessionEnd": HookEventType.SESSION_END,
+        "userPromptSubmitted": HookEventType.BEFORE_AGENT,
+        "preToolUse": HookEventType.BEFORE_TOOL,
+        "postToolUse": HookEventType.AFTER_TOOL,
+        "errorOccurred": HookEventType.NOTIFICATION,
+        "stop": HookEventType.STOP,
+        "preCompact": HookEventType.PRE_COMPACT,
+        "notification": HookEventType.NOTIFICATION,
+    }
+
+    # Map Copilot hook types to PascalCase event names for response
+    # Uses incoming camelCase hook_type (e.g., "preToolUse" -> "PreToolUse")
+    HOOK_EVENT_NAME_MAP: dict[str, str] = {
+        "sessionStart": "SessionStart",
+        "sessionEnd": "SessionEnd",
+        "userPromptSubmitted": "UserPromptSubmitted",
+        "stop": "Stop",
+        "preToolUse": "PreToolUse",
+        "postToolUse": "PostToolUse",
+        "preCompact": "PreCompact",
+        "notification": "Notification",
+        "errorOccurred": "Notification",
+    }
+
+    def __init__(self, hook_manager: "HookManager | None" = None):
+        """Initialize the Copilot adapter.
+
+        Args:
+            hook_manager: Reference to HookManager for handling events.
+                         If None, the adapter can only translate (not handle events).
+        """
+        self._hook_manager = hook_manager
+
+    def _normalize_event_data(self, input_data: dict[str, Any]) -> dict[str, Any]:
+        """Normalize Copilot event data for CLI-agnostic processing.
+
+        Copilot uses camelCase field names which need to be translated to
+        snake_case for unified processing.
+
+        Normalizations performed:
+        1. toolName → tool_name
+        2. toolArgs → tool_input
+        3. toolResult.textResultForLlm → tool_output
+        4. sessionId → session_id (if present at top level)
+        5. Extract MCP info from toolArgs for call_tool calls
+
+        Args:
+            input_data: Raw input data from Copilot CLI
+
+        Returns:
+            Enriched data dict with normalized fields added
+        """
+        # Start with a copy to avoid mutating original
+        data = dict(input_data)
+
+        # 1. Normalize toolName → tool_name
+        if "toolName" in data and "tool_name" not in data:
+            data["tool_name"] = data["toolName"]
+
+        # 2. Normalize toolArgs → tool_input
+        if "toolArgs" in data and "tool_input" not in data:
+            data["tool_input"] = data["toolArgs"]
+
+        # 3. Normalize toolResult → tool_output
+        tool_result = data.get("toolResult", {})
+        if tool_result and "tool_output" not in data:
+            # Copilot nests result in textResultForLlm
+            if isinstance(tool_result, dict):
+                text_result = tool_result.get("textResultForLlm")
+                if text_result:
+                    data["tool_output"] = text_result
+                # Also check for resultType to detect failures
+                result_type = tool_result.get("resultType")
+                if result_type == "error":
+                    data["is_error"] = True
+            else:
+                data["tool_output"] = tool_result
+
+        # 4. Extract MCP info from nested toolArgs for call_tool calls
+        tool_name = data.get("tool_name", "")
+        tool_input = data.get("tool_input", {}) or {}
+        if tool_name in ("call_tool", "mcp__gobby__call_tool"):
+            if "mcp_server" not in data:
+                data["mcp_server"] = tool_input.get("server_name")
+            if "mcp_tool" not in data:
+                data["mcp_tool"] = tool_input.get("tool_name")
+
+        return data
+
+    def translate_to_hook_event(self, native_event: dict[str, Any]) -> HookEvent:
+        """Convert Copilot native event to unified HookEvent.
+
+        Copilot payloads have the structure:
+        {
+            "hook_type": "preToolUse",  # camelCase hook name
+            "input_data": {
+                "session_id": "abc123",
+                "cwd": "/path/to/project",
+                "toolName": "Read",
+                "toolArgs": {"path": "/file.py"},
+                # For post-tool:
+                "toolResult": {
+                    "resultType": "success",
+                    "textResultForLlm": "file contents..."
+                }
+            }
+        }
+
+        Args:
+            native_event: Raw payload from Copilot hook dispatcher
+
+        Returns:
+            Unified HookEvent with normalized fields.
+        """
+        hook_type = native_event.get("hook_type", "")
+        input_data = native_event.get("input_data", {})
+
+        # Map Copilot hook type to unified event type
+        # Fall back to NOTIFICATION for unknown types (fail-open)
+        event_type = self.EVENT_MAP.get(hook_type, HookEventType.NOTIFICATION)
+
+        # Extract session_id
+        session_id = input_data.get("session_id", "")
+
+        # Check for error in tool result
+        tool_result = input_data.get("toolResult", {})
+        is_error = False
+        if isinstance(tool_result, dict):
+            is_error = tool_result.get("resultType") == "error"
+
+        metadata = {"is_failure": is_error} if is_error else {}
+
+        # Normalize event data for CLI-agnostic processing
+        normalized_data = self._normalize_event_data(input_data)
+
+        return HookEvent(
+            event_type=event_type,
+            session_id=session_id,
+            source=self.source,
+            timestamp=datetime.now(UTC),
+            machine_id=input_data.get("machine_id"),
+            cwd=input_data.get("cwd"),
+            data=normalized_data,
+            metadata=metadata,
+        )
+
+    def translate_from_hook_response(
+        self, response: HookResponse, hook_type: str | None = None
+    ) -> dict[str, Any]:
+        """Convert HookResponse to Copilot's expected format.
+
+        Copilot expects responses in this format:
+        {
+            "permissionDecision": "allow" | "deny",
+            "permissionDecisionReason": "...",  # Optional reason
+            "hookSpecificOutput": {
+                "additionalContext": "..."  # Context to inject
+            }
+        }
+
+        Args:
+            response: Unified HookResponse from HookManager.
+            hook_type: Original Copilot hook type (e.g., "preToolUse")
+                      Used to format hookSpecificOutput appropriately.
+
+        Returns:
+            Dict in Copilot's expected format.
+        """
+        # Map decision to Copilot's permissionDecision format
+        # Copilot uses "allow"/"deny" directly
+        if response.decision in ("deny", "block"):
+            permission_decision = "deny"
+        else:
+            permission_decision = "allow"
+
+        result: dict[str, Any] = {
+            "permissionDecision": permission_decision,
+        }
+
+        # Add reason if present
+        if response.reason:
+            result["permissionDecisionReason"] = response.reason
+
+        # Add system message if present
+        if response.system_message:
+            result["systemMessage"] = response.system_message
+
+        # Build hookSpecificOutput with additionalContext for model context injection
+        hook_event_name = self.HOOK_EVENT_NAME_MAP.get(hook_type or "", "Unknown")
+        additional_context_parts: list[str] = []
+
+        # Add workflow-injected context
+        if response.context:
+            additional_context_parts.append(response.context)
+
+        # Add session identifiers from metadata
+        if response.metadata:
+            gobby_session_id = response.metadata.get("session_id")
+            session_ref = response.metadata.get("session_ref")
+            external_id = response.metadata.get("external_id")
+            is_first_hook = response.metadata.get("_first_hook_for_session", False)
+
+            if gobby_session_id:
+                if is_first_hook:
+                    # First hook: inject full metadata
+                    context_lines = []
+                    if session_ref:
+                        context_lines.append(
+                            f"Gobby Session ID: {session_ref} (or {gobby_session_id})"
+                        )
+                    else:
+                        context_lines.append(f"Gobby Session ID: {gobby_session_id}")
+                    if external_id:
+                        context_lines.append(
+                            f"CLI-Specific Session ID (external_id): {external_id}"
+                        )
+                    if response.metadata.get("parent_session_id"):
+                        context_lines.append(
+                            f"parent_session_id: {response.metadata['parent_session_id']}"
+                        )
+                    if response.metadata.get("machine_id"):
+                        context_lines.append(f"machine_id: {response.metadata['machine_id']}")
+                    if response.metadata.get("project_id"):
+                        context_lines.append(f"project_id: {response.metadata['project_id']}")
+                    # Add terminal context
+                    if response.metadata.get("terminal_term_program"):
+                        context_lines.append(
+                            f"terminal: {response.metadata['terminal_term_program']}"
+                        )
+                    if response.metadata.get("terminal_parent_pid"):
+                        context_lines.append(
+                            f"parent_pid: {response.metadata['terminal_parent_pid']}"
+                        )
+                    additional_context_parts.append("\n".join(context_lines))
+                else:
+                    # Subsequent hooks: inject minimal session ref only
+                    if session_ref:
+                        additional_context_parts.append(f"Gobby Session ID: {session_ref}")
+
+        # Build hookSpecificOutput if we have any context to inject
+        valid_hook_event_names = {
+            "PreToolUse",
+            "UserPromptSubmitted",
+            "PostToolUse",
+            "SessionStart",
+        }
+        if additional_context_parts and hook_event_name in valid_hook_event_names:
+            result["hookSpecificOutput"] = {
+                "hookEventName": hook_event_name,
+                "additionalContext": "\n\n".join(additional_context_parts),
+            }
+
+        return result
+
+    def handle_native(
+        self, native_event: dict[str, Any], hook_manager: "HookManager"
+    ) -> dict[str, Any]:
+        """Main entry point for HTTP endpoint.
+
+        Translates native Copilot event, processes through HookManager,
+        and returns response in Copilot's expected format.
+
+        Args:
+            native_event: Raw payload from Copilot hook dispatcher
+            hook_manager: HookManager instance for processing.
+
+        Returns:
+            Response dict in Copilot's expected format.
+        """
+        # Translate to unified HookEvent
+        hook_event = self.translate_to_hook_event(native_event)
+
+        # Get original hook type for response formatting
+        hook_type = native_event.get("hook_type", "")
+
+        # Process through HookManager
+        hook_response = hook_manager.handle(hook_event)
+
+        # Translate response back to Copilot format
+        return self.translate_from_hook_response(hook_response, hook_type=hook_type)