Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

36.7 KB
Raw Blame
use crate::agent_events::AgentEvent;
use crate::ai::{AiCapabilitySource, AiConfig, AiEffortCapability, AiEffortLevel, AiModelInfo, AiTestConnectionResult};
use crate::ai_cli_agent::{
    build_cli_agent_prompt, cli_command, dbx_mcp_enabled_tools, dbx_mcp_scope_env, model_infos, parse_cli_jsonl_event,
    run_cli_jsonl_agent, CliAgentCommandSpec, CliAgentJsonlDialect, CliAgentProcessSpec, CliAgentRunOptions,
};
use serde_json::{json, Map, Value};
use std::collections::{BTreeMap, BTreeSet};
use std::env;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::{Duration, Instant};
use tokio::io::AsyncWriteExt;
use tokio::sync::Notify;

const DEFAULT_CLAUDE_CODE_MODELS: &[&str] = &["default", "sonnet", "opus", "fable"];
const CLAUDE_CODE_MODEL_DISCOVERY_TIMEOUT: Duration = Duration::from_secs(10);
const CLAUDE_CODE_SETTING_SOURCES: &str = "user";

pub type ClaudeCodeRunOptions = CliAgentRunOptions;
pub type ClaudeCodeCommandSpec = CliAgentCommandSpec;

struct ClaudeCodeIsolatedCwd {
    path: PathBuf,
}

impl ClaudeCodeIsolatedCwd {
    fn create() -> Result<Self, String> {
        let path = env::temp_dir().join(format!("dbx-claude-code-{}", uuid::Uuid::new_v4()));
        std::fs::create_dir(&path).map_err(|error| {
            format!("[claudeCodeRunFailed] Failed to create isolated Claude Code directory: {error}")
        })?;
        Ok(Self { path })
    }

    fn write_mcp_config(&self, config: &str) -> Result<PathBuf, String> {
        let path = self.path.join("mcp.json");
        std::fs::write(&path, config)
            .map_err(|error| format!("[claudeCodeRunFailed] Failed to write temporary MCP configuration: {error}"))?;
        Ok(path)
    }
}

impl Drop for ClaudeCodeIsolatedCwd {
    fn drop(&mut self) {
        let _ = std::fs::remove_dir_all(&self.path);
    }
}

fn append_claude_code_isolation_args(args: &mut Vec<String>) {
    // User settings retain authentication and preferences without loading project hooks or local overrides.
    args.extend(["--setting-sources".to_string(), CLAUDE_CODE_SETTING_SOURCES.to_string()]);
}

fn claude_code_program(config: &AiConfig) -> String {
    config
        .claude_code_cli_path
        .as_deref()
        .map(str::trim)
        .filter(|path| !path.is_empty())
        .unwrap_or("claude")
        .to_string()
}

fn claude_code_process_env(
    config: &AiConfig,
    command: &ClaudeCodeCommandSpec,
) -> Result<Vec<(String, String)>, String> {
    let mut env = BTreeMap::from_iter(claude_code_cli_env(config)?);
    if let Some(dir) = command_parent_dir(command) {
        let user_path = env.get("PATH").map(String::as_str);
        env.insert("PATH".to_string(), merged_path_with_dir(&dir, user_path));
    }
    Ok(env.into_iter().collect())
}

fn command_parent_dir(command: &ClaudeCodeCommandSpec) -> Option<String> {
    Path::new(&command.program)
        .parent()
        .filter(|parent| !parent.as_os_str().is_empty())
        .map(|parent| parent.to_string_lossy().to_string())
}

fn merged_path_with_dir(dir: &str, user_path: Option<&str>) -> String {
    let mut seen = BTreeSet::new();
    let mut dirs = vec![PathBuf::from(dir)];
    if let Some(path) = user_path {
        dirs.extend(env::split_paths(path));
    }
    dirs.extend(common_executable_dirs());
    let paths = dirs.into_iter().filter(|path| seen.insert(path.clone())).collect::<Vec<_>>();
    env::join_paths(paths).unwrap_or_default().to_string_lossy().to_string()
}

fn common_executable_dirs() -> Vec<PathBuf> {
    let mut dirs = Vec::new();
    if let Ok(path) = env::var("PATH") {
        dirs.extend(env::split_paths(&path));
    }
    #[cfg(windows)]
    {
        if let Ok(app_data) = env::var("APPDATA") {
            dirs.push(PathBuf::from(app_data).join("npm"));
        }
    }
    #[cfg(not(windows))]
    {
        dirs.extend([
            PathBuf::from("/opt/homebrew/bin"),
            PathBuf::from("/usr/local/bin"),
            PathBuf::from("/usr/bin"),
            PathBuf::from("/bin"),
            PathBuf::from("/usr/sbin"),
            PathBuf::from("/sbin"),
        ]);
    }
    dirs
}

