* feat(ai): add Grok CLI as a Desktop no-API-key provider Add grok-cli alongside Codex/Claude Code/Pi, with path/env settings, isolated MCP-scoped headless runs, model listing, and connection test. * feat(ai): expose Grok CLI reasoning effort like Codex Attach low/medium/high effort capabilities to Grok models for the assistant effort menu, wire resolve_model_effort for grok-cli, and use the monochrome Grok mark icon. * i18n: add Grok CLI error messages for remaining locales Fill grokCli* cliErrors strings in es, it, ja, ko, pt-BR, and zh-TW to match en/zh-CN and satisfy i18n autofill CI. * fix(ai): align Grok CLI headless with official Build flags Address review feedback on PR #5494: - Use streaming-json + CliAgentJsonlDialect::GrokStreamingJson - Switch permission to --always-approve and MCPTool(dbx__*) rules - Prefer --effort over --reasoning-effort; keep --prompt-file Verified with unit tests and a local headless e2e against grok 1.0. * style(ai): fix rustfmt for Grok CLI provider files * test(ai): fix Grok CLI entry in provider ordering spec * fix(ai): harden grok CLI error wording and config schema Add 'not signed in' to classify_grok_run_error and test_grok_connection auth detection — real @xai-official/grok 1.0.0 emits this exact wording on headless auth failure (verified against the shipped binary). Remove invalid config.toml fields: permission_mode='always-approve' (not a valid enum; auto-approve is driven by --always-approve flag) and startup_timeout_sec/tool_timeout_sec/enabled_tools (not mcp_servers schema fields per 'grok mcp add'). --------- Co-authored-by: t8y2 <1156263951@qq.com>
696 lines
29 KiB
Rust
696 lines
29 KiB
Rust
use crate::agent_events::AgentEvent;
|
|
use crate::ai::{
|
|
AiCapabilitySource, AiConfig, AiEffortCapability, AiEffortLevel, AiEffortOption, AiEffortSelection, AiModelInfo,
|
|
AiTestConnectionResult,
|
|
};
|
|
use crate::ai_cli_agent::{
|
|
build_cli_agent_prompt, cli_command, dbx_mcp_enabled_tools, dbx_mcp_scope_env, run_cli_jsonl_agent, toml_string,
|
|
toml_string_array, CliAgentCommandSpec, CliAgentJsonlDialect, CliAgentProcessSpec, CliAgentRunOptions,
|
|
};
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
use std::env;
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::Stdio;
|
|
use std::time::{Duration, Instant};
|
|
use tokio::sync::Notify;
|
|
|
|
const DEFAULT_GROK_MODELS: &[&str] = &["default", "grok-4.5"];
|
|
/// Matches Grok CLI model metadata (`supports_reasoning_effort` + `reasoning_efforts`).
|
|
const DEFAULT_GROK_EFFORTS: &[&str] = &["low", "medium", "high"];
|
|
const DEFAULT_GROK_EFFORT: &str = "high";
|
|
const GROK_MODEL_DISCOVERY_TIMEOUT: Duration = Duration::from_secs(10);
|
|
const DISALLOWED_BUILTIN_TOOLS: &str = "run_terminal_command,read_file,search_replace,list_dir,grep,kill_command_or_subagent,todo_write,get_command_or_subagent_output,spawn_subagent,scheduler_create,scheduler_delete,scheduler_list,monitor,search_tool,use_tool,workflow,enter_plan_mode,exit_plan_mode,ask_user_question,image_gen,image_edit,image_to_video,reference_to_video,write,bash,shell,edit,Glob,Grep";
|
|
|
|
pub type GrokRunOptions = CliAgentRunOptions;
|
|
pub type GrokCommandSpec = CliAgentCommandSpec;
|
|
|
|
struct GrokIsolatedHome {
|
|
path: PathBuf,
|
|
}
|
|
|
|
impl GrokIsolatedHome {
|
|
fn create(options: &GrokRunOptions) -> Result<Self, String> {
|
|
let path = env::temp_dir().join(format!("dbx-grok-cli-{}", uuid::Uuid::new_v4()));
|
|
let grok_dir = path.join(".grok");
|
|
std::fs::create_dir_all(&grok_dir)
|
|
.map_err(|error| format!("[grokCliRunFailed] Failed to create isolated Grok home: {error}"))?;
|
|
|
|
if let Some(auth_source) = real_grok_auth_path() {
|
|
let auth_dest = grok_dir.join("auth.json");
|
|
std::fs::copy(&auth_source, &auth_dest).map_err(|error| {
|
|
format!(
|
|
"[grokCliNotAuthenticated] Failed to copy Grok auth credentials into the isolated home: {error}"
|
|
)
|
|
})?;
|
|
}
|
|
|
|
let config_path = grok_dir.join("config.toml");
|
|
std::fs::write(&config_path, grok_mcp_config_toml(options))
|
|
.map_err(|error| format!("[grokCliRunFailed] Failed to write isolated Grok MCP configuration: {error}"))?;
|
|
|
|
Ok(Self { path })
|
|
}
|
|
|
|
fn write_prompt(&self, prompt: &str) -> Result<PathBuf, String> {
|
|
let path = self.path.join("dbx-prompt.txt");
|
|
std::fs::write(&path, prompt)
|
|
.map_err(|error| format!("[grokCliRunFailed] Failed to write Grok prompt file: {error}"))?;
|
|
Ok(path)
|
|
}
|
|
}
|
|
|
|
impl Drop for GrokIsolatedHome {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::remove_dir_all(&self.path);
|
|
}
|
|
}
|
|
|
|
fn real_grok_home() -> Option<PathBuf> {
|
|
env::var_os("HOME").map(PathBuf::from).map(|home| home.join(".grok")).filter(|path| path.is_dir())
|
|
}
|
|
|
|
fn real_grok_auth_path() -> Option<PathBuf> {
|
|
real_grok_home().map(|home| home.join("auth.json")).filter(|path| path.is_file())
|
|
}
|
|
|
|
fn grok_program(config: &AiConfig) -> String {
|
|
config.grok_cli_path.as_deref().map(str::trim).filter(|path| !path.is_empty()).unwrap_or("grok").to_string()
|
|
}
|
|
|
|
fn grok_process_env(
|
|
config: &AiConfig,
|
|
command: &GrokCommandSpec,
|
|
home: Option<&Path>,
|
|
) -> Result<Vec<(String, String)>, String> {
|
|
let mut env = BTreeMap::from_iter(grok_cli_env(config)?);
|
|
if let Some(home) = home {
|
|
env.insert("HOME".to_string(), home.to_string_lossy().to_string());
|
|
}
|
|
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: &GrokCommandSpec) -> 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"),
|
|
]);
|
|
if let Some(home) = env::var_os("HOME") {
|
|
dirs.push(PathBuf::from(home).join(".grok").join("bin"));
|
|
}
|
|
}
|
|
dirs
|
|
}
|
|
|
|
fn validate_grok_program(config: &AiConfig) -> Result<String, String> {
|
|
let program = grok_program(config);
|
|
if starts_with_env_assignment(&program) {
|
|
return Err("[grokCliPathInvalid] Grok CLI path should contain only the executable path. Add environment variables in the Grok 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, "grok").ok_or_else(|| {
|
|
"[grokCliPathInvalid] Grok CLI path should point to the grok executable or a directory containing grok."
|
|
.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 grok_cli_env(config: &AiConfig) -> Result<Vec<(String, String)>, String> {
|
|
let mut env = BTreeMap::new();
|
|
for (key, value) in &config.grok_cli_env {
|
|
let key = key.trim();
|
|
if key.is_empty() {
|
|
continue;
|
|
}
|
|
if !is_env_var_name(key) {
|
|
return Err(format!(
|
|
"[grokCliEnvInvalid] Invalid Grok CLI environment variable name `{key}`. Use names like HTTPS_PROXY."
|
|
));
|
|
}
|
|
if is_reserved_dbx_mcp_env_name(key) {
|
|
return Err(format!(
|
|
"[grokCliEnvReserved] `{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())
|
|
}
|
|
|
|
/// Grok MCP tool names are `server__tool` (no `mcp__` prefix). Permission rules
|
|
/// must use `MCPTool(server__tool)` form — `mcp__server__tool` never matches.
|
|
fn grok_mcp_permission_rules(options: &GrokRunOptions) -> Vec<String> {
|
|
let mut rules = vec!["MCPTool(dbx__*)".to_string()];
|
|
for tool in dbx_mcp_enabled_tools(options.agent_mode) {
|
|
rules.push(format!("MCPTool(dbx__{tool})"));
|
|
}
|
|
rules
|
|
}
|
|
|
|
fn grok_mcp_config_toml(options: &GrokRunOptions) -> String {
|
|
let mcp_command =
|
|
options.mcp_server_command.as_ref().map(|command| command.program.as_str()).unwrap_or("dbx-mcp-server");
|
|
let permission_rules = grok_mcp_permission_rules(options);
|
|
let permission_rule_refs = permission_rules.iter().map(String::as_str).collect::<Vec<_>>();
|
|
let mut lines = vec![
|
|
"[cli]".to_string(),
|
|
"auto_update = false".to_string(),
|
|
String::new(),
|
|
// Tool auto-approval is driven by the `--always-approve` CLI flag, not a
|
|
// config key: grok's permission_mode enum has no "always-approve" value
|
|
// (valid values: default/acceptEdits/auto/dontAsk/bypassPermissions/plan).
|
|
"[permission]".to_string(),
|
|
format!("allow = {}", toml_string_array(&permission_rule_refs)),
|
|
String::new(),
|
|
// Only command/args/env are part of the documented mcp_servers schema
|
|
// (per `grok mcp add`); startup_timeout_sec/tool_timeout_sec/enabled_tools
|
|
// are not recognized fields and would be silently ignored.
|
|
"[mcp_servers.dbx]".to_string(),
|
|
format!("command = {}", toml_string(mcp_command)),
|
|
];
|
|
if let Some(command) = options.mcp_server_command.as_ref().filter(|command| !command.args.is_empty()) {
|
|
let args = command.args.iter().map(String::as_str).collect::<Vec<_>>();
|
|
lines.push(format!("args = {}", toml_string_array(&args)));
|
|
}
|
|
lines.push(String::new());
|
|
lines.push("[mcp_servers.dbx.env]".to_string());
|
|
for (name, value) in dbx_mcp_scope_env(options) {
|
|
lines.push(format!("{name} = {}", toml_string(&value)));
|
|
}
|
|
lines.push(String::new());
|
|
lines.join("\n")
|
|
}
|
|
|
|
pub fn build_grok_command(config: &AiConfig, prompt_file: &Path, options: &GrokRunOptions) -> GrokCommandSpec {
|
|
// Align with Grok Build headless docs (`--prompt-file`, `streaming-json`,
|
|
// `--always-approve`, `--effort`). Prompt is written to a temp file so long
|
|
// DBX system+conversation prompts stay under OS argv limits.
|
|
let mut args = vec![
|
|
"--prompt-file".to_string(),
|
|
prompt_file.to_string_lossy().to_string(),
|
|
"--output-format".to_string(),
|
|
"streaming-json".to_string(),
|
|
"--always-approve".to_string(),
|
|
"--disable-web-search".to_string(),
|
|
"--no-subagents".to_string(),
|
|
"--no-plan".to_string(),
|
|
"--disallowed-tools".to_string(),
|
|
DISALLOWED_BUILTIN_TOOLS.to_string(),
|
|
"--verbatim".to_string(),
|
|
];
|
|
|
|
// Grok permission rules: `MCPTool(server__tool)`, not Claude-style `mcp__server__tool`.
|
|
for rule in grok_mcp_permission_rules(options) {
|
|
args.push("--allow".to_string());
|
|
args.push(rule);
|
|
}
|
|
|
|
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 =
|
|
config.runtime_effort.as_ref().and_then(|effort| effort.cli_value()).or_else(|| match config.reasoning_level {
|
|
crate::ai::AiReasoningLevel::Default | crate::ai::AiReasoningLevel::Minimal => None,
|
|
crate::ai::AiReasoningLevel::Low => Some("low".to_string()),
|
|
crate::ai::AiReasoningLevel::Medium => Some("medium".to_string()),
|
|
crate::ai::AiReasoningLevel::High => Some("high".to_string()),
|
|
crate::ai::AiReasoningLevel::Xhigh | crate::ai::AiReasoningLevel::Max => Some("high".to_string()),
|
|
});
|
|
if let Some(effort) = effort {
|
|
// `--effort` is the documented alias of `--reasoning-effort`.
|
|
args.push("--effort".to_string());
|
|
args.push(effort);
|
|
}
|
|
|
|
GrokCommandSpec { program: grok_program(config), args }
|
|
}
|
|
|
|
pub fn build_grok_prompt(system_prompt: &str, messages: &[crate::ai::AiMessage], allow_write_sql: bool) -> String {
|
|
build_cli_agent_prompt("Grok", system_prompt, messages, allow_write_sql)
|
|
}
|
|
|
|
fn grok_effort_option(id: &str, label: &str, description: &str) -> AiEffortOption {
|
|
AiEffortOption {
|
|
id: id.to_string(),
|
|
label: label.to_string(),
|
|
description: Some(description.to_string()),
|
|
selection: AiEffortSelection::Enum(id.to_string()),
|
|
}
|
|
}
|
|
|
|
/// Grok CLI reasoning effort levels (same surface as Codex model effort in the assistant).
|
|
pub fn grok_effort_capability() -> AiEffortCapability {
|
|
AiEffortCapability::Enum {
|
|
options: vec![
|
|
grok_effort_option("low", "Low", "Quick, fast implementations"),
|
|
grok_effort_option("medium", "Medium", "Balanced effort with standard implementation and testing"),
|
|
grok_effort_option("high", "High", "Highest implementation quality with extensive reasoning"),
|
|
],
|
|
default: AiEffortSelection::Enum(DEFAULT_GROK_EFFORT.to_string()),
|
|
source: AiCapabilitySource::LocalCli,
|
|
}
|
|
}
|
|
|
|
fn with_grok_effort(mut model: AiModelInfo) -> AiModelInfo {
|
|
model.effort_capability = Some(grok_effort_capability());
|
|
model.supported_effort_levels =
|
|
DEFAULT_GROK_EFFORTS.iter().filter_map(|level| level.parse::<AiEffortLevel>().ok()).collect();
|
|
model
|
|
}
|
|
|
|
fn default_grok_models() -> Vec<AiModelInfo> {
|
|
DEFAULT_GROK_MODELS
|
|
.iter()
|
|
.map(|id| {
|
|
let display = if *id == "default" { Some("Default".to_string()) } else { None };
|
|
with_grok_effort(AiModelInfo::new(*id, display))
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub async fn list_grok_models(config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
|
|
let program = validate_grok_program(config)?;
|
|
Ok(discover_grok_models(config, program).await.unwrap_or_else(default_grok_models))
|
|
}
|
|
|
|
async fn discover_grok_models(config: &AiConfig, program: String) -> Option<Vec<AiModelInfo>> {
|
|
let command = GrokCommandSpec { program, args: vec!["models".to_string()] };
|
|
let env = grok_process_env(config, &command, None).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())))
|
|
.stdin(Stdio::null())
|
|
.stdout(Stdio::piped())
|
|
.stderr(Stdio::piped())
|
|
.kill_on_drop(true);
|
|
let child = process.spawn().ok()?;
|
|
let output = tokio::time::timeout(GROK_MODEL_DISCOVERY_TIMEOUT, child.wait_with_output()).await.ok()?.ok()?;
|
|
if !output.status.success() {
|
|
return None;
|
|
}
|
|
parse_grok_models(&String::from_utf8_lossy(&output.stdout))
|
|
}
|
|
|
|
fn parse_grok_models(stdout: &str) -> Option<Vec<AiModelInfo>> {
|
|
let mut seen = BTreeSet::new();
|
|
let mut models = Vec::new();
|
|
for line in stdout.lines() {
|
|
let trimmed = line.trim();
|
|
let Some(id) = trimmed.strip_prefix('*').map(str::trim).filter(|id| !id.is_empty()) else {
|
|
continue;
|
|
};
|
|
let id = id.split_whitespace().next().unwrap_or(id).trim_matches(|ch| ch == '(' || ch == ')' || ch == ',');
|
|
if id.is_empty() || !seen.insert(id.to_string()) {
|
|
continue;
|
|
}
|
|
models.push(with_grok_effort(AiModelInfo::new(id, None)));
|
|
}
|
|
if models.is_empty() {
|
|
return None;
|
|
}
|
|
if seen.insert("default".to_string()) {
|
|
models.insert(0, with_grok_effort(AiModelInfo::new("default", Some("Default".to_string()))));
|
|
}
|
|
Some(models)
|
|
}
|
|
|
|
pub async fn test_grok_connection(config: &AiConfig) -> Result<AiTestConnectionResult, String> {
|
|
let start = Instant::now();
|
|
let program = validate_grok_program(config)?;
|
|
let command = GrokCommandSpec { program, args: vec!["models".to_string()] };
|
|
let mut process = cli_command(&command.program);
|
|
process.args(command.args.iter().map(String::as_str));
|
|
process.envs(grok_process_env(config, &command, None)?.iter().map(|(key, value)| (key.as_str(), value.as_str())));
|
|
|
|
let output = process.output().await.map_err(|e| classify_grok_spawn_error(&e.to_string()))?;
|
|
let stdout = String::from_utf8_lossy(&output.stdout);
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
let combined =
|
|
[stdout.trim(), stderr.trim()].into_iter().filter(|part| !part.is_empty()).collect::<Vec<_>>().join("\n");
|
|
|
|
if output.status.success() {
|
|
// `grok models` can exit 0 yet print an auth warning; catch the same
|
|
// "Not signed in" wording the headless run emits (see classify_grok_run_error).
|
|
let combined_lower = combined.to_ascii_lowercase();
|
|
if combined_lower.contains("not signed in")
|
|
|| combined_lower.contains("not logged")
|
|
|| combined_lower.contains("not authenticated")
|
|
{
|
|
return Err(classify_grok_run_error(&combined));
|
|
}
|
|
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 {
|
|
Err(classify_grok_run_error(&combined))
|
|
}
|
|
}
|
|
|
|
fn classify_grok_spawn_error(message: &str) -> String {
|
|
if message.contains("No such file") || message.contains("not found") {
|
|
"[grokCliNotInstalled] Grok CLI was not found. Install Grok CLI or set the Grok CLI path in DBX AI settings."
|
|
.to_string()
|
|
} else if is_command_line_too_long_error(message) {
|
|
"[grokCliCommandLineTooLong] Grok CLI command line is too long. Update DBX so Grok prompts are sent through a temporary prompt file."
|
|
.to_string()
|
|
} else {
|
|
format!("[grokCliRunFailed] Failed to start Grok CLI: {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_grok_run_error(stderr: &str) -> String {
|
|
let lower = stderr.to_ascii_lowercase();
|
|
// Grok's real headless auth error is "Not signed in. ... run `grok login` ..."
|
|
// (verified against @xai-official/grok 1.0.0). Older wording used
|
|
// "not authenticated"/"not logged", so cover both for robustness.
|
|
if lower.contains("not signed in")
|
|
|| lower.contains("not authenticated")
|
|
|| lower.contains("not logged")
|
|
|| lower.contains("please login")
|
|
|| lower.contains("login required")
|
|
|| lower.contains("authentication required")
|
|
{
|
|
format!("[grokCliNotAuthenticated] Grok CLI is not authenticated. Run `grok login` and try again. {stderr}")
|
|
} else if lower.contains("dbx-mcp-server") || lower.contains("enoent") {
|
|
format!("[dbxMcpMissing] DBX MCP server was not found. Install @dbx-app/mcp-server and try again. {stderr}")
|
|
} else if lower.contains("mcp") && (lower.contains("dbx") || lower.contains("server")) {
|
|
format!("[grokCliMcpStartupFailed] Grok could not start the DBX MCP server. {stderr}")
|
|
} else {
|
|
format!("[grokCliRunFailed] Grok CLI failed. {stderr}")
|
|
}
|
|
}
|
|
|
|
pub async fn run_grok_agent(
|
|
config: &AiConfig,
|
|
prompt: &str,
|
|
options: GrokRunOptions,
|
|
cancelled: &Notify,
|
|
on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
|
|
) -> Result<String, String> {
|
|
let program = validate_grok_program(config)?;
|
|
let isolated_home = GrokIsolatedHome::create(&options)?;
|
|
let prompt_path = isolated_home.write_prompt(prompt)?;
|
|
let mut command = build_grok_command(config, &prompt_path, &options);
|
|
command.program = program;
|
|
let env = grok_process_env(config, &command, Some(&isolated_home.path))?;
|
|
run_cli_jsonl_agent(
|
|
CliAgentProcessSpec {
|
|
command,
|
|
env,
|
|
env_remove: Vec::new(),
|
|
current_dir: Some(isolated_home.path.clone()),
|
|
stdin: None,
|
|
// Grok headless `streaming-json`: text/thought/tool_call/tool_call_update/end/error.
|
|
dialect: CliAgentJsonlDialect::GrokStreamingJson,
|
|
classify_spawn_error: classify_grok_spawn_error,
|
|
classify_run_error: classify_grok_run_error,
|
|
},
|
|
cancelled,
|
|
on_event,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{
|
|
build_grok_command, classify_grok_run_error, default_grok_models, grok_cli_env, grok_effort_capability,
|
|
grok_mcp_config_toml, parse_grok_models, validate_grok_program, GrokRunOptions,
|
|
};
|
|
use crate::ai::{
|
|
AiApiStyle, AiAuthMethod, AiCapabilitySource, AiConfig, AiEffortCapability, AiEffortLevel, AiEffortSelection,
|
|
AiProvider, AiReasoningLevel,
|
|
};
|
|
use crate::ai_cli_agent::CliAgentCommandSpec;
|
|
use std::path::PathBuf;
|
|
|
|
fn base_config() -> AiConfig {
|
|
AiConfig {
|
|
provider: AiProvider::GrokCli,
|
|
api_key: String::new(),
|
|
auth_method: AiAuthMethod::Bearer,
|
|
endpoint: String::new(),
|
|
model: "default".to_string(),
|
|
models: Vec::new(),
|
|
api_style: AiApiStyle::Completions,
|
|
proxy_enabled: false,
|
|
proxy_url: String::new(),
|
|
enable_thinking: true,
|
|
reasoning_level: AiReasoningLevel::Default,
|
|
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(),
|
|
cursor_cli_path: None,
|
|
cursor_cli_env: Default::default(),
|
|
grok_cli_path: None,
|
|
grok_cli_env: Default::default(),
|
|
}
|
|
}
|
|
|
|
fn run_options() -> GrokRunOptions {
|
|
GrokRunOptions {
|
|
connection_id: "conn-1".to_string(),
|
|
connection_name: "Demo".to_string(),
|
|
database: "app".to_string(),
|
|
schema: None,
|
|
agent_mode: true,
|
|
allow_writes: false,
|
|
allow_dangerous: false,
|
|
confirmed_write_sql: None,
|
|
mcp_server_command: Some(CliAgentCommandSpec {
|
|
program: "dbx-mcp-server".to_string(),
|
|
args: vec!["--stdio".to_string()],
|
|
}),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn validates_path_and_env() {
|
|
let mut config = base_config();
|
|
assert_eq!(validate_grok_program(&config).unwrap(), "grok");
|
|
|
|
config.grok_cli_path = Some("HTTPS_PROXY=http://proxy:1 /usr/bin/grok".to_string());
|
|
assert!(validate_grok_program(&config).unwrap_err().contains("[grokCliPathInvalid]"));
|
|
|
|
config.grok_cli_path = None;
|
|
config.grok_cli_env.insert("HTTPS_PROXY".to_string(), "http://proxy:9800".to_string());
|
|
assert_eq!(grok_cli_env(&config).unwrap(), vec![("HTTPS_PROXY".to_string(), "http://proxy:9800".to_string())]);
|
|
|
|
config.grok_cli_env.insert("DBX_MCP_ALLOW_WRITES".to_string(), "1".to_string());
|
|
assert!(grok_cli_env(&config).unwrap_err().contains("[grokCliEnvReserved]"));
|
|
}
|
|
|
|
#[test]
|
|
fn builds_headless_command_with_prompt_file_and_model() {
|
|
let mut config = base_config();
|
|
config.model = "grok-4.5".to_string();
|
|
let prompt = PathBuf::from("/tmp/dbx-prompt.txt");
|
|
let command = build_grok_command(&config, &prompt, &run_options());
|
|
assert_eq!(command.program, "grok");
|
|
assert!(command.args.windows(2).any(|pair| pair == ["--prompt-file", "/tmp/dbx-prompt.txt"]));
|
|
assert!(command.args.windows(2).any(|pair| pair == ["--output-format", "streaming-json"]));
|
|
assert!(command.args.iter().any(|arg| arg == "--always-approve"));
|
|
assert!(command.args.windows(2).any(|pair| pair == ["--model", "grok-4.5"]));
|
|
assert!(command.args.iter().any(|arg| arg == "--disable-web-search"));
|
|
// Grok permission rule form — not Claude-style mcp__server__tool.
|
|
assert!(command.args.windows(2).any(|pair| pair == ["--allow", "MCPTool(dbx__*)"]));
|
|
assert!(command.args.windows(2).any(|pair| pair == ["--allow", "MCPTool(dbx__dbx_list_tables)"]));
|
|
assert!(!command.args.iter().any(|arg| arg.contains("mcp__dbx__")));
|
|
}
|
|
|
|
#[test]
|
|
fn builds_effort_flag_from_runtime_effort() {
|
|
let mut config = base_config();
|
|
config.model = "grok-4.5".to_string();
|
|
config.runtime_effort = Some(AiEffortSelection::Enum("medium".to_string()));
|
|
let prompt = PathBuf::from("/tmp/dbx-prompt.txt");
|
|
let command = build_grok_command(&config, &prompt, &run_options());
|
|
assert!(command.args.windows(2).any(|pair| pair == ["--effort", "medium"]));
|
|
}
|
|
|
|
#[test]
|
|
fn models_expose_low_medium_high_effort_like_codex() {
|
|
let capability = grok_effort_capability();
|
|
let AiEffortCapability::Enum { options, default, source } = capability else {
|
|
panic!("expected enum effort capability");
|
|
};
|
|
assert_eq!(source, AiCapabilitySource::LocalCli);
|
|
assert_eq!(default, AiEffortSelection::Enum("high".to_string()));
|
|
assert_eq!(options.iter().map(|option| option.id.as_str()).collect::<Vec<_>>(), vec!["low", "medium", "high"]);
|
|
|
|
let stdout = "You are logged in with grok.com.\n\nDefault model: grok-4.5\n\nAvailable models:\n * grok-4.5 (default)\n";
|
|
let models = parse_grok_models(stdout).unwrap();
|
|
let grok = models.iter().find(|model| model.id == "grok-4.5").unwrap();
|
|
assert!(matches!(grok.effort_capability, Some(AiEffortCapability::Enum { .. })));
|
|
assert_eq!(grok.supported_effort_levels, vec![AiEffortLevel::Low, AiEffortLevel::Medium, AiEffortLevel::High]);
|
|
}
|
|
|
|
#[test]
|
|
fn mcp_config_includes_scoped_dbx_server() {
|
|
let toml = grok_mcp_config_toml(&run_options());
|
|
assert!(toml.contains("[mcp_servers.dbx]"));
|
|
assert!(toml.contains("command = \"dbx-mcp-server\""));
|
|
assert!(toml.contains("args = [\"--stdio\"]"));
|
|
assert!(toml.contains("DBX_MCP_SCOPE_CONNECTION_ID = \"conn-1\""));
|
|
assert!(toml.contains("DBX_MCP_ALLOW_WRITES = \"0\""));
|
|
assert!(toml.contains("[permission]"));
|
|
assert!(toml.contains("MCPTool(dbx__*)"));
|
|
// Invalid fields removed: grok has no "always-approve" permission_mode,
|
|
// and startup_timeout_sec/tool_timeout_sec/enabled_tools are not mcp_servers keys.
|
|
assert!(!toml.contains("permission_mode"));
|
|
assert!(!toml.contains("always-approve"));
|
|
assert!(!toml.contains("startup_timeout_sec"));
|
|
assert!(!toml.contains("tool_timeout_sec"));
|
|
assert!(!toml.contains("enabled_tools"));
|
|
}
|
|
|
|
#[test]
|
|
fn parses_models_listing() {
|
|
let stdout = "You are logged in with grok.com.\n\nDefault model: grok-4.5\n\nAvailable models:\n * grok-4.5 (default)\n * grok-4\n";
|
|
let models = parse_grok_models(stdout).unwrap();
|
|
assert_eq!(models[0].id, "default");
|
|
assert!(models.iter().any(|model| model.id == "grok-4.5"));
|
|
assert!(models.iter().any(|model| model.id == "grok-4"));
|
|
assert_eq!(default_grok_models()[1].id, "grok-4.5");
|
|
}
|
|
|
|
#[test]
|
|
fn classifies_auth_errors() {
|
|
let err = classify_grok_run_error("not authenticated; please login");
|
|
assert!(err.contains("[grokCliNotAuthenticated]"));
|
|
|
|
// Real @xai-official/grok 1.0.0 headless auth failure emits this exact wording.
|
|
let real = classify_grok_run_error(
|
|
"Not signed in. To authenticate without a browser, run:\n grok login --device-code",
|
|
);
|
|
assert!(real.contains("[grokCliNotAuthenticated]"));
|
|
}
|
|
}
|