+
+
+
+
+
+
## What is Claudable?
@@ -224,4 +230,8 @@ If you encounter the error: `Error output dangerously skip permissions cannot be
## License
-MIT License.
\ No newline at end of file
+MIT License.
+
+## Star History
+
+[](https://www.star-history.com/#opactorai/Claudable&Date)
diff --git a/apps/api/app/api/settings.py b/apps/api/app/api/settings.py
index 248b0eed..8bce9b50 100644
--- a/apps/api/app/api/settings.py
+++ b/apps/api/app/api/settings.py
@@ -1,146 +1,230 @@
-import subprocess
-import asyncio
-import json
-from typing import Dict, Any
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-from app.services.cli.unified_manager import CLIType, CursorAgentCLI
-
-router = APIRouter(prefix="/api/settings", tags=["settings"])
-
-# CLI 옵션과 체크 명령어 정의
-CLI_OPTIONS = [
- {
- "id": "claude",
- "name": "Claude Code",
- "check_command": ["claude", "--version"]
- },
- {
- "id": "cursor",
- "name": "Cursor Agent",
- "check_command": ["cursor-agent", "--version"]
- },
-]
-
-class CLIStatusResponse(BaseModel):
- cli_id: str
- installed: bool
- version: str | None = None
- error: str | None = None
-
-
-async def check_cli_installation(cli_id: str, command: list) -> CLIStatusResponse:
- """단일 CLI의 설치 상태를 확인합니다."""
- try:
- # subprocess를 비동기로 실행
- process = await asyncio.create_subprocess_exec(
- *command,
- stdout=asyncio.subprocess.PIPE,
- stderr=asyncio.subprocess.PIPE
- )
-
- stdout, stderr = await process.communicate()
-
- if process.returncode == 0:
- # 성공적으로 실행된 경우
- version_output = stdout.decode().strip()
- # 버전 정보에서 실제 버전 번호 추출 (첫 번째 라인만 사용)
- version = version_output.split('\n')[0] if version_output else "installed"
-
- return CLIStatusResponse(
- cli_id=cli_id,
- installed=True,
- version=version
- )
- else:
- # 명령어 실행은 되었지만 에러 리턴 코드
- error_msg = stderr.decode().strip() if stderr else f"Command failed with code {process.returncode}"
- return CLIStatusResponse(
- cli_id=cli_id,
- installed=False,
- error=error_msg
- )
-
- except FileNotFoundError:
- # 명령어를 찾을 수 없는 경우 (설치되지 않음)
- return CLIStatusResponse(
- cli_id=cli_id,
- installed=False,
- error="Command not found"
- )
- except Exception as e:
- # 기타 예외
- return CLIStatusResponse(
- cli_id=cli_id,
- installed=False,
- error=str(e)
- )
-
-
-@router.get("/cli-status")
-async def get_cli_status() -> Dict[str, Any]:
- """모든 CLI의 설치 상태를 확인하고 반환합니다."""
- results = {}
-
- # 새로운 UnifiedCLIManager의 CLI 인스턴스 사용
- from app.services.cli.unified_manager import ClaudeCodeCLI, CursorAgentCLI
- cli_instances = {
- "claude": ClaudeCodeCLI(),
- "cursor": CursorAgentCLI()
- }
-
- # 모든 CLI를 병렬로 확인
- tasks = []
- for cli_id, cli_instance in cli_instances.items():
- async def check_cli(cli_id, cli_instance):
- status = await cli_instance.check_availability()
- return cli_id, status
-
- tasks.append(check_cli(cli_id, cli_instance))
-
- # 모든 태스크 실행
- cli_results = await asyncio.gather(*tasks)
-
- # 결과를 딕셔너리로 변환
- for cli_id, status in cli_results:
- results[cli_id] = {
- "installed": status.get("available", False) and status.get("configured", False),
- "version": status.get("models", ["Unknown"])[0] if status.get("models") else None,
- "error": status.get("error"),
- "checking": False
- }
-
- return results
-
-
-# 글로벌 설정 관리를 위한 임시 메모리 저장소 (실제로는 데이터베이스에 저장해야 함)
-GLOBAL_SETTINGS = {
- "default_cli": "claude",
- "cli_settings": {
- "claude": {"model": "claude-sonnet-4"},
- "cursor": {"model": "gpt-5"}
- }
-}
-
-class GlobalSettingsModel(BaseModel):
- default_cli: str
- cli_settings: Dict[str, Any]
-
-
-@router.get("/global")
-async def get_global_settings() -> Dict[str, Any]:
- """글로벌 설정을 반환합니다."""
- return GLOBAL_SETTINGS
-
-
-@router.put("/global")
-async def update_global_settings(settings: GlobalSettingsModel) -> Dict[str, Any]:
- """글로벌 설정을 업데이트합니다."""
- global GLOBAL_SETTINGS
-
- GLOBAL_SETTINGS.update({
- "default_cli": settings.default_cli,
- "cli_settings": settings.cli_settings
- })
-
- return {"success": True, "settings": GLOBAL_SETTINGS}
\ No newline at end of file
+import subprocess
+import asyncio
+import json
+import os
+from typing import Dict, Any
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from app.services.cli.unified_manager import CLIType, CursorAgentCLI
+
+router = APIRouter(prefix="/api/settings", tags=["settings"])
+
+# CLI 옵션과 체크 명령어 정의
+CLI_OPTIONS = [
+ {
+ "id": "claude",
+ "name": "Claude Code",
+ "check_command": ["claude", "--version"]
+ },
+ {
+ "id": "cursor",
+ "name": "Cursor Agent",
+ "check_command": ["cursor-agent", "--version"]
+ },
+]
+
+class CLIStatusResponse(BaseModel):
+ cli_id: str
+ installed: bool
+ version: str | None = None
+ error: str | None = None
+
+
+async def check_cli_installation(cli_id: str, command: list) -> CLIStatusResponse:
+ """단일 CLI의 설치 상태를 확인합니다."""
+ try:
+ # subprocess를 비동기로 실행
+ process = await asyncio.create_subprocess_exec(
+ *command,
+ stdout=asyncio.subprocess.PIPE,
+ stderr=asyncio.subprocess.PIPE
+ )
+
+ stdout, stderr = await process.communicate()
+
+ if process.returncode == 0:
+ # 성공적으로 실행된 경우
+ version_output = stdout.decode().strip()
+ # 버전 정보에서 실제 버전 번호 추출 (첫 번째 라인만 사용)
+ version = version_output.split('\n')[0] if version_output else "installed"
+
+ return CLIStatusResponse(
+ cli_id=cli_id,
+ installed=True,
+ version=version
+ )
+ else:
+ # 명령어 실행은 되었지만 에러 리턴 코드
+ error_msg = stderr.decode().strip() if stderr else f"Command failed with code {process.returncode}"
+ return CLIStatusResponse(
+ cli_id=cli_id,
+ installed=False,
+ error=error_msg
+ )
+
+ except FileNotFoundError:
+ # 명령어를 찾을 수 없는 경우 (설치되지 않음)
+ return CLIStatusResponse(
+ cli_id=cli_id,
+ installed=False,
+ error="Command not found"
+ )
+ except Exception as e:
+ # 기타 예외
+ return CLIStatusResponse(
+ cli_id=cli_id,
+ installed=False,
+ error=str(e)
+ )
+
+
+@router.get("/cli-status")
+async def get_cli_status() -> Dict[str, Any]:
+ """모든 CLI의 설치 상태를 확인하고 반환합니다."""
+ results = {}
+
+ # 새로운 UnifiedCLIManager의 CLI 인스턴스 사용
+ from app.services.cli.unified_manager import ClaudeCodeCLI, CursorAgentCLI
+ cli_instances = {
+ "claude": ClaudeCodeCLI(),
+ "cursor": CursorAgentCLI()
+ }
+
+ # 모든 CLI를 병렬로 확인
+ tasks = []
+ for cli_id, cli_instance in cli_instances.items():
+ async def check_cli(cli_id, cli_instance):
+ status = await cli_instance.check_availability()
+ return cli_id, status
+
+ tasks.append(check_cli(cli_id, cli_instance))
+
+ # 모든 태스크 실행
+ cli_results = await asyncio.gather(*tasks)
+
+ # 결과를 딕셔너리로 변환
+ for cli_id, status in cli_results:
+ results[cli_id] = {
+ "installed": status.get("available", False) and status.get("configured", False),
+ "version": status.get("models", ["Unknown"])[0] if status.get("models") else None,
+ "error": status.get("error"),
+ "checking": False
+ }
+
+ return results
+
+
+# 글로벌 설정 관리를 위한 임시 메모리 저장소 (실제로는 데이터베이스에 저장해야 함)
+GLOBAL_SETTINGS = {
+ "default_cli": "claude",
+ "cli_settings": {
+ "claude": {
+ "model": "claude-sonnet-4",
+ "permission_mode": "acceptEdits" # acceptEdits or bypassPermissions
+ },
+ "cursor": {"model": "gpt-5"}
+ }
+}
+
+class GlobalSettingsModel(BaseModel):
+ default_cli: str
+ cli_settings: Dict[str, Any]
+
+
+@router.get("/global")
+async def get_global_settings() -> Dict[str, Any]:
+ """글로벌 설정을 반환합니다."""
+ return GLOBAL_SETTINGS
+
+
+@router.put("/global")
+async def update_global_settings(settings: GlobalSettingsModel) -> Dict[str, Any]:
+ """글로벌 설정을 업데이트합니다."""
+ global GLOBAL_SETTINGS
+
+ GLOBAL_SETTINGS.update({
+ "default_cli": settings.default_cli,
+ "cli_settings": settings.cli_settings
+ })
+
+ return {"success": True, "settings": GLOBAL_SETTINGS}
+
+
+class TestPermissionRequest(BaseModel):
+ permission_mode: str = "acceptEdits" # acceptEdits or bypassPermissions
+
+
+@router.post("/test-permission-mode")
+async def test_permission_mode(request: TestPermissionRequest) -> Dict[str, Any]:
+ """Test if the specified permission mode works with Claude CLI."""
+
+ # Check if running as root
+ is_root = os.geteuid() == 0 if hasattr(os, 'geteuid') else False
+
+ # Build test command based on permission mode
+ if request.permission_mode == "bypassPermissions":
+ if is_root:
+ return {
+ "success": False,
+ "error": "Cannot use 'bypassPermissions' mode when running as root/sudo",
+ "suggestion": "Use 'acceptEdits' mode instead for root environments",
+ "is_root": is_root
+ }
+ # Test with bypass permissions flag
+ test_command = ["claude", "--dangerously-skip-permissions", "--version"]
+ else:
+ # Test with normal mode (acceptEdits)
+ test_command = ["claude", "--version"]
+
+ try:
+ # Run the test command
+ process = await asyncio.create_subprocess_exec(
+ *test_command,
+ stdout=asyncio.subprocess.PIPE,
+ stderr=asyncio.subprocess.PIPE,
+ env={**os.environ, "CLAUDE_NO_INTERACTIVE": "1"} # Prevent interactive prompts
+ )
+
+ stdout, stderr = await process.communicate()
+
+ if process.returncode == 0:
+ version_output = stdout.decode().strip()
+ return {
+ "success": True,
+ "message": f"Permission mode '{request.permission_mode}' is working correctly",
+ "version": version_output.split('\n')[0] if version_output else "Claude CLI detected",
+ "is_root": is_root
+ }
+ else:
+ error_output = stderr.decode().strip()
+
+ # Check for specific permission error
+ if "dangerously-skip-permissions" in error_output and "root" in error_output:
+ return {
+ "success": False,
+ "error": "Permission mode conflict: Cannot bypass permissions as root user",
+ "suggestion": "Switch to 'acceptEdits' mode for root environments",
+ "details": error_output,
+ "is_root": is_root
+ }
+
+ return {
+ "success": False,
+ "error": f"Claude CLI test failed with permission mode '{request.permission_mode}'",
+ "details": error_output or f"Command failed with exit code {process.returncode}",
+ "is_root": is_root
+ }
+
+ except FileNotFoundError:
+ return {
+ "success": False,
+ "error": "Claude CLI not found",
+ "suggestion": "Please install Claude Code CLI: npm install -g @anthropic-ai/claude-code",
+ "is_root": is_root
+ }
+ except Exception as e:
+ return {
+ "success": False,
+ "error": f"Failed to test permission mode: {str(e)}",
+ "is_root": is_root
+ }
\ No newline at end of file
diff --git a/apps/api/app/services/cli/unified_manager.py b/apps/api/app/services/cli/unified_manager.py
index 56dd8744..27be2e03 100644
--- a/apps/api/app/services/cli/unified_manager.py
+++ b/apps/api/app/services/cli/unified_manager.py
@@ -1,1532 +1,1554 @@
-"""
-Unified CLI Manager for Multi-AI Agent Support
-Supports Claude Code SDK, Cursor Agent, Qwen Code, Gemini CLI, and Codex CLI
-"""
-import asyncio
-import json
-import os
-import subprocess
-import uuid
-from abc import ABC, abstractmethod
-from datetime import datetime
-from typing import Optional, Callable, Dict, Any, AsyncGenerator, List
-from enum import Enum
-import tempfile
-import base64
-
-
-def get_project_root() -> str:
- """Get project root directory using relative path navigation"""
- current_file_dir = os.path.dirname(os.path.abspath(__file__))
- # unified_manager.py -> cli -> services -> app -> api -> apps -> project-root
- project_root = os.path.join(current_file_dir, "..", "..", "..", "..", "..")
- return os.path.abspath(project_root)
-
-
-def get_display_path(file_path: str) -> str:
- """Convert absolute path to relative display path"""
- try:
- project_root = get_project_root()
- if file_path.startswith(project_root):
- # Remove project root from path
- display_path = file_path.replace(project_root + "/", "")
- return display_path.replace("data/projects/", "…/")
- except Exception:
- pass
- return file_path
-
-from app.models.messages import Message
-from app.models.sessions import Session
-from app.core.websocket.manager import manager as ws_manager
-from app.core.terminal_ui import ui
-
-# Claude Code SDK imports
-from claude_code_sdk import ClaudeSDKClient, ClaudeCodeOptions
-
-
-# Model mapping from unified names to CLI-specific names
-MODEL_MAPPING = {
- "claude": {
- "opus-4.1": "claude-opus-4-1-20250805",
- "sonnet-4": "claude-sonnet-4-20250514",
- "opus-4": "claude-opus-4-20250514",
- "haiku-3.5": "claude-3-5-haiku-20241022",
- # Handle claude-prefixed model names
- "claude-sonnet-4": "claude-sonnet-4-20250514",
- "claude-opus-4.1": "claude-opus-4-1-20250805",
- "claude-opus-4": "claude-opus-4-20250514",
- "claude-haiku-3.5": "claude-3-5-haiku-20241022",
- # Support direct full model names
- "claude-opus-4-1-20250805": "claude-opus-4-1-20250805",
- "claude-sonnet-4-20250514": "claude-sonnet-4-20250514",
- "claude-opus-4-20250514": "claude-opus-4-20250514",
- "claude-3-5-haiku-20241022": "claude-3-5-haiku-20241022"
- },
- "cursor": {
- "gpt-5": "gpt-5",
- "sonnet-4": "sonnet-4",
- "opus-4.1": "opus-4.1",
- "sonnet-4-thinking": "sonnet-4-thinking",
- # Handle mapping from unified Claude model names
- "claude-sonnet-4": "sonnet-4",
- "claude-opus-4.1": "opus-4.1",
- "claude-sonnet-4-20250514": "sonnet-4",
- "claude-opus-4-1-20250805": "opus-4.1"
- }
-}
-
-
-class CLIType(str, Enum):
- CLAUDE = "claude"
- CURSOR = "cursor"
-
-
-class BaseCLI(ABC):
- """Abstract base class for all CLI implementations"""
-
- def __init__(self, cli_type: CLIType):
- self.cli_type = cli_type
-
- def _get_cli_model_name(self, model: Optional[str]) -> Optional[str]:
- """Convert unified model name to CLI-specific model name"""
- if not model:
- return None
-
- from app.core.terminal_ui import ui
-
- ui.debug(f"Input model: '{model}' for CLI: {self.cli_type.value}", "Model")
- cli_models = MODEL_MAPPING.get(self.cli_type.value, {})
-
- # Try exact match first
- if model in cli_models:
- mapped_model = cli_models[model]
- ui.info(f"Mapped '{model}' to '{mapped_model}' for {self.cli_type.value}", "Model")
- return mapped_model
-
- # Try direct model name (already CLI-specific)
- if model in cli_models.values():
- ui.info(f"Using direct model name '{model}' for {self.cli_type.value}", "Model")
- return model
-
- # For debugging: show available models
- available_models = list(cli_models.keys())
- ui.warning(f"Model '{model}' not found in mapping for {self.cli_type.value}", "Model")
- ui.debug(f"Available models for {self.cli_type.value}: {available_models}", "Model")
- ui.warning(f"Using model as-is: '{model}'", "Model")
- return model
-
- def get_supported_models(self) -> List[str]:
- """Get list of supported models for this CLI"""
- cli_models = MODEL_MAPPING.get(self.cli_type.value, {})
- return list(cli_models.keys()) + list(cli_models.values())
-
- def is_model_supported(self, model: str) -> bool:
- """Check if a model is supported by this CLI"""
- return model in self.get_supported_models() or model in MODEL_MAPPING.get(self.cli_type.value, {}).values()
-
- @abstractmethod
- async def check_availability(self) -> Dict[str, Any]:
- """Check if CLI is available and configured"""
- pass
-
- @abstractmethod
- async def execute_with_streaming(
- self,
- instruction: str,
- project_path: str,
- session_id: Optional[str] = None,
- log_callback: Optional[Callable] = None,
- images: Optional[List[Dict[str, Any]]] = None,
- model: Optional[str] = None,
- is_initial_prompt: bool = False
- ) -> AsyncGenerator[Message, None]:
- """Execute instruction and yield messages in real-time"""
- pass
-
- @abstractmethod
- async def get_session_id(self, project_id: str) -> Optional[str]:
- """Get current session ID for project"""
- pass
-
- @abstractmethod
- async def set_session_id(self, project_id: str, session_id: str) -> None:
- """Set session ID for project"""
- pass
-
-
- def parse_message_data(self, data: Dict[str, Any], project_id: str, session_id: str) -> Message:
- """Parse CLI-specific message data to unified Message format"""
- return Message(
- id=str(uuid.uuid4()),
- project_id=project_id,
- role=self._normalize_role(data.get("role", "assistant")),
- message_type="chat",
- content=self._extract_content(data),
- metadata_json={
- **data,
- "cli_type": self.cli_type.value,
- "original_format": data
- },
- session_id=session_id,
- created_at=datetime.utcnow()
- )
-
- def _normalize_role(self, role: str) -> str:
- """Normalize different CLI role formats"""
- role_mapping = {
- "model": "assistant",
- "ai": "assistant",
- "human": "user",
- "bot": "assistant"
- }
- return role_mapping.get(role.lower(), role.lower())
-
- def _extract_content(self, data: Dict[str, Any]) -> str:
- """Extract content from CLI-specific data format"""
-
- # Handle Claude's complex content array structure
- if "content" in data and isinstance(data["content"], list):
- content = ""
- for item in data["content"]:
- if item.get("type") == "text":
- content += item.get("text", "")
- elif item.get("type") == "tool_use":
- tool_name = item.get("name", "Unknown")
- tool_input = item.get("input", {})
-
- # Create simplified tool use summary
- summary = self._create_tool_summary(tool_name, tool_input)
- content += f"{summary}\n"
- return content
-
- # Handle simple content string
- elif "content" in data:
- return str(data["content"])
-
- # Handle Gemini parts format
- elif "parts" in data:
- content = ""
- for part in data["parts"]:
- if "text" in part:
- content += part.get("text", "")
- elif "functionCall" in part:
- func_call = part["functionCall"]
- tool_name = func_call.get('name', 'Unknown')
- tool_input = func_call.get("args", {})
- summary = self._create_tool_summary(tool_name, tool_input)
- content += f"{summary}\n"
- return content
-
- # Handle OpenAI/Codex format with choices
- elif "choices" in data and data["choices"]:
- choice = data["choices"][0]
- if "message" in choice:
- return choice["message"].get("content", "")
- elif "text" in choice:
- return choice.get("text", "")
-
- # Handle direct text fields
- elif "text" in data:
- return str(data["text"])
- elif "message" in data:
- # Handle nested message structure
- if isinstance(data["message"], dict):
- return self._extract_content(data["message"])
- return str(data["message"])
-
- # Handle response field (common in many APIs)
- elif "response" in data:
- return str(data["response"])
-
- # Handle delta streaming format
- elif "delta" in data and "content" in data["delta"]:
- return str(data["delta"]["content"])
-
- # Fallback: convert entire data to string
- else:
- return str(data)
-
- def _normalize_tool_name(self, tool_name: str) -> str:
- """Normalize different CLI tool names to unified format"""
- tool_mapping = {
- # File operations
- "read_file": "Read", "read": "Read",
- "write_file": "Write", "write": "Write",
- "edit_file": "Edit",
- "replace": "Edit", "edit": "Edit",
- "delete": "Delete",
-
- # Terminal operations
- "shell": "Bash",
- "run_terminal_command": "Bash",
-
- # Search operations
- "search_file_content": "Grep",
- "codebase_search": "Grep", "grep": "Grep",
- "find_files": "Glob", "glob": "Glob",
- "list_directory": "LS",
- "list_dir": "LS", "ls": "LS",
- "semSearch": "SemSearch",
-
- # Web operations
- "google_web_search": "WebSearch",
- "web_search": "WebSearch",
- "web_fetch": "WebFetch",
-
- # Task/Memory operations
- "save_memory": "SaveMemory",
- }
-
- return tool_mapping.get(tool_name, tool_name)
-
- def _get_clean_tool_display(self, tool_name: str, tool_input: Dict[str, Any]) -> str:
- """Create a clean tool display like Claude Code"""
- normalized_name = self._normalize_tool_name(tool_name)
-
- if normalized_name == "Read":
- file_path = tool_input.get("file_path") or tool_input.get("path") or tool_input.get("file", "")
- if file_path:
- filename = file_path.split("/")[-1]
- return f"Reading {filename}"
- return "Reading file"
- elif normalized_name == "Write":
- file_path = tool_input.get("file_path") or tool_input.get("path") or tool_input.get("file", "")
- if file_path:
- filename = file_path.split("/")[-1]
- return f"Writing {filename}"
- return "Writing file"
- elif normalized_name == "Edit":
- file_path = tool_input.get("file_path") or tool_input.get("path") or tool_input.get("file", "")
- if file_path:
- filename = file_path.split("/")[-1]
- return f"Editing {filename}"
- return "Editing file"
- elif normalized_name == "Bash":
- command = tool_input.get("command") or tool_input.get("cmd") or tool_input.get("script", "")
- if command:
- cmd_display = command.split()[0] if command.split() else command
- return f"Running {cmd_display}"
- return "Running command"
- elif normalized_name == "LS":
- return "Listing directory"
- elif normalized_name == "TodoWrite":
- return "Planning next steps"
- elif normalized_name == "WebSearch":
- query = tool_input.get("query", "")
- if query:
- return f"Searching: {query[:50]}..."
- return "Web search"
- elif normalized_name == "WebFetch":
- url = tool_input.get("url", "")
- if url:
- domain = url.split("//")[-1].split("/")[0] if "//" in url else url.split("/")[0]
- return f"Fetching from {domain}"
- return "Fetching web content"
- else:
- return f"Using {tool_name}"
-
- def _create_tool_summary(self, tool_name: str, tool_input: Dict[str, Any]) -> str:
- """Create a visual markdown summary for tool usage"""
- # Normalize the tool name first
- normalized_name = self._normalize_tool_name(tool_name)
-
- if normalized_name == "Edit":
- # Handle different argument names from different CLIs
- file_path = tool_input.get("file_path") or tool_input.get("path") or tool_input.get("file", "")
- if file_path:
- display_path = get_display_path(file_path)
- if len(display_path) > 40:
- display_path = "…/" + "/".join(display_path.split("/")[-2:])
- return f"**Edit** `{display_path}`"
- return "**Edit** `file`"
- elif normalized_name == "Read":
- # Handle different argument names from different CLIs
- file_path = tool_input.get("file_path") or tool_input.get("path") or tool_input.get("file", "")
- if file_path:
- display_path = get_display_path(file_path)
- if len(display_path) > 40:
- display_path = "…/" + "/".join(display_path.split("/")[-2:])
- return f"**Read** `{display_path}`"
- return "**Read** `file`"
- elif normalized_name == "Bash":
- # Handle different command argument names
- command = tool_input.get("command") or tool_input.get("cmd") or tool_input.get("script", "")
- if command:
- display_cmd = command[:40] + "..." if len(command) > 40 else command
- return f"**Bash** `{display_cmd}`"
- return "**Bash** `command`"
- elif normalized_name == "TodoWrite":
- return "`Planning for next moves...`"
- elif normalized_name == "SaveMemory":
- # Handle save_memory from Gemini CLI
- fact = tool_input.get("fact", "")
- if fact:
- return f"**SaveMemory** `{fact[:40]}{'...' if len(fact) > 40 else ''}`"
- return "**SaveMemory** `storing information`"
- elif normalized_name == "Grep":
- # Handle different search tool arguments
- pattern = tool_input.get("pattern") or tool_input.get("query") or tool_input.get("search", "")
- path = tool_input.get("path") or tool_input.get("file") or tool_input.get("directory", "")
- if pattern:
- if path:
- display_path = get_display_path(path)
- return f"**Search** `{pattern}` in `{display_path}`"
- return f"**Search** `{pattern}`"
- return "**Search** `pattern`"
- elif normalized_name == "Glob":
- # Handle find_files from Cursor Agent
- if tool_name == "find_files":
- name = tool_input.get("name", "")
- if name:
- return f"**Glob** `{name}`"
- return "**Glob** `finding files`"
- pattern = tool_input.get("pattern", "") or tool_input.get("globPattern", "")
- if pattern:
- return f"**Glob** `{pattern}`"
- return "**Glob** `pattern`"
- elif normalized_name == "Write":
- # Handle different argument names from different CLIs
- file_path = tool_input.get("file_path") or tool_input.get("path") or tool_input.get("file", "")
- if file_path:
- display_path = get_display_path(file_path)
- if len(display_path) > 40:
- display_path = "…/" + "/".join(display_path.split("/")[-2:])
- return f"**Write** `{display_path}`"
- return "**Write** `file`"
- elif normalized_name == "MultiEdit":
- # Handle different argument names from different CLIs
- file_path = tool_input.get("file_path") or tool_input.get("path") or tool_input.get("file", "")
- if file_path:
- display_path = get_display_path(file_path)
- if len(display_path) > 40:
- display_path = "…/" + "/".join(display_path.split("/")[-2:])
- return f"🔧 **MultiEdit** `{display_path}`"
- return "🔧 **MultiEdit** `file`"
- elif normalized_name == "LS":
- # Handle list_dir from Cursor Agent and list_directory from Gemini
- path = tool_input.get("path") or tool_input.get("directory") or tool_input.get("dir", "")
- if path:
- display_path = get_display_path(path)
- if len(display_path) > 40:
- display_path = "…/" + display_path[-37:]
- return f"📁 **LS** `{display_path}`"
- return "📁 **LS** `directory`"
- elif normalized_name == "Delete":
- file_path = tool_input.get("path", "")
- if file_path:
- display_path = get_display_path(file_path)
- if len(display_path) > 40:
- display_path = "…/" + "/".join(display_path.split("/")[-2:])
- return f"**Delete** `{display_path}`"
- return "**Delete** `file`"
- elif normalized_name == "SemSearch":
- query = tool_input.get("query", "")
- if query:
- short_query = query[:40] + "..." if len(query) > 40 else query
- return f"**SemSearch** `{short_query}`"
- return "**SemSearch** `query`"
- elif normalized_name == "WebFetch":
- # Handle web_fetch from Gemini CLI
- url = tool_input.get("url", "")
- prompt = tool_input.get("prompt", "")
- if url and prompt:
- domain = url.split("//")[-1].split("/")[0] if "//" in url else url.split("/")[0]
- short_prompt = prompt[:30] + "..." if len(prompt) > 30 else prompt
- return f"**WebFetch** [{domain}]({url})\n> {short_prompt}"
- elif url:
- domain = url.split("//")[-1].split("/")[0] if "//" in url else url.split("/")[0]
- return f"**WebFetch** [{domain}]({url})"
- return "**WebFetch** `url`"
- elif normalized_name == "WebSearch":
- # Handle google_web_search from Gemini CLI and web_search from Cursor Agent
- query = tool_input.get("query") or tool_input.get("search_query", "")
- query = tool_input.get("query", "")
- if query:
- short_query = query[:40] + "..." if len(query) > 40 else query
- return f"**WebSearch** `{short_query}`"
- return "**WebSearch** `query`"
- elif normalized_name == "Task":
- # Handle Task tool from Claude Code
- description = tool_input.get("description", "")
- subagent_type = tool_input.get("subagent_type", "")
- if description and subagent_type:
- return f"🤖 **Task** `{subagent_type}`\n> {description[:50]}{'...' if len(description) > 50 else ''}"
- elif description:
- return f"🤖 **Task** `{description[:40]}{'...' if len(description) > 40 else ''}`"
- return "🤖 **Task** `subtask`"
- elif normalized_name == "ExitPlanMode":
- # Handle ExitPlanMode from Claude Code
- return "✅ **ExitPlanMode** `planning complete`"
- elif normalized_name == "NotebookEdit":
- # Handle NotebookEdit from Claude Code
- notebook_path = tool_input.get("notebook_path", "")
- if notebook_path:
- filename = notebook_path.split("/")[-1]
- return f"📓 **NotebookEdit** `{filename}`"
- return "📓 **NotebookEdit** `notebook`"
- else:
- return f"**{tool_name}** `executing...`"
-
-
-class ClaudeCodeCLI(BaseCLI):
- """Claude Code Python SDK implementation"""
-
- def __init__(self):
- super().__init__(CLIType.CLAUDE)
- self.session_mapping: Dict[str, str] = {}
-
- async def check_availability(self) -> Dict[str, Any]:
- """Check if Claude Code CLI is available"""
- try:
- # First try to check if claude CLI is installed and working
- result = await asyncio.create_subprocess_shell(
- "claude -h",
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE
- )
- stdout, stderr = await result.communicate()
-
- if result.returncode != 0:
- return {
- "available": False,
- "configured": False,
- "error": "Claude Code CLI not installed or not working.\n\nTo install:\n1. Install Claude Code: npm install -g @anthropic-ai/claude-code\n2. Login to Claude: claude login\n3. Try running your prompt again"
- }
-
- # Check if help output contains expected content
- help_output = stdout.decode() + stderr.decode()
- if "claude" not in help_output.lower():
- return {
- "available": False,
- "configured": False,
- "error": "Claude Code CLI not responding correctly.\n\nPlease try:\n1. Reinstall: npm install -g @anthropic-ai/claude-code\n2. Login: claude login\n3. Check installation: claude -h"
- }
-
- return {
- "available": True,
- "configured": True,
- "mode": "CLI",
- "models": self.get_supported_models(),
- "default_models": ["claude-sonnet-4-20250514", "claude-opus-4-1-20250805"]
- }
- except Exception as e:
- return {
- "available": False,
- "configured": False,
- "error": f"Failed to check Claude Code CLI: {str(e)}\n\nTo install:\n1. Install Claude Code: npm install -g @anthropic-ai/claude-code\n2. Login to Claude: claude login"
- }
-
- async def execute_with_streaming(
- self,
- instruction: str,
- project_path: str,
- session_id: Optional[str] = None,
- log_callback: Optional[Callable] = None,
- images: Optional[List[Dict[str, Any]]] = None,
- model: Optional[str] = None,
- is_initial_prompt: bool = False
- ) -> AsyncGenerator[Message, None]:
- """Execute instruction using Claude Code Python SDK"""
- from app.core.terminal_ui import ui
-
- ui.info("Starting Claude SDK execution", "Claude SDK")
- ui.debug(f"Instruction: {instruction[:100]}...", "Claude SDK")
- ui.debug(f"Project path: {project_path}", "Claude SDK")
- ui.debug(f"Session ID: {session_id}", "Claude SDK")
-
- if log_callback:
- await log_callback("Starting execution...")
-
- # Load system prompt
- try:
- from app.services.claude_act import get_system_prompt
- system_prompt = get_system_prompt()
- ui.debug(f"System prompt loaded: {len(system_prompt)} chars", "Claude SDK")
- except Exception as e:
- ui.error(f"Failed to load system prompt: {e}", "Claude SDK")
- system_prompt = "You are Claude Code, an AI coding assistant specialized in building modern web applications."
-
- # Get CLI-specific model name
- cli_model = self._get_cli_model_name(model) or "claude-sonnet-4-20250514"
-
- # Add project directory structure for initial prompts
- if is_initial_prompt:
- project_structure_info = """
-Configure your Claudable preferences
-Dark Mode
-Toggle between light and dark theme
-Auto-save projects
-Automatically save changes to projects
-Show file extensions
-Display file extensions in code explorer
-- Manage your AI coding assistants and their configurations -
-
- )}
- {cli.id === 'cursor' && (
- 
- )}
- {cli.description}
-
- )}
- {cli.id === 'cursor' && (
-
- )}
- {cli.description}
- {hasError && ( -{hasError}
- )} -- Install command: -
-
- {cli.installCommand}
-
-
- - Configure your API tokens for external services. These tokens are stored encrypted and used across all projects. -
- -{provider}
-- {token ? ( - <> - Token configured • Added {new Date(token.created_at).toLocaleDateString()} - - ) : ( - 'Token not configured' - )} -
-- Tokens configured here will be available for all projects. To connect a project to specific repositories - and services, use the Project Settings in each individual project. -
-
- Version 1.0.0
-- Claudable is an AI-powered development platform that integrates with GitHub, Supabase, and Vercel - to streamline your web development workflow. -
-Fast Deploy
-AI Powered
-Built with love for developers
- -Configure your Claudable preferences
+Dark Mode
+Toggle between light and dark theme
+Auto-save projects
+Automatically save changes to projects
+Show file extensions
+Display file extensions in code explorer
++ Manage your AI coding assistants and their configurations +
+
+ )}
+ {cli.id === 'cursor' && (
+
+ )}
+ {cli.description}
++ ⚠️ "Bypass Permissions" mode will not work when running as root/sudo. + Use "Accept Edits" for Docker or WSL environments. +
++ {permissionTestResult.message} +
+ {permissionTestResult.isRoot && ( ++ Running as: {permissionTestResult.isRoot ? 'root user' : 'regular user'} +
+ )} +
+ )}
+ {cli.id === 'cursor' && (
+
+ )}
+ {cli.description}
+ {hasError && ( +{hasError}
+ )} ++ Install command: +
+
+ {cli.installCommand}
+
+
+ + Configure your API tokens for external services. These tokens are stored encrypted and used across all projects. +
+ +{provider}
++ {token ? ( + <> + Token configured • Added {new Date(token.created_at).toLocaleDateString()} + + ) : ( + 'Token not configured' + )} +
++ Tokens configured here will be available for all projects. To connect a project to specific repositories + and services, use the Project Settings in each individual project. +
+
+ Version 1.0.0
++ Claudable is an AI-powered development platform that integrates with GitHub, Supabase, and Vercel + to streamline your web development workflow. +
+Fast Deploy
+AI Powered
+Built with love for developers
+ +