fn validate_claude_code_program(config: &AiConfig) -> Result<String, String> {
    let program = claude_code_program(config);
    if starts_with_env_assignment(&program) {
        return Err("[claudeCodeCliPathInvalid] Claude Code CLI path should contain only the executable path. Add environment variables in the Claude Code CLI environment variables section.".to_string());
    }
    if is_path_like_program(&program) {
        let expanded = crate::path_utils::expand_tilde(&program);
        let path = Path::new(&expanded);
        if path.is_dir() {
            return launchable_program_in_dir(path, "claude").ok_or_else(|| {
                "[claudeCodeCliPathInvalid] Claude Code CLI path should point to the claude executable or a directory containing claude."
                    .to_string()
            });
        }
        return Ok(expanded);
    }
    Ok(program)
}

fn launchable_program_in_dir(dir: &Path, program: &str) -> Option<String> {
    program_path_candidates(dir, program)
        .into_iter()
        .find(|candidate| is_launchable_program_path(candidate) && candidate.is_file())
        .map(|path| path.to_string_lossy().to_string())
}

#[cfg(not(windows))]
fn program_path_candidates(dir: &Path, program: &str) -> Vec<PathBuf> {
    vec![dir.join(program)]
}

#[cfg(windows)]
fn program_path_candidates(dir: &Path, program: &str) -> Vec<PathBuf> {
    let path = Path::new(program);
    if path.extension().is_some() {
        return vec![dir.join(program)];
    }
    [".cmd", ".exe", ".bat", ".com", ""].iter().map(|extension| dir.join(format!("{program}{extension}"))).collect()
}

#[cfg(not(windows))]
fn is_launchable_program_path(_path: &Path) -> bool {
    true
}

#[cfg(windows)]
fn is_launchable_program_path(path: &Path) -> bool {
    matches!(
        path.extension().and_then(|extension| extension.to_str()).map(str::to_ascii_lowercase).as_deref(),
        Some("exe" | "cmd" | "bat" | "com")
    )
}

fn is_path_like_program(program: &str) -> bool {
    program.contains('/') || program.contains('\\') || program.starts_with('~')
}

fn starts_with_env_assignment(program: &str) -> bool {
    let Some(first_token) = program.split_whitespace().next() else {
        return false;
    };
    let Some((key, _)) = first_token.split_once('=') else {
        return false;
    };
    is_env_var_name(key)
}

fn is_env_var_name(name: &str) -> bool {
    let mut chars = name.chars();
    let Some(first) = chars.next() else {
        return false;
    };
    (first == '_' || first.is_ascii_alphabetic()) && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric())
}

fn is_reserved_dbx_mcp_env_name(name: &str) -> bool {
    name.to_ascii_uppercase().starts_with("DBX_MCP_")
}

pub fn claude_code_cli_env(config: &AiConfig) -> Result<Vec<(String, String)>, String> {
    let mut env = BTreeMap::new();
    for (key, value) in &config.claude_code_cli_env {
        let key = key.trim();
        if key.is_empty() {
            continue;
        }
        if !is_env_var_name(key) {
            return Err(format!(
                "[claudeCodeEnvInvalid] Invalid Claude Code CLI environment variable name `{key}`. Use names like HTTPS_PROXY."
            ));
        }
        if is_reserved_dbx_mcp_env_name(key) {
            return Err(format!(
                "[claudeCodeEnvReserved] `{key}` is managed by DBX for the scoped MCP server and cannot be set here."
            ));
        }
        env.insert(key.to_string(), value.clone());
    }
    Ok(env.into_iter().collect())
}

pub fn claude_code_enabled_tools(agent_mode: bool) -> Vec<String> {
    dbx_mcp_enabled_tools(agent_mode).into_iter().map(|tool| format!("mcp__dbx__{tool}")).collect()
}

fn claude_code_mcp_config(options: &ClaudeCodeRunOptions) -> String {
    let mcp_command =
        options.mcp_server_command.as_ref().map(|command| command.program.as_str()).unwrap_or("dbx-mcp-server");
    let mut server = Map::new();
    server.insert("command".to_string(), Value::String(mcp_command.to_string()));
    if let Some(command) = options.mcp_server_command.as_ref().filter(|command| !command.args.is_empty()) {
        server.insert("args".to_string(), json!(command.args));
    }

    let env = dbx_mcp_scope_env(options)
        .into_iter()
        .map(|(name, value)| (name.to_string(), Value::String(value)))
        .collect::<Map<_, _>>();
    server.insert("env".to_string(), Value::Object(env));

    json!({
        "mcpServers": {
            "dbx": Value::Object(server)
        }
    })
    .to_string()
}

pub fn build_claude_code_command(
    config: &AiConfig,
    _prompt: &str,
    options: &ClaudeCodeRunOptions,
) -> ClaudeCodeCommandSpec {
    build_claude_code_command_with_mcp_arg(config, options, claude_code_mcp_config(options))
}

