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

gobby/hooks/events.py

@@ -63,6 +63,9 @@ class SessionSource(str, Enum):
     CODEX = "codex"
     CLAUDE_SDK = "claude_sdk"
     ANTIGRAVITY = "antigravity"  # Antigravity IDE (uses Claude Code format)
+    CURSOR = "cursor"
+    WINDSURF = "windsurf"
+    COPILOT = "copilot"
 
 
 @dataclass
@@ -144,75 +147,120 @@ EVENT_TYPE_CLI_SUPPORT: dict[HookEventType, dict[str, str | None]] = {
         "claude": "SessionStart",
         "gemini": "SessionStart",
         "codex": "thread/started",
+        "cursor": "SessionStart",
+        "windsurf": "SessionStart",
+        "copilot": "SessionStart",
     },
     HookEventType.SESSION_END: {
         "claude": "SessionEnd",
         "gemini": "SessionEnd",
         "codex": "thread/archive",
+        "cursor": "SessionEnd",
+        "windsurf": "SessionEnd",
+        "copilot": "SessionEnd",
     },
     HookEventType.BEFORE_AGENT: {
         "claude": "UserPromptSubmit",
         "gemini": "BeforeAgent",
         "codex": "turn/started",
+        "cursor": "UserPromptSubmit",
+        "windsurf": "UserPromptSubmit",
+        "copilot": "UserPromptSubmit",
     },
     HookEventType.AFTER_AGENT: {
         "claude": "Stop",
         "gemini": "AfterAgent",
         "codex": "turn/completed",
+        "cursor": "Stop",
+        "windsurf": "Stop",
+        "copilot": "Stop",
     },
     HookEventType.STOP: {
         "claude": "Stop",
         "gemini": None,
         "codex": None,
+        "cursor": "Stop",
+        "windsurf": "Stop",
+        "copilot": "Stop",
     },
     HookEventType.BEFORE_TOOL: {
         "claude": "PreToolUse",
         "gemini": "BeforeTool",
         "codex": "requestApproval",
+        "cursor": "PreToolUse",
+        "windsurf": "PreToolUse",
+        "copilot": "PreToolUse",
     },
     HookEventType.AFTER_TOOL: {
         "claude": "PostToolUse",
         "gemini": "AfterTool",
         "codex": "item/completed",
+        "cursor": "PostToolUse",
+        "windsurf": "PostToolUse",
+        "copilot": "PostToolUse",
     },
     HookEventType.BEFORE_TOOL_SELECTION: {
         "claude": None,
         "gemini": "BeforeToolSelection",
         "codex": None,
+        "cursor": None,
+        "windsurf": None,
+        "copilot": None,
     },
     HookEventType.BEFORE_MODEL: {
         "claude": None,
         "gemini": "BeforeModel",
         "codex": None,
+        "cursor": None,
+        "windsurf": None,
+        "copilot": None,
     },
     HookEventType.AFTER_MODEL: {
         "claude": None,
         "gemini": "AfterModel",
         "codex": None,
+        "cursor": None,
+        "windsurf": None,
+        "copilot": None,
     },
     HookEventType.PRE_COMPACT: {
         "claude": "PreCompact",
         "gemini": "PreCompress",
         "codex": None,
+        "cursor": "PreCompact",
+        "windsurf": "PreCompact",
+        "copilot": "PreCompact",
     },
     HookEventType.SUBAGENT_START: {
         "claude": "SubagentStart",
         "gemini": None,
         "codex": None,
+        "cursor": "SubagentStart",
+        "windsurf": "SubagentStart",
+        "copilot": "SubagentStart",
     },
     HookEventType.SUBAGENT_STOP: {
         "claude": "SubagentStop",
         "gemini": None,
         "codex": None,
+        "cursor": "SubagentStop",
+        "windsurf": "SubagentStop",
+        "copilot": "SubagentStop",
     },
     HookEventType.PERMISSION_REQUEST: {
         "claude": "PermissionRequest",
         "gemini": None,
         "codex": None,
+        "cursor": "PermissionRequest",
+        "windsurf": "PermissionRequest",
+        "copilot": "PermissionRequest",
     },
     HookEventType.NOTIFICATION: {
         "claude": "Notification",
         "gemini": "Notification",
         "codex": None,
+        "cursor": "Notification",
+        "windsurf": "Notification",
+        "copilot": "Notification",
     },
 }

gobby/hooks/hook_manager.py

@@ -256,11 +256,33 @@ class HookManager:
         # But 'TemplateEngine' constructor takes optional dirs.
         self._template_engine = TemplateEngine()
 
