observal-cli 0.2.0__py3-none-any.whl

observal_cli/cmd_doctor.py

@@ -0,0 +1,674 @@
+"""observal doctor: diagnose IDE settings that conflict with Observal telemetry."""
+
+import json
+import os
+import shutil
+from pathlib import Path
+
+import typer
+from rich import print as rprint
+
+from observal_cli import config, settings_reconciler
+from observal_cli.hooks_spec import get_desired_env, get_desired_hooks
+
+doctor_app = typer.Typer(help="Diagnose IDE settings for Observal compatibility")
+
+
+# ── IDE config locations ─────────────────────────────────
+
+IDE_CONFIGS = {
+    "claude-code": {
+        "user_settings": [
+            Path.home() / ".claude" / "settings.json",
+        ],
+        "project_settings": [
+            Path(".claude") / "settings.json",
+            Path(".claude") / "settings.local.json",
+        ],
+        "mcp": [
+            Path(".mcp.json"),
+        ],
+    },
+    "kiro": {
+        "user_settings": [
+            Path.home() / ".kiro" / "settings" / "cli.json",
+            Path.home() / ".kiro" / "settings.json",
+        ],
+        "project_settings": [
+            Path(".kiro") / "settings.json",
+            Path(".kiro") / "settings" / "cli.json",
+        ],
+        "mcp": [],
+    },
+    "cursor": {
+        "user_settings": [
+            Path.home() / ".cursor" / "mcp.json",
+        ],
+        "project_settings": [
+            Path(".cursor") / "mcp.json",
+        ],
+        "mcp": [],
+    },
+    "gemini-cli": {
+        "user_settings": [
+            Path.home() / ".gemini" / "settings.json",
+        ],
+        "project_settings": [
+            Path(".gemini") / "settings.json",
+        ],
+        "mcp": [],
+    },
+}
+
+
+# ── Check functions ──────────────────────────────────────
+
+
+def _load_json(path: Path) -> dict | None:
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return None
+
+
+def _check_claude_code(path: Path, data: dict, issues: list, warnings: list):
+    """Check Claude Code settings for Observal conflicts."""
+    # Hooks disabled entirely
+    if data.get("disableAllHooks"):
+        issues.append(f"{path}: `disableAllHooks` is true. Observal hook telemetry will not fire.")
+
+    # allowedHttpHookUrls blocks our endpoint
+    allowed_urls = data.get("allowedHttpHookUrls")
+    if isinstance(allowed_urls, list) and len(allowed_urls) > 0:
+        has_observal = any("localhost:8000" in u or "observal" in u.lower() for u in allowed_urls)
+        if not has_observal:
+            issues.append(
+                f"{path}: `allowedHttpHookUrls` is set but does not include Observal's URL. "
+                "Add `http://localhost:8000/*` to allow hook telemetry."
+            )
+
+    # httpHookAllowedEnvVars blocks OBSERVAL_API_KEY
+    allowed_env = data.get("httpHookAllowedEnvVars")
+    if isinstance(allowed_env, list) and "OBSERVAL_API_KEY" not in allowed_env:
+        issues.append(
+            f"{path}: `httpHookAllowedEnvVars` does not include `OBSERVAL_API_KEY`. "
+            "Observal hooks need this env var for authentication."
+        )
+
+    # allowManagedHooksOnly blocks project/user hooks
+    if data.get("allowManagedHooksOnly"):
+        issues.append(
+            f"{path}: `allowManagedHooksOnly` is true. "
+            "Only managed hooks will run. Observal hooks installed at project/user level will be blocked."
+        )
+
+    # Permissions denying our tools
+    perms = data.get("permissions", {})
+    deny_list = perms.get("deny", [])
+    for rule in deny_list:
+        if isinstance(rule, str) and ("observal" in rule.lower() or rule == "WebFetch"):
+            warnings.append(f"{path}: deny rule `{rule}` may block Observal telemetry.")
+
+    # MCP servers: check if observal-shim is being bypassed
+    # (project .mcp.json or user mcpServers)
+
+    # Sandbox settings that block network
+    sandbox = data.get("sandbox", {})
+    network = sandbox.get("network", {})
+    allowed_domains = network.get("allowedDomains", [])
+    if isinstance(allowed_domains, list) and len(allowed_domains) > 0:
+        has_localhost = any("localhost" in d for d in allowed_domains)
+        if not has_localhost:
+            warnings.append(
+                f"{path}: sandbox `network.allowedDomains` does not include `localhost`. "
+                "Observal telemetry POSTs to localhost:8000."
+            )
+
+    # env vars that override Observal
+    env = data.get("env", {})
+    if env.get("OBSERVAL_KEY") or env.get("OBSERVAL_SERVER"):
+        warnings.append(f"{path}: env overrides for OBSERVAL_KEY/OBSERVAL_SERVER found. Verify they are correct.")
+
+
+def _check_kiro(path: Path, data: dict, issues: list, warnings: list):
+    """Check Kiro CLI/IDE settings for Observal conflicts."""
+    # Telemetry disabled
+    if data.get("telemetry.enabled") is False or data.get("telemetry", {}).get("enabled") is False:
+        warnings.append(
+            f"{path}: Kiro telemetry is disabled. This does not affect Observal, but may indicate a preference against data collection."
+        )
+
+    # MCP init timeout too low
+    mcp_timeout = data.get("mcp.initTimeout") or data.get("mcp", {}).get("initTimeout")
+    if mcp_timeout is not None and mcp_timeout < 10:
+        warnings.append(
+            f"{path}: `mcp.initTimeout` is {mcp_timeout}s. "
+            "observal-shim adds a small overhead to MCP startup. Consider 10s+."
+        )
+
+    # Auto-compaction may lose telemetry context
+    if data.get("chat.disableAutoCompaction") is False or data.get("chat", {}).get("disableAutoCompaction") is False:
+        pass  # default, fine
+
+
+def _check_kiro_installation(issues: list, warnings: list):
+    """Check Kiro CLI installation and agent hook configuration."""
+    # Check kiro-cli binary
+    if os.system("which kiro-cli > /dev/null 2>&1") != 0:
+        warnings.append("`kiro-cli` not found in PATH. Install with: curl -fsSL https://cli.kiro.dev/install | bash")
+    else:
+        # Check if kiro-cli is authenticated
+        if os.system("kiro-cli whoami > /dev/null 2>&1") != 0:
+            warnings.append("`kiro-cli` is installed but not authenticated. Run `kiro-cli login`.")
+
+    # Check for Kiro agents directory
+    agents_dir = Path.home() / ".kiro" / "agents"
+    if agents_dir.exists():
+        agent_files = list(agents_dir.glob("*.json"))
+        if agent_files:
+            # Check if any agents have Observal hooks configured
+            has_observal_hooks = False
+            for af in agent_files:
+                agent_data = _load_json(af)
+                if agent_data and "hooks" in agent_data:
+                    hooks = agent_data["hooks"]
+                    for _event, hook_list in hooks.items():
+                        for h in hook_list if isinstance(hook_list, list) else []:
+                            cmd = h.get("command", "")
+                            if "observal" in cmd or "telemetry/hooks" in cmd:
+                                has_observal_hooks = True
+                                break
+            if not has_observal_hooks:
+                warnings.append(
+                    "No Kiro agents have Observal telemetry hooks. "
+                    "Run `observal scan --ide kiro --home` to inject hooks."
+                )
+
+    # Check MCP config for observal-shim
+    mcp_path = Path.home() / ".kiro" / "settings" / "mcp.json"
+    if mcp_path.exists():
+        mcp_data = _load_json(mcp_path)
+        if mcp_data:
+            servers = mcp_data.get("mcpServers", {})
+            unwrapped = [
+                n
+                for n, c in servers.items()
+                if isinstance(c, dict)
+                and "observal-shim" not in c.get("command", "")
+                and "observal-proxy" not in c.get("command", "")
+                and "url" not in c  # HTTP transport doesn't need shim
+            ]
+            if unwrapped:
+                warnings.append(
+                    f"Kiro MCP servers not wrapped with observal-shim: {', '.join(unwrapped)}. "
+                    "Run `observal scan --ide kiro` to wrap them."
+                )
+
+
+def _check_cursor(path: Path, data: dict, issues: list, warnings: list):
+    """Check Cursor MCP config for Observal conflicts."""
+    servers = data.get("mcpServers", {})
+    for name, srv_cfg in servers.items():
+        cmd = srv_cfg.get("command", "")
+        args = srv_cfg.get("args", [])
+        full_cmd = f"{cmd} {' '.join(str(a) for a in args)}"
+        # Check if MCP is wrapped with observal-shim
+        if "observal-shim" not in full_cmd and "observal-proxy" not in full_cmd:
+            warnings.append(
+                f"{path}: MCP server `{name}` is not wrapped with observal-shim. "
+                "Install via `observal install <id> --ide cursor` to enable telemetry."
+            )
+
+
+def _check_gemini(path: Path, data: dict, issues: list, warnings: list):
+    """Check Gemini CLI settings for Observal conflicts."""
+    servers = data.get("mcpServers", {})
+    for name, srv_cfg in servers.items():
+        cmd = srv_cfg.get("command", "")
+        args = srv_cfg.get("args", [])
+        full_cmd = f"{cmd} {' '.join(str(a) for a in args)}"
+        if "observal-shim" not in full_cmd and "observal-proxy" not in full_cmd:
+            warnings.append(
+                f"{path}: MCP server `{name}` is not wrapped with observal-shim. "
+                "Install via `observal install <id> --ide gemini-cli` to enable telemetry."
+            )
+
+
+def _check_mcp_json(path: Path, data: dict, issues: list, warnings: list):
+    """Check .mcp.json for unwrapped servers."""
+    servers = data.get("mcpServers", {})
+    for name, srv_cfg in servers.items():
+        cmd = srv_cfg.get("command", "")
+        args = srv_cfg.get("args", [])
+        full_cmd = f"{cmd} {' '.join(str(a) for a in args)}"
+        if "observal-shim" not in full_cmd and "observal-proxy" not in full_cmd:
+            warnings.append(
+                f"{path}: MCP server `{name}` is not wrapped with observal-shim/proxy. "
+                "Telemetry will not be collected for this server."
+            )
+
+
+# ── Observal config checks ──────────────────────────────
+
+
+def _check_observal_config(issues: list, warnings: list):
+    """Check Observal's own config."""
+    config_path = Path.home() / ".observal" / "config.json"
+    if not config_path.exists():
+        issues.append("~/.observal/config.json not found. Run `observal auth login` first.")
+        return
+
+    data = _load_json(config_path)
+    if data is None:
+        issues.append("~/.observal/config.json is not valid JSON.")
+        return
+
+    if not data.get("access_token"):
+        issues.append("No access token in ~/.observal/config.json. Run `observal auth login`.")
+
+    if not data.get("server_url"):
+        issues.append("No server_url in ~/.observal/config.json. Run `observal auth login`.")
+
+    # Check server is reachable
+    server_url = data.get("server_url", "")
+    if server_url:
+        try:
+            import httpx
+
+            resp = httpx.get(f"{server_url}/health", timeout=5)
+            if resp.status_code != 200:
+                issues.append(f"Observal server at {server_url} returned status {resp.status_code}.")
+        except Exception as e:
+            issues.append(f"Cannot reach Observal server at {server_url}: {e}")
+
+
+# ── Environment checks ───────────────────────────────────
+
+
+def _check_environment(issues: list, warnings: list):
+    """Check environment variables."""
+    if os.environ.get("OBSERVAL_KEY"):
+        pass  # good
+    elif not (Path.home() / ".observal" / "config.json").exists():
+        warnings.append("OBSERVAL_KEY env var not set and no config file found.")
+
+    # Check if Docker is available (for sandbox runner)
+    if os.system("docker info > /dev/null 2>&1") != 0:
+        warnings.append("Docker is not running. `observal-sandbox-run` requires Docker.")
+
+    # Check entry points
+    for ep in ["observal-shim", "observal-proxy", "observal-sandbox-run"]:
+        if not shutil.which(ep):
+            warnings.append(f"`{ep}` not found in PATH. Run `uv tool install --editable .` from the Observal repo.")
+
+
+# ── Main doctor command ──────────────────────────────────
+
+
+@doctor_app.callback(invoke_without_command=True)
+def doctor(
+    ctx: typer.Context,
+    ide: str = typer.Option(None, help="Check specific IDE only (claude-code, kiro, cursor, gemini-cli)"),
+    fix: bool = typer.Option(False, help="Show suggested fixes"),
+):
+    """Diagnose IDE and Observal settings for compatibility issues."""
+    if ctx.invoked_subcommand is not None:
+        return  # Let the subcommand handle it
+    issues: list[str] = []
+    warnings: list[str] = []
+
+    rprint("[bold]Observal Doctor[/bold]\n")
+
+    # 1. Check Observal itself
+    rprint("[cyan]Checking Observal config...[/cyan]")
+    _check_observal_config(issues, warnings)
+
+    # 2. Check environment
+    rprint("[cyan]Checking environment...[/cyan]")
+    _check_environment(issues, warnings)
+
+    # 3. Kiro-specific installation checks
+    if not ide or ide in ("kiro", "kiro-cli"):
+        rprint("[cyan]Checking Kiro installation...[/cyan]")
+        _check_kiro_installation(issues, warnings)
+
+    # 4. Check IDE configs
+    ides_to_check = [ide] if ide else list(IDE_CONFIGS.keys())
+
+    for ide_name in ides_to_check:
+        if ide_name not in IDE_CONFIGS:
+            rprint(f"[yellow]Unknown IDE: {ide_name}[/yellow]")
+            continue
+
+        config = IDE_CONFIGS[ide_name]
+        rprint(f"[cyan]Checking {ide_name}...[/cyan]")
+
+        check_fn = {
+            "claude-code": _check_claude_code,
+            "kiro": _check_kiro,
+            "cursor": _check_cursor,
+            "gemini-cli": _check_gemini,
+        }.get(ide_name)
+
+        found_any = False
+        for path_list_key in ["user_settings", "project_settings"]:
+            for path in config[path_list_key]:
+                if path.exists():
+                    found_any = True
+                    data = _load_json(path)
+                    if data is None:
+                        issues.append(f"{path}: file exists but is not valid JSON.")
+                    elif check_fn:
+                        check_fn(path, data, issues, warnings)
+
+        for path in config.get("mcp", []):
+            if path.exists():
+                found_any = True
+                data = _load_json(path)
+                if data is not None:
+                    _check_mcp_json(path, data, issues, warnings)
+
+        if not found_any:
+            rprint(f"  [dim]No config files found for {ide_name}[/dim]")
+
+    # 4. Report
+    rprint("")
+    if not issues and not warnings:
+        rprint("[bold green]All clear![/bold green] No issues found.")
+        raise typer.Exit(0)
+
+    if issues:
+        rprint(f"[bold red]{len(issues)} issue(s):[/bold red]")
+        for i, issue in enumerate(issues, 1):
+            rprint(f"  [red]{i}.[/red] {issue}")
+
+    if warnings:
+        rprint(f"\n[bold yellow]{len(warnings)} warning(s):[/bold yellow]")
+        for i, warning in enumerate(warnings, 1):
+            rprint(f"  [yellow]{i}.[/yellow] {warning}")
+
+    if fix and issues:
+        rprint("\n[bold]Suggested fixes:[/bold]")
+        for issue in issues:
+            if "disableAllHooks" in issue:
+                rprint("  Set `disableAllHooks: false` in your Claude Code settings.json")
+            elif "allowedHttpHookUrls" in issue:
+                rprint('  Add `"http://localhost:8000/*"` to `allowedHttpHookUrls`')
+            elif "OBSERVAL_API_KEY" in issue and "httpHookAllowedEnvVars" in issue:
+                rprint('  Add `"OBSERVAL_API_KEY"` to `httpHookAllowedEnvVars`')
+            elif "allowManagedHooksOnly" in issue:
+                rprint("  Set `allowManagedHooksOnly: false` or add Observal hooks to managed config")
+            elif "observal auth login" in issue:
+                rprint("  Run: observal auth login")
+            elif "Cannot reach" in issue:
+                rprint("  Start the server: cd docker && docker compose up -d")
+            elif "kiro-cli" in issue and "not found" in issue:
+                rprint("  Install: curl -fsSL https://cli.kiro.dev/install | bash")
+            elif "kiro-cli" in issue and "not authenticated" in issue:
+                rprint("  Run: kiro-cli login")
+            elif "Observal telemetry hooks" in issue:
+                rprint("  Run: observal scan --ide kiro --home")
+            elif "observal-shim" in issue and "Kiro" in issue:
+                rprint("  Run: observal scan --ide kiro")
+
+    raise typer.Exit(1 if issues else 0)
+
+
+# ── SLI: reinstall hooks ──────────────────────────────────
+
+# Kiro camelCase event mapping and all supported events
+_KIRO_EVENT_MAP = {
+    "SessionStart": "agentSpawn",
+    "UserPromptSubmit": "userPromptSubmit",
+    "PreToolUse": "preToolUse",
+    "PostToolUse": "postToolUse",
+    "Stop": "stop",
+}
+
+# All Claude Code events that should have hooks
+_ALL_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "SubagentStart",
+    "SubagentStop",
+    "Stop",
+    "StopFailure",
+    "Notification",
+    "TaskCreated",
+    "TaskCompleted",
+    "PreCompact",
+    "PostCompact",
+    "WorktreeCreate",
+    "WorktreeRemove",
+    "Elicitation",
+    "ElicitationResult",
+]
+
+
+def _find_hook_script(name: str) -> str | None:
+    """Locate a hook script by filename."""
+    candidates = [
+        Path(__file__).parent / "hooks" / name,
+        Path(shutil.which(name) or ""),
+    ]
+    for p in candidates:
+        if p.is_file():
+            return str(p.resolve())
+    return None
+
+
+def _install_claude_code_hooks(server_url: str, api_key: str) -> list[str]:
+    """Reconcile Claude Code hooks into ~/.claude/settings.json."""
+    hooks_url = f"{server_url.rstrip('/')}/api/v1/otel/hooks"
+    hook_script = _find_hook_script("observal-hook.sh")
+    stop_script = _find_hook_script("observal-stop-hook.sh")
+    cfg = config.load()
+    user_id = cfg.get("user_id", "")
+
+    desired_hooks = get_desired_hooks(hook_script, stop_script, hooks_url, user_id)
+    desired_env = get_desired_env(server_url, api_key, user_id)
+
+    return settings_reconciler.reconcile(desired_hooks, desired_env)
+
+
+def _install_kiro_hooks(server_url: str) -> tuple[list[str], bool]:
+    """Install Observal hooks into all Kiro agent configs.
+
+    Returns (messages, changed) where changed is True if any file was modified.
+    """
+    agents_dir = Path.home() / ".kiro" / "agents"
+    changes: list[str] = []
+    changed = False
+
+    agents_dir.mkdir(parents=True, exist_ok=True)
+
+    agent_files = list(agents_dir.glob("*.json"))
+
+    hooks_url = f"{server_url.rstrip('/')}/api/v1/otel/hooks"
+
+    # Locate the Kiro hook scripts
+    hook_py = Path(__file__).parent / "hooks" / "kiro_hook.py"
+    stop_py = Path(__file__).parent / "hooks" / "kiro_stop_hook.py"
+
+    if not hook_py.is_file() or not stop_py.is_file():
+        return ["[red]Cannot find kiro_hook.py / kiro_stop_hook.py — reinstall Observal CLI[/red]"], False
+
+    hook_py_str = str(hook_py.resolve())
+    stop_py_str = str(stop_py.resolve())
+
+    # Migrate: remove old default.json created by earlier Observal versions.
+    old_default = agents_dir / "default.json"
+    if old_default.exists():
+        try:
+            od = json.loads(old_default.read_text())
+            if od.get("name") == "default" and any(
+                "otel/hooks" in h.get("command", "")
+                for hs in od.get("hooks", {}).values()
+                if isinstance(hs, list)
+                for h in hs
+            ):
+                old_default.unlink()
+                kiro_bin = shutil.which("kiro-cli") or shutil.which("kiro") or shutil.which("kiro-cli-chat")
+                if kiro_bin:
+                    import subprocess
+
+                    subprocess.run(
+                        [kiro_bin, "agent", "set-default", "kiro_default"],
+                        capture_output=True,
+                        timeout=10,
+                    )
+                changes.append("- default: removed (migrated to kiro_default)")
+                changed = True
+        except (ValueError, OSError):
+            pass
+    agent_files = list(agents_dir.glob("*.json"))
+
+    # Create kiro_default agent config if it doesn't exist, so hooks attach to
+    # the built-in kiro_default agent instead of a separate workspace agent.
+    default_agent = agents_dir / "kiro_default.json"
+    if not default_agent.exists():
+        cmd = "cat | python3 " + hook_py_str + " --url " + hooks_url + " --agent-name kiro_default"
+        stop_cmd = "cat | python3 " + stop_py_str + " --url " + hooks_url + " --agent-name kiro_default"
+        default_agent.write_text(
+            json.dumps(
+                {
+                    "name": "kiro_default",
+                    "hooks": {
+                        "agentSpawn": [{"command": cmd}],
+                        "userPromptSubmit": [{"command": cmd}],
+                        "preToolUse": [{"matcher": "*", "command": cmd}],
+                        "postToolUse": [{"matcher": "*", "command": cmd}],
+                        "stop": [{"command": stop_cmd}],
+                    },
+                },
+                indent=2,
+            )
+            + "\n"
+        )
+        changes.append("+ kiro_default: created with Observal hooks")
+        changed = True
+        agent_files = list(agents_dir.glob("*.json"))
+
+    for af in agent_files:
+        agent_name = af.stem
+        try:
+            data = json.loads(af.read_text())
+        except (json.JSONDecodeError, OSError):
+            changes.append(f"[yellow]⚠ {agent_name}: could not parse, skipped[/yellow]")
+            continue
+
+        # Build per-agent hook command (kiro_hook.py handles all metadata natively)
+        generic_cmd = "cat | python3 " + hook_py_str + " --url " + hooks_url + " --agent-name " + agent_name
+        stop_cmd = "cat | python3 " + stop_py_str + " --url " + hooks_url + " --agent-name " + agent_name
+
+        desired_kiro_hooks: dict[str, list[dict]] = {}
+        for event in _ALL_EVENTS:
+            kiro_event = _KIRO_EVENT_MAP.get(event)
+            if not kiro_event:
+                continue
+            if kiro_event == "stop":
+                desired_kiro_hooks[kiro_event] = [{"command": stop_cmd}]
+            else:
+                entry: dict = {"command": generic_cmd}
+                if kiro_event in ("preToolUse", "postToolUse"):
+                    entry["matcher"] = "*"
+                desired_kiro_hooks[kiro_event] = [entry]
+
+        current_hooks = data.get("hooks", {})
+        updated = False
+
+        for kiro_event, desired_entries in desired_kiro_hooks.items():
+            existing = current_hooks.get(kiro_event, [])
+            # Check if Observal hook already present
+            has_observal = any(
+                "observal" in h.get("command", "") or "otel/hooks" in h.get("command", "") for h in existing
+            )
+            if not has_observal:
+                # Append our hooks, keep existing ones
+                current_hooks[kiro_event] = existing + desired_entries
+                updated = True
+
+        if updated:
+            data["hooks"] = current_hooks
+            af.write_text(json.dumps(data, indent=2) + "\n")
+            changes.append(f"+ {agent_name}: added Observal hooks")
+            changed = True
+        else:
+            changes.append(f"[dim]  {agent_name}: already has Observal hooks[/dim]")
+
+    return changes, changed
+
+
+@doctor_app.command(name="sli")
+def doctor_sli(
+    ide: str = typer.Option(
+        None,
+        "--ide",
+        "-i",
+        help="Target IDE only (claude-code, kiro). Default: both.",
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="Show changes without applying"),
+):
+    """Re-install Observal telemetry hooks into Claude Code and/or Kiro.
+
+    Repairs missing or outdated hooks non-destructively — your existing
+    hooks and settings are preserved.
+    """
+    cfg = config.load()
+    server_url = cfg.get("server_url")
+    api_key = cfg.get("api_key", "")
+
+    if not server_url:
+        rprint("[red]Not configured. Run [bold]observal auth login[/bold] first.[/red]")
+        raise typer.Exit(1)
+
+    targets = [ide] if ide else ["claude-code", "kiro"]
+    any_changes = False
+
+    for target in targets:
+        if target == "claude-code":
+            claude_dir = Path.home() / ".claude"
+            if not claude_dir.is_dir() and not shutil.which("claude"):
+                rprint("[dim]Claude Code not detected — skipping[/dim]")
+                continue
+
+            rprint("[cyan]Claude Code[/cyan]")
+            if dry_run:
+                hooks_url = f"{server_url.rstrip('/')}/api/v1/otel/hooks"
+                hook_script = _find_hook_script("observal-hook.sh")
+                stop_script = _find_hook_script("observal-stop-hook.sh")
+                user_id = cfg.get("user_id", "")
+                desired_hooks = get_desired_hooks(hook_script, stop_script, hooks_url, user_id)
+                desired_env = get_desired_env(server_url, api_key, user_id)
+                changes = settings_reconciler.reconcile(desired_hooks, desired_env, dry_run=True)
+            else:
+                changes = _install_claude_code_hooks(server_url, api_key)
+
+            if changes:
+                any_changes = True
+                for c in changes:
+                    rprint(f"  {c}")
+            else:
+                rprint("  [dim]Already up to date[/dim]")
+
+        elif target in ("kiro", "kiro-cli"):
+            rprint("[cyan]Kiro[/cyan]")
+            if dry_run:
+                rprint("  [yellow]Dry run not supported for Kiro — use without --dry-run[/yellow]")
+                continue
+
+            messages, kiro_changed = _install_kiro_hooks(server_url)
+            if kiro_changed:
+                any_changes = True
+            for c in messages:
+                rprint(f"  {c}")
+        else:
+            rprint(f"[yellow]Unknown IDE: {target}. Use 'claude-code' or 'kiro'.[/yellow]")
+
+    if any_changes:
+        rprint("\n[green]✓ Hooks installed.[/green] Restart your IDE session to pick up changes.")
+    elif not dry_run:
+        rprint("\n[dim]All hooks already up to date.[/dim]")