fn build_claude_code_command_with_mcp_arg(
    config: &AiConfig,
    options: &ClaudeCodeRunOptions,
    mcp_config_arg: String,
) -> ClaudeCodeCommandSpec {
    let enabled_tools = claude_code_enabled_tools(options.agent_mode);
    let mut args = vec![
        "--print".to_string(),
        "--output-format".to_string(),
        "stream-json".to_string(),
        "--verbose".to_string(),
        "--input-format".to_string(),
        "text".to_string(),
        "--no-session-persistence".to_string(),
        "--permission-mode".to_string(),
        "dontAsk".to_string(),
        "--mcp-config".to_string(),
        mcp_config_arg,
        "--strict-mcp-config".to_string(),
    ];
    append_claude_code_isolation_args(&mut args);
    args.push("--tools".to_string());
    args.extend(enabled_tools.iter().cloned());
    args.push("--allowedTools".to_string());
    args.extend(enabled_tools);

    let model = config.model.trim();
    if !model.is_empty() && !model.eq_ignore_ascii_case("default") {
        args.push("--model".to_string());
        args.push(model.to_string());
    }
    let effort = match config.runtime_effort.as_ref() {
        Some(effort) => effort.cli_value(),
        None => config.reasoning_level.as_claude_code_effort().map(ToString::to_string),
    };
    if let Some(effort) = effort {
        args.push("--effort".to_string());
        args.push(effort);
    }

    ClaudeCodeCommandSpec { program: claude_code_program(config), args }
}

pub fn build_claude_code_prompt(
    system_prompt: &str,
    messages: &[crate::ai::AiMessage],
    allow_write_sql: bool,
) -> String {
    build_cli_agent_prompt("Claude Code", system_prompt, messages, allow_write_sql)
}

pub async fn list_claude_code_models(config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
    let program = validate_claude_code_program(config)?;
    Ok(discover_claude_code_models(config, program).await.unwrap_or_else(|| model_infos(DEFAULT_CLAUDE_CODE_MODELS)))
}

async fn discover_claude_code_models(config: &AiConfig, program: String) -> Option<Vec<AiModelInfo>> {
    let mut command = ClaudeCodeCommandSpec {
        program,
        args: vec![
            "--print".to_string(),
            "--output-format".to_string(),
            "stream-json".to_string(),
            "--input-format".to_string(),
            "stream-json".to_string(),
            "--verbose".to_string(),
        ],
    };
    append_claude_code_isolation_args(&mut command.args);
    let env = claude_code_process_env(config, &command).ok()?;
    let isolated_cwd = ClaudeCodeIsolatedCwd::create().ok()?;
    let mut process = cli_command(&command.program);
    process
        .args(command.args.iter().map(String::as_str))
        .envs(env.iter().map(|(key, value)| (key.as_str(), value.as_str())))
        .env_remove("CLAUDECODE")
        .current_dir(&isolated_cwd.path)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .kill_on_drop(true);

    let mut child = process.spawn().ok()?;
    let mut stdin = child.stdin.take()?;
    let mut request = serde_json::to_vec(&json!({
        "type": "control_request",
        "request_id": "dbx_model_discovery",
        "request": { "subtype": "initialize" }
    }))
    .ok()?;
    request.push(b'\n');
    stdin.write_all(&request).await.ok()?;
    drop(stdin);

    let output =
        tokio::time::timeout(CLAUDE_CODE_MODEL_DISCOVERY_TIMEOUT, child.wait_with_output()).await.ok()?.ok()?;
    parse_claude_code_models(&String::from_utf8_lossy(&output.stdout))
}

fn parse_claude_code_models(stdout: &str) -> Option<Vec<AiModelInfo>> {
    for line in stdout.lines() {
        let Ok(event) = serde_json::from_str::<Value>(line.trim()) else {
            continue;
        };
        if event.get("type").and_then(Value::as_str) != Some("control_response") {
            continue;
        }

        let Some(response) = event.get("response") else {
            continue;
        };
        let data = response.get("response").unwrap_or(response);
        let Some(models) = data.get("models").and_then(Value::as_array) else {
            continue;
        };
        let mut seen = BTreeSet::new();
        let mut result = Vec::new();
        for model in models {
            let Some(id) = model
                .get("value")
                .and_then(Value::as_str)
                .or_else(|| model.get("id").and_then(Value::as_str))
                .map(str::trim)
                .filter(|id| !id.is_empty())
            else {
                continue;
            };
            if !seen.insert(id.to_string()) {
                continue;
            }
            let display_name = model
                .get("displayName")
                .and_then(Value::as_str)
                .or_else(|| model.get("display_name").and_then(Value::as_str))
                .map(str::trim)
                .filter(|name| !name.is_empty())
                .map(ToString::to_string);
            let mut info = AiModelInfo::new(id, display_name);
            let effort_levels = parse_claude_code_effort_level_strings(model);
            info.supported_effort_levels =
                effort_levels.iter().filter_map(|level| level.parse::<AiEffortLevel>().ok()).collect();
            info.effort_capability =
                if model.get("supportsEffort").or_else(|| model.get("supports_effort")).and_then(Value::as_bool)
                    == Some(false)
                {
                    Some(AiEffortCapability::Unsupported)
                } else {
                    crate::ai_effort::dynamic_enum_capability(effort_levels, AiCapabilitySource::LocalCli)
                };
            result.push(info);
        }

        if result.is_empty() {
            return None;
        }
        if seen.insert("default".to_string()) {
            result.insert(0, AiModelInfo::new("default", Some("Default".to_string())));
        }
        return Some(result);
    }

    None
}