+        # Skill manager for core skill injection
+        # Initialized before ActionExecutor so it can be passed through
+        self._skill_manager = HookSkillManager()
+
         # Get websocket_server from broadcaster if available
         websocket_server = None
         if self.broadcaster and hasattr(self.broadcaster, "websocket_server"):
             websocket_server = self.broadcaster.websocket_server
 
+        # Initialize pipeline executor for run_pipeline action support
+        self._pipeline_executor = None
+        try:
+            from gobby.storage.pipelines import LocalPipelineExecutionManager
+            from gobby.workflows.pipeline_executor import PipelineExecutor
+
+            # Resolve project_id dynamically since it's not stored on the instance
+            project_id = self._resolve_project_id(None, None)
+            pipeline_execution_manager = LocalPipelineExecutionManager(self._database, project_id)
+            self._pipeline_executor = PipelineExecutor(
+                db=self._database,
+                execution_manager=pipeline_execution_manager,
+                llm_service=self._llm_service,
+                loader=self._workflow_loader,
+            )
+        except Exception as e:
+            logging.getLogger(__name__).debug(f"Pipeline executor not available: {e}")
+
         self._action_executor = ActionExecutor(
             db=self._database,
             session_manager=self._session_storage,
@@ -278,6 +300,9 @@ class HookManager:
             progress_tracker=self._progress_tracker,
             stuck_detector=self._stuck_detector,
             websocket_server=websocket_server,
+            skill_manager=self._skill_manager,
+            pipeline_executor=self._pipeline_executor,
+            workflow_loader=self._workflow_loader,
         )
         self._workflow_engine = WorkflowEngine(
             loader=self._workflow_loader,
@@ -366,9 +391,6 @@ class HookManager:
             logger=self.logger,
         )
 
-        # Skill manager for core skill injection
-        self._skill_manager = HookSkillManager()
-
         # Track sessions that have received full metadata injection
         # Key: "{platform_session_id}:{source}" - cleared on daemon restart
         self._injected_sessions: set[str] = set()
@@ -386,6 +408,8 @@ class HookManager:
             message_manager=self._message_manager,
             skill_manager=self._skill_manager,
             skills_config=self._config.skills if self._config else None,
+            artifact_capture_hook=self._artifact_capture_hook,
+            workflow_config=self._config.workflow if self._config else None,
             get_machine_id=self.get_machine_id,
             resolve_project_id=self._resolve_project_id,
             logger=self.logger,