fn parse_claude_code_effort_level_strings(model: &Value) -> Vec<String> {
    if model.get("supportsEffort").or_else(|| model.get("supports_effort")).and_then(Value::as_bool) == Some(false) {
        return Vec::new();
    }
    let Some(levels) =
        model.get("supportedEffortLevels").or_else(|| model.get("supported_effort_levels")).and_then(Value::as_array)
    else {
        return Vec::new();
    };

    let mut seen = BTreeSet::new();
    levels
        .iter()
        .filter_map(Value::as_str)
        .map(str::trim)
        .filter(|level| !level.is_empty())
        .filter(|level| seen.insert((*level).to_string()))
        .map(ToString::to_string)
        .collect()
}

pub async fn test_claude_code_connection(config: &AiConfig) -> Result<AiTestConnectionResult, String> {
    let start = Instant::now();
    let claude_command = ClaudeCodeCommandSpec { program: validate_claude_code_program(config)?, args: Vec::new() };
    let mut command = cli_command(&claude_command.program);
    command.args(claude_command.args.iter().map(String::as_str));
    command.args(["auth", "status"]);
    command.envs(
        claude_code_process_env(config, &claude_command)?.iter().map(|(key, value)| (key.as_str(), value.as_str())),
    );

    let output = command.output().await.map_err(|e| classify_claude_code_spawn_error(&e.to_string()))?;

    if output.status.success() {
        Ok(AiTestConnectionResult {
            success: true,
            message: format!("OK - {}ms", start.elapsed().as_millis()),
            latency_ms: Some(start.elapsed().as_millis() as u64),
            model_used: config.model.trim().to_string(),
            error_category: None,
        })
    } else {
        let stderr = String::from_utf8_lossy(&output.stderr);
        let stdout = String::from_utf8_lossy(&output.stdout);
        let message =
            [stderr.trim(), stdout.trim()].into_iter().filter(|part| !part.is_empty()).collect::<Vec<_>>().join("\n");
        Err(classify_claude_code_run_error(&message))
    }
}

fn classify_claude_code_spawn_error(message: &str) -> String {
    if message.contains("No such file") || message.contains("not found") {
        format!("[claudeCodeNotInstalled] {message}")
    } else if is_command_line_too_long_error(message) {
        format!("[claudeCodeCommandLineTooLong] {message}")
    } else {
        format!("[claudeCodeRunFailed] {message}")
    }
}

fn is_command_line_too_long_error(message: &str) -> bool {
    let lower = message.to_ascii_lowercase();
    message.contains("os error 206")
        || message.contains("文件名或扩展名太长")
        || lower.contains("filename or extension is too long")
        || lower.contains("the filename or extension is too long")
}

fn classify_claude_code_run_error(stderr: &str) -> String {
    let lower = stderr.to_ascii_lowercase();
    if lower.contains("invalid mcp configuration") || lower.contains("mcp config file not found") {
        format!("[claudeCodeMcpConfigInvalid] {stderr}")
    } else if lower.contains("not authenticated")
        || lower.contains("authentication required")
        || lower.contains("please login")
    {
        format!("[claudeCodeNotAuthenticated] {stderr}")
    } else if lower.contains("dbx-mcp-server") || lower.contains("enoent") {
        format!("[dbxMcpMissing] {stderr}")
    } else if lower.contains("mcp") && (lower.contains("dbx") || lower.contains("server")) {
        format!("[claudeCodeMcpStartupFailed] {stderr}")
    } else {
        format!("[claudeCodeRunFailed] {stderr}")
    }
}

pub fn parse_claude_code_jsonl_event(line: &str) -> Option<Vec<AgentEvent>> {
    parse_cli_jsonl_event(line, CliAgentJsonlDialect::ClaudeCodePrint)
}