gobby/install/copilot/hooks/hook_dispatcher.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Hook Dispatcher - Routes GitHub Copilot CLI hooks to HookManager.
+
+This is a thin wrapper script that receives hook calls from Copilot CLI
+and routes them to the appropriate handler via HookManager.
+
+Usage:
+    hook_dispatcher.py --type sessionStart < input.json > output.json
+    hook_dispatcher.py --type preToolUse --debug < input.json > output.json
+
+Exit Codes:
+    0 - Success
+    1 - General error (logged, continues)
+    2 - Block action (Copilot interprets as deny)
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Default daemon configuration
+DEFAULT_DAEMON_PORT = 60887
+DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
+
+
+def get_daemon_url() -> str:
+    """Get the daemon HTTP URL from config file."""
+    config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
+
+    if config_path.exists():
+        try:
+            import yaml
+
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+            port = config.get("daemon_port", DEFAULT_DAEMON_PORT)
+        except Exception:
+            port = DEFAULT_DAEMON_PORT
+    else:
+        port = DEFAULT_DAEMON_PORT
+
+    return f"http://localhost:{port}"
+
+
+def get_terminal_context() -> dict[str, str | int | None]:
+    """Capture terminal/process context for session correlation."""
+    context: dict[str, str | int | None] = {}
+
+    try:
+        context["parent_pid"] = os.getppid()
+    except Exception:
+        context["parent_pid"] = None
+
+    try:
+        context["tty"] = os.ttyname(0)
+    except Exception:
+        context["tty"] = None
+
+    context["term_session_id"] = os.environ.get("TERM_SESSION_ID")
+    context["iterm_session_id"] = os.environ.get("ITERM_SESSION_ID")
+    context["vscode_terminal_id"] = os.environ.get("VSCODE_GIT_ASKPASS_NODE")
+    context["tmux_pane"] = os.environ.get("TMUX_PANE")
+    context["kitty_window_id"] = os.environ.get("KITTY_WINDOW_ID")
+    context["alacritty_socket"] = os.environ.get("ALACRITTY_SOCKET")
+    context["term_program"] = os.environ.get("TERM_PROGRAM")
+
+    return context
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Copilot CLI Hook Dispatcher")
+    parser.add_argument(
+        "--type",
+        required=True,
+        help="Hook type (e.g., sessionStart, preToolUse)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    return parser.parse_args()
+
+
+def check_daemon_running(timeout: float = 0.5) -> bool:
+    """Check if gobby daemon is active and responding."""
+    try:
+        import httpx
+
+        daemon_url = get_daemon_url()
+        response = httpx.get(
+            f"{daemon_url}/admin/status",
+            timeout=timeout,
+            follow_redirects=False,
+        )
+        return response.status_code == 200
+    except Exception:
+        return False
+
+
+def main() -> int:
+    """Main dispatcher execution."""
+    try:
+        args = parse_arguments()
+    except (argparse.ArgumentError, SystemExit):
+        print(json.dumps({}))
+        return 2
+
+    hook_type = args.type
+    debug_mode = args.debug
+
+    # Check if daemon is running
+    if not check_daemon_running():
+        critical_hooks = {"sessionStart", "sessionEnd"}
+        if hook_type in critical_hooks:
+            print(
+                f"Gobby daemon is not running. Start with 'gobby start' before continuing. "
+                f"({hook_type} requires daemon for session state management)",
+                file=sys.stderr,
+            )
+            return 2
+        else:
+            print(
+                json.dumps(
+                    {"status": "daemon_not_running", "message": "gobby daemon is not running"}
+                )
+            )
+            return 0
+
+    import logging
+
+    logger = logging.getLogger("gobby.hooks.dispatcher.copilot")
+    if debug_mode:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING, handlers=[])
+
+    try:
+        input_data = json.load(sys.stdin)
+
+        if hook_type == "sessionStart":
+            input_data["terminal_context"] = get_terminal_context()
+
+        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+
+        if debug_mode:
+            logger.debug(f"Input data: {input_data}")
+
+    except json.JSONDecodeError as e:
+        if debug_mode:
+            logger.error(f"JSON decode error: {e}")
+        print(json.dumps({}))
+        return 2
+
+    import httpx
+
+    daemon_url = get_daemon_url()
+    try:
+        response = httpx.post(
+            f"{daemon_url}/hooks/execute",
+            json={
+                "hook_type": hook_type,
+                "input_data": input_data,
+                "source": "copilot",
+            },
+            timeout=90.0,
+        )
+
+        if response.status_code == 200:
+            result = response.json()
+
+            if debug_mode:
+                logger.debug(f"Output data: {result}")
+
+            # Check for block decision
+            if result.get("continue") is False or result.get("permissionDecision") == "deny":
+                reason = result.get("reason") or "Blocked by hook"
+                print(reason, file=sys.stderr)
+                return 2
+
+            if result and result != {}:
+                print(json.dumps(result))
+
+            return 0
+        else:
+            error_detail = response.text
+            logger.error(
+                f"Daemon returned error: status={response.status_code}, detail={error_detail}"
+            )
+            print(json.dumps({"status": "error", "message": f"Daemon error: {error_detail}"}))
+            return 1
+
+    except Exception as e:
+        logger.error(f"Hook execution failed: {e}", exc_info=True)
+        print(json.dumps({"status": "error", "message": str(e)}))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gobby/install/cursor/hooks/hook_dispatcher.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""Hook Dispatcher - Routes Cursor hooks to HookManager.
+
+This is a thin wrapper script that receives hook calls from Cursor
+and routes them to the appropriate handler via HookManager.
+
+Usage:
+    hook_dispatcher.py --type sessionStart < input.json > output.json
+    hook_dispatcher.py --type preToolUse --debug < input.json > output.json
+
+Exit Codes:
+    0 - Success
+    1 - General error (logged, continues)
+    2 - Block action (Cursor interprets as deny)
+"""
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Default daemon configuration
+DEFAULT_DAEMON_PORT = 60887
+DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
+
+
+def get_daemon_url() -> str:
+    """Get the daemon HTTP URL from config file."""
+    config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
+
+    if config_path.exists():
+        try:
+            import yaml
+
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+            port = config.get("daemon_port", DEFAULT_DAEMON_PORT)
+        except Exception:
+            port = DEFAULT_DAEMON_PORT
+    else:
+        port = DEFAULT_DAEMON_PORT
+
+    return f"http://localhost:{port}"
+
+
+def get_terminal_context() -> dict[str, str | int | None]:
+    """Capture terminal/process context for session correlation."""
+    context: dict[str, str | int | None] = {}
+
+    try:
+        context["parent_pid"] = os.getppid()
+    except Exception:
+        context["parent_pid"] = None
+
+    try:
+        context["tty"] = os.ttyname(0)
+    except Exception:
+        context["tty"] = None
+
+    context["term_session_id"] = os.environ.get("TERM_SESSION_ID")
+    context["iterm_session_id"] = os.environ.get("ITERM_SESSION_ID")
+    context["vscode_terminal_id"] = os.environ.get("VSCODE_GIT_ASKPASS_NODE")
+    context["tmux_pane"] = os.environ.get("TMUX_PANE")
+    context["kitty_window_id"] = os.environ.get("KITTY_WINDOW_ID")
+    context["alacritty_socket"] = os.environ.get("ALACRITTY_SOCKET")
+    context["term_program"] = os.environ.get("TERM_PROGRAM")
+
+    return context
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Cursor Hook Dispatcher")
+    parser.add_argument(
+        "--type",
+        required=True,
+        help="Hook type (e.g., sessionStart, preToolUse)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    return parser.parse_args()
+
+
+def check_daemon_running(timeout: float = 0.5) -> bool:
+    """Check if gobby daemon is active and responding."""
+    try:
+        import httpx
+
+        daemon_url = get_daemon_url()
+        response = httpx.get(
+            f"{daemon_url}/admin/status",
+            timeout=timeout,
+            follow_redirects=False,
+        )
+        return response.status_code == 200
+    except Exception:
+        return False
+
+
+def main() -> int:
+    """Main dispatcher execution."""
+    try:
+        args = parse_arguments()
+    except (argparse.ArgumentError, SystemExit):
+        print(json.dumps({}))
+        return 2
+
+    hook_type = args.type
+    debug_mode = args.debug
+
+    # Check if daemon is running
+    if not check_daemon_running():
+        critical_hooks = {"sessionStart", "sessionEnd", "preCompact"}
+        if hook_type in critical_hooks:
+            print(
+                f"Gobby daemon is not running. Start with 'gobby start' before continuing. "
+                f"({hook_type} requires daemon for session state management)",
+                file=sys.stderr,
+            )
+            return 2
+        else:
+            print(
+                json.dumps(
+                    {"status": "daemon_not_running", "message": "gobby daemon is not running"}
+                )
+            )
+            return 0
+
+    import logging
+
+    logger = logging.getLogger("gobby.hooks.dispatcher.cursor")
+    if debug_mode:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.WARNING, handlers=[])
+
+    try:
+        input_data = json.load(sys.stdin)
+
+        if hook_type == "sessionStart":
+            input_data["terminal_context"] = get_terminal_context()
+
+        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+
+        if debug_mode:
+            logger.debug(f"Input data: {input_data}")
+
+    except json.JSONDecodeError as e:
+        if debug_mode:
+            logger.error(f"JSON decode error: {e}")
+        print(json.dumps({}))
+        return 2
+
+    import httpx
+
+    daemon_url = get_daemon_url()
+    try:
+        response = httpx.post(
+            f"{daemon_url}/hooks/execute",
+            json={
+                "hook_type": hook_type,
+                "input_data": input_data,
+                "source": "cursor",
+            },
+            timeout=90.0,
+        )
+
+        if response.status_code == 200:
+            result = response.json()
+
+            if debug_mode:
+                logger.debug(f"Output data: {result}")
+
+            # Check for block decision
+            if result.get("continue") is False or result.get("decision") == "deny":
+                reason = result.get("user_message") or result.get("reason") or "Blocked by hook"
+                print(reason, file=sys.stderr)
+                return 2
+
+            if result and result != {}:
+                print(json.dumps(result))
+
+            return 0
+        else:
+            error_detail = response.text
+            logger.error(
+                f"Daemon returned error: status={response.status_code}, detail={error_detail}"
+            )
+            print(json.dumps({"status": "error", "message": f"Daemon error: {error_detail}"}))
+            return 1
+
+    except Exception as e:
+        logger.error(f"Hook execution failed: {e}", exc_info=True)
+        print(json.dumps({"status": "error", "message": str(e)}))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -108,6 +108,14 @@ def get_terminal_context() -> dict[str, str | int | bool | None]:
     # Generic terminal program identifier (set by many terminals)
     context["term_program"] = os.environ.get("TERM_PROGRAM")
 
+    # Gobby session context (set when spawned by Gobby)
+    # These allow the daemon to link this Gemini session to a pre-created Gobby session
+    context["gobby_session_id"] = os.environ.get("GOBBY_SESSION_ID")
+    context["gobby_parent_session_id"] = os.environ.get("GOBBY_PARENT_SESSION_ID")
+    context["gobby_agent_run_id"] = os.environ.get("GOBBY_AGENT_RUN_ID")
+    context["gobby_project_id"] = os.environ.get("GOBBY_PROJECT_ID")
+    context["gobby_workflow_name"] = os.environ.get("GOBBY_WORKFLOW_NAME")
+
     return context