pub async fn run_claude_code_agent(
    config: &AiConfig,
    prompt: &str,
    options: ClaudeCodeRunOptions,
    cancelled: &Notify,
    on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
) -> Result<String, String> {
    let program = validate_claude_code_program(config)?;
    let isolated_cwd = ClaudeCodeIsolatedCwd::create()?;
    let mcp_config_path = isolated_cwd.write_mcp_config(&claude_code_mcp_config(&options))?;
    let mut command =
        build_claude_code_command_with_mcp_arg(config, &options, mcp_config_path.to_string_lossy().to_string());
    command.program = program;
    let env = claude_code_process_env(config, &command)?;
    let result = run_cli_jsonl_agent(
        CliAgentProcessSpec {
            command,
            env,
            env_remove: Vec::new(),
            current_dir: Some(isolated_cwd.path.clone()),
            stdin: Some(prompt.to_string()),
            dialect: CliAgentJsonlDialect::ClaudeCodePrint,
            classify_spawn_error: classify_claude_code_spawn_error,
            classify_run_error: classify_claude_code_run_error,
        },
        cancelled,
        on_event,
    )
    .await;
    result
}

#[cfg(test)]
mod tests {
    use super::{
        build_claude_code_command, classify_claude_code_run_error, claude_code_cli_env, claude_code_enabled_tools,
        parse_claude_code_jsonl_event, parse_claude_code_models, validate_claude_code_program, ClaudeCodeRunOptions,
        DEFAULT_CLAUDE_CODE_MODELS,
    };
    #[cfg(unix)]
    use super::{list_claude_code_models, run_claude_code_agent};
    use crate::agent_events::AgentEvent;
    use crate::ai::{
        AiApiStyle, AiAuthMethod, AiConfig, AiEffortCapability, AiEffortLevel, AiEffortSelection, AiProvider,
        AiReasoningLevel,
    };
    use crate::ai_cli_agent::{model_infos, CliAgentCommandSpec};
    #[cfg(unix)]
    use std::os::unix::fs::PermissionsExt;
    #[cfg(unix)]
    use tokio::sync::Notify;

    fn claude_code_config(model: &str) -> AiConfig {
        AiConfig {
            provider: AiProvider::ClaudeCodeCli,
            api_key: String::new(),
            auth_method: AiAuthMethod::Bearer,
            endpoint: String::new(),
            model: model.to_string(),
            models: Vec::new(),
            api_style: AiApiStyle::Completions,
            custom_headers: Default::default(),
            proxy_enabled: false,
            proxy_url: String::new(),
            skip_tls_verify: false,
            enable_thinking: true,
            reasoning_level: AiReasoningLevel::Default,
            max_output_tokens: None,
            runtime_effort: None,
            context_window: None,
            max_retries: None,
            codex_cli_path: None,
            codex_cli_env: Default::default(),
            claude_code_cli_path: None,
            claude_code_cli_env: Default::default(),
            pi_agent_cli_path: None,
            pi_agent_cli_env: Default::default(),
            opencode_cli_path: None,
            opencode_cli_env: Default::default(),
            opencode_cli_version: None,
            cursor_cli_path: None,
            cursor_cli_env: Default::default(),
            grok_cli_path: None,
            grok_cli_env: Default::default(),
            codebuddy_cli_path: None,
            codebuddy_cli_env: Default::default(),
            qoder_cli_path: None,
            qoder_cli_env: Default::default(),
        }
    }

    fn run_options() -> ClaudeCodeRunOptions {
        ClaudeCodeRunOptions {
            connection_id: "conn-1".to_string(),
            connection_name: "local".to_string(),
            database: "demo".to_string(),
            selected_databases: Vec::new(),
            schema: None,
            agent_mode: true,
            allow_writes: false,
            allow_dangerous: false,
            confirmed_write_sql: None,
            mcp_server_command: None,
        }
    }

    #[cfg(unix)]
    fn isolated_cli_test_config() -> (AiConfig, std::path::PathBuf, std::path::PathBuf) {
        let project_dir = std::env::temp_dir().join(format!("dbx-claude-project-test-{}", uuid::Uuid::new_v4()));
        let claude_dir = project_dir.join(".claude");
        let user_config_dir = project_dir.join("user-config");
        let hook_marker = project_dir.join("project-hook-loaded");
        std::fs::create_dir_all(&claude_dir).unwrap();
        std::fs::create_dir_all(&user_config_dir).unwrap();
        std::fs::write(user_config_dir.join("auth-marker"), "authenticated").unwrap();
        std::fs::write(
            claude_dir.join("settings.json"),
            serde_json::to_vec(&serde_json::json!({
                "model": "project-model-must-not-load",
                "hooks": {
                    "SessionStart": [{
                        "matcher": "",
                        "hooks": [{
                            "type": "command",
                            "command": format!("printf loaded > {}", hook_marker.display())
                        }]
                    }]
                }
            }))
            .unwrap(),
        )
        .unwrap();

        let executable = project_dir.join("claude");
        std::fs::write(
            &executable,
            r#"#!/bin/sh
user_settings=false
mcp_config=""
previous=""
for arg in "$@"; do
  if [ "$previous" = "--setting-sources" ] && [ "$arg" = "user" ]; then
    user_settings=true
  elif [ "$previous" = "--mcp-config" ]; then
    mcp_config="$arg"
  fi
  previous="$arg"
done
if [ "$user_settings" != "true" ] || [ "$PWD" = "$DBX_TEST_PROJECT_DIR" ]; then
  printf loaded > "$DBX_TEST_HOOK_MARKER"
fi
if [ ! -f "$CLAUDE_CONFIG_DIR/auth-marker" ]; then
  exit 9
fi
input=$(cat)
case " $* " in
  *" --input-format stream-json "*)
    printf '%s\n' '{"type":"control_response","response":{"response":{"models":[{"value":"claude-user-model","displayName":"User Model"}]}}}'
    ;;
  *)
    if [ ! -f "$mcp_config" ] || ! grep -q '"mcpServers"' "$mcp_config"; then
      printf '%s\n' 'invalid MCP configuration' >&2
      exit 10
    fi
    printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"isolated execution"}]}}'
    printf '%s\n' '{"type":"result","subtype":"success"}'
    ;;
esac
"#,
        )
        .unwrap();
        let mut permissions = std::fs::metadata(&executable).unwrap().permissions();
        permissions.set_mode(0o755);
        std::fs::set_permissions(&executable, permissions).unwrap();

        let mut config = claude_code_config("default");
        config.claude_code_cli_path = Some(executable.to_string_lossy().to_string());
        config
            .claude_code_cli_env
            .insert("CLAUDE_CONFIG_DIR".to_string(), user_config_dir.to_string_lossy().to_string());
        config
            .claude_code_cli_env
            .insert("DBX_TEST_PROJECT_DIR".to_string(), project_dir.to_string_lossy().to_string());
        config
            .claude_code_cli_env
            .insert("DBX_TEST_HOOK_MARKER".to_string(), hook_marker.to_string_lossy().to_string());

        (config, project_dir, hook_marker)
    }

    #[test]
    fn builds_claude_code_command_with_scoped_mcp_and_default_model() {
        let spec = build_claude_code_command(&claude_code_config("default"), "hello", &run_options());

        assert_eq!(spec.program, "claude");
        assert!(spec.args.contains(&"--print".to_string()));
        assert!(spec.args.contains(&"stream-json".to_string()));
        assert!(spec.args.contains(&"--mcp-config".to_string()));
        assert!(spec.args.windows(2).any(|args| args == ["--setting-sources", "user"]));
        assert!(
            spec.args.iter().position(|arg| arg == "--setting-sources")
                < spec.args.iter().position(|arg| arg == "--tools")
        );
        assert!(!spec.args.contains(&"hello".to_string()));
        assert!(!spec.args.contains(&"--model".to_string()));
        assert!(!spec.args.contains(&"--effort".to_string()));
        assert!(spec.args.iter().any(|arg| arg.contains("\"command\":\"dbx-mcp-server\"")));
        assert!(spec.args.iter().any(|arg| arg.contains("\"DBX_MCP_ALLOW_WRITES\":\"0\"")));
        assert!(spec.args.iter().any(|arg| arg.contains("\"DBX_MCP_SCOPE_CONNECTION_ID\":\"conn-1\"")));
        assert!(spec.args.iter().any(|arg| arg.contains("mcp__dbx__dbx_execute_query")));
    }

    #[cfg(unix)]
    #[tokio::test]
    async fn model_discovery_uses_user_settings_from_an_isolated_directory() {
        let (config, project_dir, hook_marker) = isolated_cli_test_config();

        let models = list_claude_code_models(&config).await.unwrap();

        assert!(models.iter().any(|model| model.id == "claude-user-model"));
        assert!(!hook_marker.exists());
        let _ = std::fs::remove_dir_all(project_dir);
    }

    #[cfg(unix)]
    #[tokio::test]
    async fn execution_uses_user_settings_and_temporary_mcp_config_from_an_isolated_directory() {
        let (config, project_dir, hook_marker) = isolated_cli_test_config();

        let output = run_claude_code_agent(&config, "hello", run_options(), &Notify::new(), |_| {}).await.unwrap();

        assert_eq!(output, "isolated execution");
        assert!(!hook_marker.exists());
        let _ = std::fs::remove_dir_all(project_dir);
    }

    #[test]
    fn builds_claude_code_command_with_custom_mcp_server_and_ask_tools() {
        let mut options = run_options();
        options.agent_mode = false;
        options.mcp_server_command = Some(CliAgentCommandSpec {
            program: "/opt/dbx/bin/dbx-mcp-server".to_string(),
            args: vec!["--stdio".to_string()],
        });
        let spec = build_claude_code_command(&claude_code_config("sonnet"), "hello", &options);

        let model_pos = spec.args.iter().position(|arg| arg == "--model").unwrap();
        assert_eq!(spec.args[model_pos + 1], "sonnet");
        assert!(spec.args.iter().any(|arg| arg.contains("\"command\":\"/opt/dbx/bin/dbx-mcp-server\"")));
        assert!(spec.args.iter().any(|arg| arg.contains("\"args\":[\"--stdio\"]")));
        assert!(!claude_code_enabled_tools(false).iter().any(|tool| tool == "mcp__dbx__dbx_execute_query"));
        assert!(!spec.args.iter().any(|arg| arg.contains("mcp__dbx__dbx_execute_query")));
    }

    #[test]
    fn builds_claude_code_command_with_supported_effort() {
        let mut config = claude_code_config("sonnet");
        config.reasoning_level = AiReasoningLevel::Xhigh;

        let spec = build_claude_code_command(&config, "hello", &run_options());

        let effort_pos = spec.args.iter().position(|arg| arg == "--effort").unwrap();
        assert_eq!(spec.args[effort_pos + 1], "xhigh");

        config.reasoning_level = AiReasoningLevel::Minimal;
        let spec = build_claude_code_command(&config, "hello", &run_options());
        assert!(!spec.args.contains(&"--effort".to_string()));
    }

    #[test]
    fn runtime_effort_takes_priority_over_legacy_reasoning_level() {
        let mut config = claude_code_config("sonnet");
        config.reasoning_level = AiReasoningLevel::Xhigh;
        config.runtime_effort = Some(AiEffortSelection::ProviderDefault);

        let spec = build_claude_code_command(&config, "hello", &run_options());
        assert!(!spec.args.contains(&"--effort".to_string()));

        config.runtime_effort = Some(AiEffortSelection::Enum("future".to_string()));
        let spec = build_claude_code_command(&config, "hello", &run_options());
        let effort_pos = spec.args.iter().position(|arg| arg == "--effort").unwrap();
        assert_eq!(spec.args[effort_pos + 1], "future");
    }

    #[test]
    fn default_model_list_matches_supported_aliases() {
        assert_eq!(model_infos(DEFAULT_CLAUDE_CODE_MODELS), model_infos(&["default", "sonnet", "opus", "fable"]));
    }

    #[test]
    fn parses_discovered_claude_code_models() {
        let stdout = concat!(
            "not json\n",
            r#"{"type":"system","subtype":"init"}"#,
            "\n",
            r#"{"type":"control_response","response":{"subtype":"success","response":{"commands":[]}}}"#,
            "\n",
            r#"{"type":"control_response","response":{"subtype":"success","request_id":"dbx_model_discovery","response":{"models":[{"value":"default","displayName":"Default","resolvedModel":"claude-sonnet"},{"value":"claude-sonnet-4-6","displayName":"Sonnet 4.6","supportsEffort":true,"supportedEffortLevels":["low","medium","high","max","high","future"]},{"value":"claude-sonnet-4-6","displayName":"Duplicate"},{"value":"claude-opus-4-8","display_name":"Opus 4.8","supports_effort":false,"supported_effort_levels":["low"]}]}}}"#
        );

        let models = parse_claude_code_models(stdout).unwrap();

        assert_eq!(
            models.iter().map(|model| model.id.as_str()).collect::<Vec<_>>(),
            ["default", "claude-sonnet-4-6", "claude-opus-4-8"]
        );
        let sonnet = &models[1];
        assert_eq!(sonnet.display_name.as_deref(), Some("Sonnet 4.6"));
        assert_eq!(
            sonnet.supported_effort_levels,
            [AiEffortLevel::Low, AiEffortLevel::Medium, AiEffortLevel::High, AiEffortLevel::Max]
        );
        let AiEffortCapability::Enum { options, .. } = sonnet.effort_capability.as_ref().unwrap() else {
            panic!("expected effort enum");
        };
        assert_eq!(
            options.iter().map(|option| option.id.as_str()).collect::<Vec<_>>(),
            ["low", "medium", "high", "max", "future"]
        );
    }

    #[test]
    fn adds_default_to_discovered_claude_code_models_when_missing() {
        let stdout = r#"{"type":"control_response","response":{"models":[{"id":"claude-haiku-4-5","displayName":"Haiku 4.5"}]}}"#;

        let models = parse_claude_code_models(stdout).unwrap();

        assert_eq!(models[0].id, "default");
        assert_eq!(models[1].id, "claude-haiku-4-5");
    }

    #[test]
    fn rejects_claude_code_initialize_response_without_models() {
        let stdout = r#"{"type":"control_response","response":{"subtype":"success","response":{"commands":[]}}}"#;

        assert!(parse_claude_code_models(stdout).is_none());
    }

    #[test]
    fn invalid_mcp_config_is_not_reported_as_a_missing_server_package() {
        let error = classify_claude_code_run_error(
            r#"Invalid MCP configuration: MCP config file not found: C:\Temp\{mcpServers:{dbx:{args:[C:\node_modules\@dbx-app\mcp-server\bin\dbx-mcp-server.js]}}}"#,
        );

        assert!(error.starts_with("[claudeCodeMcpConfigInvalid]"));
        assert!(!error.contains("[dbxMcpMissing]"));
    }

    #[test]
    fn invalid_mcp_config_path_containing_auth_is_not_reported_as_authentication_failure() {
        let error = classify_claude_code_run_error(
            r#"Invalid MCP configuration: MCP config file not found: C:\Users\auth-test\AppData\Local\Temp\dbx\mcp.json"#,
        );

        assert!(error.starts_with("[claudeCodeMcpConfigInvalid]"));
        assert!(!error.contains("[claudeCodeNotAuthenticated]"));
    }

    #[test]
    fn normalizes_claude_code_cli_env() {
        let mut config = claude_code_config("default");
        config.claude_code_cli_env.insert(" HTTPS_PROXY ".to_string(), "http://proxy:9800".to_string());
        config.claude_code_cli_env.insert("NO_PROXY".to_string(), "localhost,127.0.0.1".to_string());

        let env = claude_code_cli_env(&config).unwrap();

        assert_eq!(
            env,
            vec![
                ("HTTPS_PROXY".to_string(), "http://proxy:9800".to_string()),
                ("NO_PROXY".to_string(), "localhost,127.0.0.1".to_string())
            ]
        );
    }

    #[test]
    fn rejects_reserved_dbx_mcp_env_name() {
        let mut config = claude_code_config("default");
        config.claude_code_cli_env.insert("DBX_MCP_SCOPE_DATABASE".to_string(), "main".to_string());

        let err = claude_code_cli_env(&config).unwrap_err();

        assert!(err.contains("[claudeCodeEnvReserved]"));
    }

    #[test]
    fn rejects_shell_style_env_prefix_in_claude_code_cli_path() {
        let mut config = claude_code_config("default");
        config.claude_code_cli_path = Some("HTTPS_PROXY=http://proxy:9800 /opt/homebrew/bin/claude".to_string());

        let err = validate_claude_code_program(&config).unwrap_err();

        assert!(err.contains("[claudeCodeCliPathInvalid]"));
        assert!(err.contains("environment variables section"));
    }

    #[test]
    fn resolves_claude_code_executable_from_configured_directory() {
        let dir = std::env::temp_dir().join(format!("dbx-claude-code-dir-test-{}", std::process::id()));
        std::fs::create_dir_all(&dir).unwrap();
        let executable = dir.join(if cfg!(windows) { "claude.cmd" } else { "claude" });
        std::fs::write(&executable, "").unwrap();
        let mut config = claude_code_config("default");
        config.claude_code_cli_path = Some(dir.to_string_lossy().to_string());

        let resolved = validate_claude_code_program(&config).unwrap();

        assert_eq!(resolved, executable.to_string_lossy());
        let _ = std::fs::remove_file(executable);
        let _ = std::fs::remove_dir(dir);
    }

    #[test]
    fn parses_claude_code_jsonl_events() {
        let started = parse_claude_code_jsonl_event(
            r#"{"type":"assistant","message":{"content":[{"type":"tool_use","id":"tool-1","name":"mcp__dbx__dbx_list_tables","input":{"schema":"public"}}]}}"#,
        )
        .unwrap();
        assert!(
            matches!(&started[0], AgentEvent::ToolCallStart { tool_name, args, .. } if tool_name == "mcp__dbx__dbx_list_tables" && args["schema"] == "public")
        );

        let text = parse_claude_code_jsonl_event(
            r#"{"type":"assistant","message":{"content":[{"type":"text","text":"Done"}]}}"#,
        )
        .unwrap();
        assert!(matches!(&text[0], AgentEvent::TextDelta { delta } if delta == "Done"));

        let tool_result = parse_claude_code_jsonl_event(
            r#"{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":[{"type":"text","text":"users"}],"is_error":false}]}}"#,
        )
        .unwrap();
        assert!(
            matches!(&tool_result[0], AgentEvent::ToolCallEnd { tool_call_id, result, is_error, .. } if tool_call_id == "tool-1" && result[0]["text"] == "users" && !is_error)
        );

        let done = parse_claude_code_jsonl_event(
            r#"{"type":"result","subtype":"success","usage":{"input_tokens":12,"output_tokens":3}}"#,
        )
        .unwrap();
        assert!(matches!(&done[0], AgentEvent::AgentEnd { input_tokens: Some(12), output_tokens: Some(3) }));

        let failed = parse_claude_code_jsonl_event(
            r#"{"type":"result","subtype":"error_max_turns","message":"too many turns"}"#,
        )
        .unwrap();
        assert!(matches!(&failed[0], AgentEvent::Error { message } if message == "too many turns"));
    }
}