1382 lines
46 KiB
Rust
1382 lines
46 KiB
Rust
use crate::db::{log_event, pool};
|
||
use rusqlite::params;
|
||
use serde::{Deserialize, Serialize};
|
||
use serde_json::{Map, Value};
|
||
use std::collections::HashMap;
|
||
use std::path::{Path, PathBuf};
|
||
use tauri_plugin_autostart::ManagerExt;
|
||
|
||
const CORE_AGENT_TOOLS: &[&str] = &[
|
||
"get_diagnostics",
|
||
"get_delivery_status",
|
||
"get_toolchain_status",
|
||
"verify_onboarding",
|
||
];
|
||
|
||
/// 全局 key（不按空间隔离，属于整个应用/机器级别配置）
|
||
const GLOBAL_KEYS: &[&str] = &[
|
||
"wsl_distro", // 机器级别，与空间无关
|
||
"wsl_open_mode", // WSL 编辑器启动方式
|
||
"editors",
|
||
"active_editors",
|
||
"active_editor",
|
||
"v2rayn_db_path", // v2rayN 数据库路径
|
||
"v2raya_username", // v2rayA 登录用户名
|
||
"v2raya_password", // v2rayA 登录密码
|
||
"mcp_port", // MCP Server 监听端口（全局，与空间无关）
|
||
];
|
||
|
||
/// 获取 settings：
|
||
/// - 有 space_id：返回该空间的 space_settings + 全局 key（GLOBAL_KEYS）
|
||
/// - 无 space_id：返回全局 settings 表
|
||
#[tauri::command]
|
||
pub fn get_settings(space_id: Option<String>) -> Result<HashMap<String, String>, String> {
|
||
let conn = pool().get().map_err(|e| e.to_string())?;
|
||
|
||
if let Some(ref sid) = space_id {
|
||
// 1. 只读当前空间的 space_settings
|
||
let mut map: HashMap<String, String> = {
|
||
let mut stmt = conn
|
||
.prepare("SELECT key, value FROM space_settings WHERE space_id = ?1")
|
||
.map_err(|e| e.to_string())?;
|
||
let x = stmt
|
||
.query_map(params![sid], |row| {
|
||
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
|
||
})
|
||
.map_err(|e| e.to_string())?
|
||
.collect::<Result<HashMap<_, _>, _>>()
|
||
.map_err(|e| e.to_string())?;
|
||
x
|
||
};
|
||
// 2. 补充全局 key（应用级，非空间相关）
|
||
for key in GLOBAL_KEYS {
|
||
if let Ok(val) = conn.query_row(
|
||
"SELECT value FROM settings WHERE key = ?1",
|
||
params![key],
|
||
|row| row.get::<_, String>(0),
|
||
) {
|
||
map.insert(key.to_string(), val);
|
||
}
|
||
}
|
||
Ok(map)
|
||
} else {
|
||
// 无空间上下文：返回全局表（应用设置弹窗使用）
|
||
let mut stmt = conn
|
||
.prepare("SELECT key, value FROM settings")
|
||
.map_err(|e| e.to_string())?;
|
||
let map = stmt
|
||
.query_map([], |row| {
|
||
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
|
||
})
|
||
.map_err(|e| e.to_string())?
|
||
.collect::<Result<HashMap<_, _>, _>>()
|
||
.map_err(|e| e.to_string())?;
|
||
Ok(map)
|
||
}
|
||
}
|
||
|
||
/// 更新 settings：全局 key 写入 settings 表；其余写入 space_settings 表
|
||
#[tauri::command]
|
||
pub fn update_settings(
|
||
settings: HashMap<String, String>,
|
||
space_id: Option<String>,
|
||
) -> Result<(), String> {
|
||
let conn = pool().get().map_err(|e| e.to_string())?;
|
||
let mut mcp_port_changed = false;
|
||
for (k, v) in &settings {
|
||
if k == "mcp_port" {
|
||
mcp_port_changed = true;
|
||
}
|
||
if GLOBAL_KEYS.contains(&k.as_str()) || space_id.is_none() {
|
||
conn.execute(
|
||
"INSERT OR REPLACE INTO settings (key, value) VALUES (?1, ?2)",
|
||
params![k, v],
|
||
)
|
||
.map_err(|e| e.to_string())?;
|
||
} else {
|
||
conn.execute(
|
||
"INSERT OR REPLACE INTO space_settings (space_id, key, value) VALUES (?1, ?2, ?3)",
|
||
params![space_id, k, v],
|
||
)
|
||
.map_err(|e| e.to_string())?;
|
||
}
|
||
}
|
||
// 端口变更后重新注入所有产品组成员的 MCP 配置
|
||
if mcp_port_changed {
|
||
let errors = crate::mcp_inject::reinject_all_mcp();
|
||
for e in &errors {
|
||
log_event(
|
||
"mcp_inject",
|
||
"error",
|
||
&format!("端口变更重注入失败: {e}"),
|
||
None,
|
||
);
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// 检测系统中已安装的常见编辑器，返回 [{name, cmd, path, found}]
|
||
#[tauri::command]
|
||
pub fn detect_editors() -> Result<Vec<Value>, String> {
|
||
// (显示名, 命令名, 常见安装路径列表)
|
||
let candidates: &[(&str, &str, &[&str])] = &[
|
||
(
|
||
"Cursor",
|
||
"cursor",
|
||
&[
|
||
r"%LOCALAPPDATA%\Programs\cursor\Cursor.exe",
|
||
r"%USERPROFILE%\AppData\Local\Programs\cursor\Cursor.exe",
|
||
],
|
||
),
|
||
(
|
||
"VS Code",
|
||
"code",
|
||
&[
|
||
r"%LOCALAPPDATA%\Programs\Microsoft VS Code\Code.exe",
|
||
r"C:\Program Files\Microsoft VS Code\Code.exe",
|
||
],
|
||
),
|
||
(
|
||
"VS Code Insiders",
|
||
"code-insiders",
|
||
&[r"%LOCALAPPDATA%\Programs\Microsoft VS Code Insiders\Code - Insiders.exe"],
|
||
),
|
||
(
|
||
"Windsurf",
|
||
"windsurf",
|
||
&[r"%LOCALAPPDATA%\Programs\windsurf\Windsurf.exe"],
|
||
),
|
||
];
|
||
|
||
let mut results = Vec::new();
|
||
|
||
for (name, cmd, fallback_paths) in candidates {
|
||
// 先用 where 命令查 PATH
|
||
let where_out = crate::silent_cmd("cmd")
|
||
.args(["/c", &format!("where {cmd} 2>nul")])
|
||
.output()
|
||
.ok();
|
||
|
||
let path_from_where = where_out
|
||
.as_ref()
|
||
.filter(|o| o.status.success())
|
||
.and_then(|o| String::from_utf8(o.stdout.clone()).ok())
|
||
.and_then(|s| s.lines().next().map(|l| l.trim().to_string()))
|
||
.filter(|s| !s.is_empty());
|
||
|
||
// 如果 where 找不到，尝试常见安装路径（展开 %LOCALAPPDATA% 等）
|
||
let resolved_path = path_from_where.or_else(|| {
|
||
for &p in *fallback_paths {
|
||
let expanded = expand_env(p);
|
||
if std::path::Path::new(&expanded).exists() {
|
||
return Some(expanded);
|
||
}
|
||
}
|
||
None
|
||
});
|
||
|
||
let found = resolved_path.is_some();
|
||
let mut obj = Map::new();
|
||
obj.insert("name".into(), Value::String(name.to_string()));
|
||
obj.insert("cmd".into(), Value::String(cmd.to_string()));
|
||
obj.insert(
|
||
"path".into(),
|
||
match &resolved_path {
|
||
Some(p) => Value::String(p.clone()),
|
||
None => Value::Null,
|
||
},
|
||
);
|
||
obj.insert("found".into(), Value::Bool(found));
|
||
results.push(Value::Object(obj));
|
||
}
|
||
|
||
Ok(results)
|
||
}
|
||
|
||
/// 搜索指定命令名对应的可执行路径
|
||
#[tauri::command]
|
||
pub fn search_editor_path(cmd: String) -> Result<Option<String>, String> {
|
||
// 先 where
|
||
let where_out = crate::silent_cmd("cmd")
|
||
.args(["/c", &format!("where {cmd} 2>nul")])
|
||
.output()
|
||
.map_err(|e| e.to_string())?;
|
||
|
||
if where_out.status.success() {
|
||
if let Ok(s) = String::from_utf8(where_out.stdout) {
|
||
if let Some(line) = s.lines().next() {
|
||
let p = line.trim().to_string();
|
||
if !p.is_empty() {
|
||
return Ok(Some(p));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 再搜 Program Files / LocalAppData
|
||
let search_dirs = [
|
||
std::env::var("LOCALAPPDATA").unwrap_or_default(),
|
||
std::env::var("PROGRAMFILES").unwrap_or_default(),
|
||
std::env::var("PROGRAMFILES(X86)").unwrap_or_default(),
|
||
];
|
||
|
||
let extensions = ["exe", "cmd"];
|
||
for dir in &search_dirs {
|
||
if dir.is_empty() {
|
||
continue;
|
||
}
|
||
for ext in &extensions {
|
||
let candidate = format!("{dir}\\{cmd}.{ext}");
|
||
if std::path::Path::new(&candidate).exists() {
|
||
return Ok(Some(candidate));
|
||
}
|
||
// 一层子目录
|
||
if let Ok(entries) = std::fs::read_dir(dir) {
|
||
for entry in entries.flatten() {
|
||
let sub = entry.path().join(format!("{cmd}.{ext}"));
|
||
if sub.exists() {
|
||
return Ok(Some(sub.to_string_lossy().into_owned()));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Ok(None)
|
||
}
|
||
|
||
/// 检测 MCP Server 是否真正在监听（实际 HTTP ping）
|
||
#[tauri::command]
|
||
pub fn check_mcp_health() -> Result<serde_json::Value, String> {
|
||
let port = crate::mcp_server::read_port();
|
||
let url = crate::mcp_server::mcp_health_url(port);
|
||
let start = std::time::Instant::now();
|
||
match ureq::builder()
|
||
.timeout(std::time::Duration::from_secs(2))
|
||
.build()
|
||
.get(&url)
|
||
.call()
|
||
{
|
||
Ok(_) => {
|
||
let latency_ms = start.elapsed().as_millis() as u64;
|
||
Ok(serde_json::json!({ "ok": true, "latency_ms": latency_ms, "port": port }))
|
||
}
|
||
Err(e) => Ok(serde_json::json!({ "ok": false, "error": e.to_string(), "port": port })),
|
||
}
|
||
}
|
||
|
||
// ── Agent runtime readiness ──────────────────────────────────────────────────
|
||
|
||
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
|
||
#[serde(rename_all = "snake_case")]
|
||
pub enum AgentRuntimeState {
|
||
Ready,
|
||
Missing,
|
||
Unavailable,
|
||
ProtocolError,
|
||
}
|
||
|
||
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
|
||
pub struct AgentRuntimeLayer {
|
||
pub state: AgentRuntimeState,
|
||
pub detail: String,
|
||
#[serde(skip_serializing_if = "Option::is_none")]
|
||
pub required: Option<bool>,
|
||
}
|
||
|
||
impl AgentRuntimeLayer {
|
||
fn new(state: AgentRuntimeState, detail: impl Into<String>) -> Self {
|
||
Self {
|
||
state,
|
||
detail: detail.into(),
|
||
required: None,
|
||
}
|
||
}
|
||
|
||
fn reload(required: bool, detail: impl Into<String>) -> Self {
|
||
Self {
|
||
state: if required {
|
||
AgentRuntimeState::Missing
|
||
} else {
|
||
AgentRuntimeState::Ready
|
||
},
|
||
detail: detail.into(),
|
||
required: Some(required),
|
||
}
|
||
}
|
||
|
||
fn is_ready(&self) -> bool {
|
||
self.state == AgentRuntimeState::Ready
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
|
||
pub struct AgentRuntimeStatus {
|
||
pub project_id: String,
|
||
pub ready: bool,
|
||
pub configured: AgentRuntimeLayer,
|
||
pub reachable: AgentRuntimeLayer,
|
||
pub handshake: AgentRuntimeLayer,
|
||
pub tools_ready: AgentRuntimeLayer,
|
||
pub reload_required: AgentRuntimeLayer,
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct AgentRuntimeEvidence {
|
||
configured: AgentRuntimeLayer,
|
||
reachable: Result<String, String>,
|
||
handshake: Result<(), String>,
|
||
tool_names: Result<Vec<String>, String>,
|
||
reload_required: bool,
|
||
}
|
||
|
||
fn build_agent_runtime_status(
|
||
project_id: &str,
|
||
evidence: AgentRuntimeEvidence,
|
||
) -> AgentRuntimeStatus {
|
||
let reachable = match evidence.reachable {
|
||
Ok(detail) => AgentRuntimeLayer::new(AgentRuntimeState::Ready, detail),
|
||
Err(detail) => AgentRuntimeLayer::new(AgentRuntimeState::Unavailable, detail),
|
||
};
|
||
let handshake = if !reachable.is_ready() {
|
||
AgentRuntimeLayer::new(
|
||
AgentRuntimeState::Unavailable,
|
||
"MCP 端口不可达，尚未执行 initialize；请先启动或重启炼境",
|
||
)
|
||
} else {
|
||
match evidence.handshake {
|
||
Ok(()) => AgentRuntimeLayer::new(AgentRuntimeState::Ready, "MCP initialize 握手成功"),
|
||
Err(detail) => AgentRuntimeLayer::new(AgentRuntimeState::ProtocolError, detail),
|
||
}
|
||
};
|
||
let tools_ready = if !handshake.is_ready() {
|
||
AgentRuntimeLayer::new(
|
||
AgentRuntimeState::Unavailable,
|
||
"initialize 未就绪，尚未读取 tools/list",
|
||
)
|
||
} else {
|
||
match evidence.tool_names {
|
||
Ok(names) => {
|
||
let missing = CORE_AGENT_TOOLS
|
||
.iter()
|
||
.filter(|required| !names.iter().any(|name| name == **required))
|
||
.copied()
|
||
.collect::<Vec<_>>();
|
||
if missing.is_empty() {
|
||
AgentRuntimeLayer::new(
|
||
AgentRuntimeState::Ready,
|
||
format!("核心工具已就绪：{}", CORE_AGENT_TOOLS.join(", ")),
|
||
)
|
||
} else {
|
||
AgentRuntimeLayer::new(
|
||
AgentRuntimeState::Missing,
|
||
format!(
|
||
"MCP 可握手，但缺少核心工具：{}；请升级或重启炼境",
|
||
missing.join(", ")
|
||
),
|
||
)
|
||
}
|
||
}
|
||
Err(detail) => AgentRuntimeLayer::new(AgentRuntimeState::ProtocolError, detail),
|
||
}
|
||
};
|
||
let reload_required = AgentRuntimeLayer::reload(
|
||
evidence.reload_required,
|
||
if evidence.reload_required {
|
||
"项目 MCP 配置已变化；请新建 Codex 任务或重载客户端后再验证工具可见性"
|
||
} else {
|
||
"服务端已可接受新连接；若当前任务仍看不到工具，请新建任务或重载客户端"
|
||
},
|
||
);
|
||
let ready = evidence.configured.is_ready()
|
||
&& reachable.is_ready()
|
||
&& handshake.is_ready()
|
||
&& tools_ready.is_ready()
|
||
&& !evidence.reload_required;
|
||
|
||
AgentRuntimeStatus {
|
||
project_id: project_id.to_string(),
|
||
ready,
|
||
configured: evidence.configured,
|
||
reachable,
|
||
handshake,
|
||
tools_ready,
|
||
reload_required,
|
||
}
|
||
}
|
||
|
||
fn resolve_project_root(conn: &rusqlite::Connection, project_id: &str) -> Result<PathBuf, String> {
|
||
if project_id.trim().is_empty() {
|
||
return Err("project_id 不能为空".to_string());
|
||
}
|
||
let win_path: Option<String> = conn
|
||
.query_row(
|
||
"SELECT win_path FROM project_workspaces WHERE id = ?1",
|
||
params![project_id],
|
||
|row| row.get(0),
|
||
)
|
||
.map_err(|_| format!("项目 {project_id} 不存在"))?;
|
||
let configured =
|
||
win_path.ok_or_else(|| format!("项目 {project_id} 未配置 Windows 本地路径"))?;
|
||
let root = PathBuf::from(&configured);
|
||
if !root.is_absolute() || !root.is_dir() {
|
||
return Err(format!("项目 Windows 路径不可访问：{configured}"));
|
||
}
|
||
Ok(root)
|
||
}
|
||
|
||
fn configured_layer(root: &Path) -> AgentRuntimeLayer {
|
||
let config = std::fs::read_to_string(root.join(".codex/config.toml")).ok();
|
||
let project_id = std::fs::read_to_string(root.join(".lian-jing/context.json"))
|
||
.ok()
|
||
.and_then(|content| serde_json::from_str::<Value>(&content).ok())
|
||
.and_then(|value| {
|
||
value
|
||
.get("project_id")
|
||
.and_then(Value::as_str)
|
||
.map(str::to_string)
|
||
})
|
||
.unwrap_or_default();
|
||
let check = crate::commands::onboarding::check_codex_mcp(
|
||
config.as_deref(),
|
||
&project_id,
|
||
crate::mcp_server::read_port(),
|
||
);
|
||
AgentRuntimeLayer::new(
|
||
if check.state == crate::commands::onboarding::VerifyState::Ready {
|
||
AgentRuntimeState::Ready
|
||
} else {
|
||
AgentRuntimeState::Missing
|
||
},
|
||
check.detail,
|
||
)
|
||
}
|
||
|
||
fn parse_rpc_result(response: ureq::Response, operation: &str) -> Result<Value, String> {
|
||
let body: Value = response
|
||
.into_json()
|
||
.map_err(|error| format!("{operation} 返回非 JSON：{error}"))?;
|
||
if let Some(error) = body.get("error") {
|
||
return Err(format!("{operation} 返回 JSON-RPC error：{error}"));
|
||
}
|
||
body.get("result")
|
||
.cloned()
|
||
.ok_or_else(|| format!("{operation} 响应缺少 result"))
|
||
}
|
||
|
||
fn collect_runtime_evidence(
|
||
project_id: &str,
|
||
configured: AgentRuntimeLayer,
|
||
) -> AgentRuntimeEvidence {
|
||
let port = crate::mcp_server::read_port();
|
||
let health_url = crate::mcp_server::mcp_health_url(port);
|
||
let rpc_url = crate::mcp_server::scoped_mcp_url(port, project_id);
|
||
let agent = ureq::builder()
|
||
.timeout(std::time::Duration::from_secs(2))
|
||
.build();
|
||
let reachable = agent
|
||
.get(&health_url)
|
||
.call()
|
||
.map(|_| format!("MCP loopback {health_url} 可达"))
|
||
.map_err(|error| format!("MCP loopback {health_url} 不可达：{error}"));
|
||
|
||
if reachable.is_err() {
|
||
return AgentRuntimeEvidence {
|
||
configured,
|
||
reachable,
|
||
handshake: Err("未执行 initialize".to_string()),
|
||
tool_names: Err("未执行 tools/list".to_string()),
|
||
reload_required: false,
|
||
};
|
||
}
|
||
|
||
let initialize = agent
|
||
.post(&rpc_url)
|
||
.send_json(serde_json::json!({
|
||
"jsonrpc": "2.0",
|
||
"id": 1,
|
||
"method": "initialize",
|
||
"params": {
|
||
"protocolVersion": "2024-11-05",
|
||
"capabilities": {},
|
||
"clientInfo": { "name": "lian-jing-readiness", "version": env!("CARGO_PKG_VERSION") }
|
||
}
|
||
}))
|
||
.map_err(|error| format!("MCP initialize 请求失败：{error}"))
|
||
.and_then(|response| parse_rpc_result(response, "MCP initialize"))
|
||
.and_then(|result| {
|
||
if result.get("serverInfo").and_then(|value| value.get("name")).is_some() {
|
||
Ok(())
|
||
} else {
|
||
Err("MCP initialize 响应缺少 serverInfo.name".to_string())
|
||
}
|
||
});
|
||
|
||
if initialize.is_err() {
|
||
return AgentRuntimeEvidence {
|
||
configured,
|
||
reachable,
|
||
handshake: initialize,
|
||
tool_names: Err("initialize 失败，未执行 tools/list".to_string()),
|
||
reload_required: false,
|
||
};
|
||
}
|
||
|
||
let tool_names = agent
|
||
.post(&rpc_url)
|
||
.send_json(serde_json::json!({
|
||
"jsonrpc": "2.0",
|
||
"id": 2,
|
||
"method": "tools/list",
|
||
"params": {}
|
||
}))
|
||
.map_err(|error| format!("MCP tools/list 请求失败：{error}"))
|
||
.and_then(|response| parse_rpc_result(response, "MCP tools/list"))
|
||
.and_then(|result| {
|
||
result
|
||
.get("tools")
|
||
.and_then(Value::as_array)
|
||
.ok_or_else(|| "MCP tools/list 响应缺少 tools 数组".to_string())
|
||
.map(|tools| {
|
||
tools
|
||
.iter()
|
||
.filter_map(|tool| tool.get("name").and_then(Value::as_str))
|
||
.map(str::to_string)
|
||
.collect()
|
||
})
|
||
});
|
||
|
||
AgentRuntimeEvidence {
|
||
configured,
|
||
reachable,
|
||
handshake: initialize,
|
||
tool_names,
|
||
reload_required: !crate::mcp_server::has_initialized_project_client(project_id),
|
||
}
|
||
}
|
||
|
||
/// MCP 内部调用 verify_onboarding 时，以当前成功连接作为运行态证据，避免 HTTP 自调用。
|
||
pub(crate) fn server_observed_runtime_status(project_id: &str, root: &Path) -> AgentRuntimeStatus {
|
||
let names = crate::mcp_tools::tools_list_result()
|
||
.get("tools")
|
||
.and_then(Value::as_array)
|
||
.map(|tools| {
|
||
tools
|
||
.iter()
|
||
.filter_map(|tool| tool.get("name").and_then(Value::as_str))
|
||
.map(str::to_string)
|
||
.collect::<Vec<_>>()
|
||
})
|
||
.ok_or_else(|| "内部 tools/list 缺少 tools 数组".to_string());
|
||
|
||
build_agent_runtime_status(
|
||
project_id,
|
||
AgentRuntimeEvidence {
|
||
configured: configured_layer(root),
|
||
reachable: Ok("当前 MCP 请求已到达 loopback listener".to_string()),
|
||
handshake: Ok(()),
|
||
tool_names: names,
|
||
reload_required: false,
|
||
},
|
||
)
|
||
}
|
||
|
||
/// 独立于 MCP 工具目录的运行态自检；即使 MCP 不可达，Tauri UI 仍可给出分层证据。
|
||
#[tauri::command]
|
||
pub fn get_agent_runtime_status(project_id: String) -> Result<AgentRuntimeStatus, String> {
|
||
let conn = pool().get().map_err(|error| error.to_string())?;
|
||
let root = resolve_project_root(&conn, &project_id)?;
|
||
let configured = configured_layer(&root);
|
||
Ok(build_agent_runtime_status(
|
||
&project_id,
|
||
collect_runtime_evidence(&project_id, configured),
|
||
))
|
||
}
|
||
|
||
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
|
||
pub struct AgentAutostartStatus {
|
||
pub supported: bool,
|
||
pub eligible: bool,
|
||
pub enabled: bool,
|
||
pub build_kind: String,
|
||
pub executable: String,
|
||
pub detail: String,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
enum AutostartAction {
|
||
RefuseEnable,
|
||
Noop,
|
||
Enable,
|
||
Disable,
|
||
}
|
||
|
||
fn plan_autostart_action(eligible: bool, current: bool, requested: bool) -> AutostartAction {
|
||
if !eligible && requested {
|
||
return AutostartAction::RefuseEnable;
|
||
}
|
||
if !eligible || current == requested {
|
||
return AutostartAction::Noop;
|
||
}
|
||
if requested {
|
||
AutostartAction::Enable
|
||
} else {
|
||
AutostartAction::Disable
|
||
}
|
||
}
|
||
|
||
fn autostart_eligibility(is_debug: bool, executable: &Path) -> (bool, String, String) {
|
||
let executable_text = executable.to_string_lossy().to_string();
|
||
if !cfg!(target_os = "windows") {
|
||
return (
|
||
false,
|
||
"unsupported".to_string(),
|
||
"当前仅支持 Windows 正式安装版".to_string(),
|
||
);
|
||
}
|
||
if is_debug {
|
||
return (
|
||
false,
|
||
"debug".to_string(),
|
||
"debug 构建拒绝启用登录自启动；请安装正式版后操作".to_string(),
|
||
);
|
||
}
|
||
let components = executable
|
||
.components()
|
||
.map(|component| component.as_os_str().to_string_lossy().to_ascii_lowercase())
|
||
.collect::<Vec<_>>();
|
||
let executable_name = format!("{}.exe", env!("CARGO_PKG_NAME"));
|
||
let expected_executable = executable
|
||
.file_name()
|
||
.and_then(|name| name.to_str())
|
||
.map(|name| name.eq_ignore_ascii_case(&executable_name))
|
||
.unwrap_or(false);
|
||
let has_product_directory = components
|
||
.iter()
|
||
.take(components.len().saturating_sub(1))
|
||
.any(|component| component == env!("CARGO_PKG_NAME"));
|
||
let under_program_files = components
|
||
.iter()
|
||
.any(|component| matches!(component.as_str(), "program files" | "program files (x86)"));
|
||
let under_local_app_data = components
|
||
.windows(2)
|
||
.any(|parts| parts == ["appdata", "local"]);
|
||
let installed_location = has_product_directory && (under_program_files || under_local_app_data);
|
||
if !expected_executable || !installed_location {
|
||
return (
|
||
false,
|
||
"release_uninstalled".to_string(),
|
||
"release 构建尚未通过正式安装器安装，拒绝注册登录自启动".to_string(),
|
||
);
|
||
}
|
||
(
|
||
true,
|
||
"installed_release".to_string(),
|
||
format!("正式安装版可注册当前 executable：{executable_text}"),
|
||
)
|
||
}
|
||
|
||
fn current_autostart_eligibility() -> Result<(bool, String, String, String), String> {
|
||
let executable = std::env::current_exe().map_err(|error| error.to_string())?;
|
||
let executable_text = executable.to_string_lossy().to_string();
|
||
let (eligible, build_kind, detail) = autostart_eligibility(cfg!(debug_assertions), &executable);
|
||
Ok((eligible, build_kind, executable_text, detail))
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn get_agent_autostart_status(app: tauri::AppHandle) -> Result<AgentAutostartStatus, String> {
|
||
let (eligible, build_kind, executable, detail) = current_autostart_eligibility()?;
|
||
let enabled = if eligible {
|
||
app.autolaunch()
|
||
.is_enabled()
|
||
.map_err(|error| error.to_string())?
|
||
} else {
|
||
false
|
||
};
|
||
Ok(AgentAutostartStatus {
|
||
supported: cfg!(target_os = "windows"),
|
||
eligible,
|
||
enabled,
|
||
build_kind,
|
||
executable,
|
||
detail,
|
||
})
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn set_agent_autostart(
|
||
app: tauri::AppHandle,
|
||
enabled: bool,
|
||
) -> Result<AgentAutostartStatus, String> {
|
||
let before = get_agent_autostart_status(app.clone())?;
|
||
match plan_autostart_action(before.eligible, before.enabled, enabled) {
|
||
AutostartAction::RefuseEnable => return Err(before.detail),
|
||
AutostartAction::Noop => return Ok(before),
|
||
AutostartAction::Enable => {
|
||
app.autolaunch()
|
||
.enable()
|
||
.map_err(|error| error.to_string())?;
|
||
}
|
||
AutostartAction::Disable => {
|
||
app.autolaunch()
|
||
.disable()
|
||
.map_err(|error| error.to_string())?;
|
||
}
|
||
}
|
||
get_agent_autostart_status(app)
|
||
}
|
||
|
||
// ── 健康检查 ──────────────────────────────────────────────────────────────────
|
||
|
||
#[derive(Debug, Serialize, Deserialize)]
|
||
pub struct HealthItem {
|
||
pub id: String,
|
||
pub name: String,
|
||
/// "ok" | "warn" | "error" | "skip"
|
||
pub status: String,
|
||
pub detail: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Serialize)]
|
||
pub struct HealthReport {
|
||
pub checked_at: String,
|
||
pub items: Vec<HealthItem>,
|
||
pub quality: QualityMetrics,
|
||
}
|
||
|
||
fn err_item(id: &str, name: &str, detail: &str) -> HealthItem {
|
||
HealthItem {
|
||
id: id.into(),
|
||
name: name.into(),
|
||
status: "error".into(),
|
||
detail: Some(detail.into()),
|
||
}
|
||
}
|
||
|
||
fn skip_item(id: &str, name: &str, detail: &str) -> HealthItem {
|
||
HealthItem {
|
||
id: id.into(),
|
||
name: name.into(),
|
||
status: "skip".into(),
|
||
detail: Some(detail.into()),
|
||
}
|
||
}
|
||
|
||
/// 检测 MCP Server 是否响应
|
||
fn check_mcp() -> HealthItem {
|
||
let port = crate::mcp_server::read_port();
|
||
let url = crate::mcp_server::mcp_health_url(port);
|
||
let start = std::time::Instant::now();
|
||
match ureq::builder()
|
||
.timeout(std::time::Duration::from_secs(5))
|
||
.build()
|
||
.get(&url)
|
||
.call()
|
||
{
|
||
Ok(_) => HealthItem {
|
||
id: "mcp".into(),
|
||
name: "MCP Server".into(),
|
||
status: "ok".into(),
|
||
detail: Some(format!(
|
||
"端口 {} 响应正常，延迟 {}ms",
|
||
port,
|
||
start.elapsed().as_millis()
|
||
)),
|
||
},
|
||
Err(e) => HealthItem {
|
||
id: "mcp".into(),
|
||
name: "MCP Server".into(),
|
||
status: "error".into(),
|
||
detail: Some(format!("端口 {} 无响应: {}", port, e)),
|
||
},
|
||
}
|
||
}
|
||
|
||
/// 检测已注册仓库的本地 .git 目录是否存在（仅检测关联了 git_repos 的 workspace）
|
||
fn check_git_paths() -> HealthItem {
|
||
let result: Result<HealthItem, String> = (|| {
|
||
let conn = pool().get().map_err(|e| e.to_string())?;
|
||
let mut stmt = conn.prepare(
|
||
"SELECT win_path FROM project_workspaces WHERE win_path IS NOT NULL AND win_path != '' AND repo_id IS NOT NULL"
|
||
).map_err(|e| e.to_string())?;
|
||
let paths: Vec<String> = stmt
|
||
.query_map([], |row| row.get::<_, String>(0))
|
||
.map_err(|e| e.to_string())?
|
||
.flatten()
|
||
.collect();
|
||
|
||
if paths.is_empty() {
|
||
return Ok(skip_item("git_paths", "Git 仓库路径", "暂无本地路径"));
|
||
}
|
||
let total = paths.len();
|
||
let invalid: Vec<&str> = paths
|
||
.iter()
|
||
.filter(|p| !std::path::Path::new(p).join(".git").exists())
|
||
.map(|p| p.as_str())
|
||
.collect();
|
||
if invalid.is_empty() {
|
||
Ok(HealthItem {
|
||
id: "git_paths".into(),
|
||
name: "Git 仓库路径".into(),
|
||
status: "ok".into(),
|
||
detail: Some(format!("全部 {} 个仓库路径有效", total)),
|
||
})
|
||
} else {
|
||
let status = if invalid.len() == total {
|
||
"error"
|
||
} else {
|
||
"warn"
|
||
};
|
||
Ok(HealthItem {
|
||
id: "git_paths".into(),
|
||
name: "Git 仓库路径".into(),
|
||
status: status.into(),
|
||
detail: Some(format!("{}/{} 个 .git 目录不存在", invalid.len(), total)),
|
||
})
|
||
}
|
||
})();
|
||
result.unwrap_or_else(|e| err_item("git_paths", "Git 仓库路径", &e))
|
||
}
|
||
|
||
/// 检测项目本地路径（win_path）是否存在于文件系统
|
||
fn check_project_paths() -> HealthItem {
|
||
let result: Result<HealthItem, String> = (|| {
|
||
let conn = pool().get().map_err(|e| e.to_string())?;
|
||
let mut stmt = conn.prepare(
|
||
"SELECT win_path FROM project_workspaces WHERE win_path IS NOT NULL AND win_path != ''"
|
||
).map_err(|e| e.to_string())?;
|
||
let paths: Vec<String> = stmt
|
||
.query_map([], |row| row.get::<_, String>(0))
|
||
.map_err(|e| e.to_string())?
|
||
.flatten()
|
||
.collect();
|
||
|
||
if paths.is_empty() {
|
||
return Ok(skip_item(
|
||
"project_paths",
|
||
"项目本地路径",
|
||
"暂无配置路径的项目",
|
||
));
|
||
}
|
||
let total = paths.len();
|
||
let missing = paths
|
||
.iter()
|
||
.filter(|p| !std::path::Path::new(p).exists())
|
||
.count();
|
||
if missing == 0 {
|
||
Ok(HealthItem {
|
||
id: "project_paths".into(),
|
||
name: "项目本地路径".into(),
|
||
status: "ok".into(),
|
||
detail: Some(format!("全部 {} 个路径存在", total)),
|
||
})
|
||
} else {
|
||
Ok(HealthItem {
|
||
id: "project_paths".into(),
|
||
name: "项目本地路径".into(),
|
||
status: "warn".into(),
|
||
detail: Some(format!(
|
||
"{}/{} 个路径不存在（可能已移动或删除）",
|
||
missing, total
|
||
)),
|
||
})
|
||
}
|
||
})();
|
||
result.unwrap_or_else(|e| err_item("project_paths", "项目本地路径", &e))
|
||
}
|
||
|
||
/// 检测活跃编辑器路径是否可用
|
||
/// 存储结构：editors = [{id,name,path}]，active_editors = ["id1","id2"]
|
||
fn check_editor() -> HealthItem {
|
||
let result: Result<HealthItem, String> = (|| {
|
||
let conn = pool().get().map_err(|e| e.to_string())?;
|
||
|
||
let get_val = |key: &str| -> Option<String> {
|
||
conn.query_row(
|
||
"SELECT value FROM settings WHERE key = ?1",
|
||
rusqlite::params![key],
|
||
|row| row.get(0),
|
||
)
|
||
.ok()
|
||
};
|
||
|
||
// 读取编辑器列表
|
||
let editors_raw = match get_val("editors") {
|
||
Some(s) if !s.trim().is_empty() => s,
|
||
_ => return Ok(skip_item("editor", "编辑器路径", "未配置任何编辑器")),
|
||
};
|
||
let editors: Vec<Value> = serde_json::from_str(&editors_raw).unwrap_or_default();
|
||
if editors.is_empty() {
|
||
return Ok(skip_item("editor", "编辑器路径", "未配置任何编辑器"));
|
||
}
|
||
|
||
// 读取活跃编辑器 ID 列表（兼容旧单值字段）
|
||
let active_ids: Vec<String> = if let Some(raw) = get_val("active_editors") {
|
||
serde_json::from_str(&raw).unwrap_or_default()
|
||
} else if let Some(old_id) = get_val("active_editor") {
|
||
if old_id.is_empty() {
|
||
vec![]
|
||
} else {
|
||
vec![old_id]
|
||
}
|
||
} else {
|
||
vec![]
|
||
};
|
||
|
||
if active_ids.is_empty() {
|
||
return Ok(HealthItem {
|
||
id: "editor".into(),
|
||
name: "编辑器路径".into(),
|
||
status: "warn".into(),
|
||
detail: Some("已添加编辑器但未勾选活跃编辑器，请前往设置页勾选至少一个".into()),
|
||
});
|
||
}
|
||
|
||
// 取第一个活跃编辑器检测路径
|
||
let first_id = &active_ids[0];
|
||
let entry = editors.iter().find(|e| e["id"].as_str() == Some(first_id));
|
||
let (name, path) = match entry {
|
||
Some(e) => (
|
||
e["name"].as_str().unwrap_or("编辑器").to_string(),
|
||
e["path"].as_str().unwrap_or("").to_string(),
|
||
),
|
||
None => {
|
||
return Ok(HealthItem {
|
||
id: "editor".into(),
|
||
name: "编辑器路径".into(),
|
||
status: "warn".into(),
|
||
detail: Some(format!(
|
||
"活跃编辑器 ID `{}` 在编辑器列表中未找到，请重新配置",
|
||
first_id
|
||
)),
|
||
})
|
||
}
|
||
};
|
||
|
||
if path.is_empty() {
|
||
return Ok(HealthItem {
|
||
id: "editor".into(),
|
||
name: "编辑器路径".into(),
|
||
status: "warn".into(),
|
||
detail: Some(format!(
|
||
"{} 路径为空，请在设置页编辑该编辑器条目补全路径",
|
||
name
|
||
)),
|
||
});
|
||
}
|
||
if std::path::Path::new(&path).exists() {
|
||
let extra = if active_ids.len() > 1 {
|
||
format!("（共 {} 个活跃编辑器）", active_ids.len())
|
||
} else {
|
||
String::new()
|
||
};
|
||
Ok(HealthItem {
|
||
id: "editor".into(),
|
||
name: "编辑器路径".into(),
|
||
status: "ok".into(),
|
||
detail: Some(format!("{} 路径有效{}", name, extra)),
|
||
})
|
||
} else {
|
||
Ok(HealthItem {
|
||
id: "editor".into(),
|
||
name: "编辑器路径".into(),
|
||
status: "error".into(),
|
||
detail: Some(format!(
|
||
"{} 可执行文件不存在: {}，请在设置页更新路径",
|
||
name, path
|
||
)),
|
||
})
|
||
}
|
||
})();
|
||
result.unwrap_or_else(|e| err_item("editor", "编辑器路径", &e))
|
||
}
|
||
|
||
/// 检测 SQLite 读写延迟
|
||
fn check_db_latency() -> HealthItem {
|
||
let result: Result<HealthItem, String> = (|| {
|
||
let conn = pool().get().map_err(|e| e.to_string())?;
|
||
let start = std::time::Instant::now();
|
||
conn.execute_batch(
|
||
"
|
||
BEGIN;
|
||
INSERT OR REPLACE INTO settings (key, value) VALUES ('__health_probe__', '1');
|
||
DELETE FROM settings WHERE key = '__health_probe__';
|
||
COMMIT;
|
||
",
|
||
)
|
||
.map_err(|e| e.to_string())?;
|
||
let ms = start.elapsed().as_millis();
|
||
let status = if ms < 100 { "ok" } else { "warn" };
|
||
Ok(HealthItem {
|
||
id: "db_latency".into(),
|
||
name: "数据库延迟".into(),
|
||
status: status.into(),
|
||
detail: Some(format!(
|
||
"读写延迟 {}ms{}",
|
||
ms,
|
||
if ms >= 100 { "（偏高）" } else { "" }
|
||
)),
|
||
})
|
||
})();
|
||
result.unwrap_or_else(|e| err_item("db_latency", "数据库延迟", &e))
|
||
}
|
||
|
||
// ── 质量指标 ──────────────────────────────────────────────────────────────────
|
||
|
||
#[derive(Debug, Serialize)]
|
||
pub struct DormantProject {
|
||
pub id: String,
|
||
pub name: String,
|
||
pub days_since_push: i64,
|
||
}
|
||
|
||
#[derive(Debug, Serialize)]
|
||
pub struct OrphanedProject {
|
||
pub id: String,
|
||
pub name: String,
|
||
}
|
||
|
||
#[derive(Debug, Serialize)]
|
||
pub struct QualityMetrics {
|
||
/// last_push_at 超过 30 天且有 repo_url 的项目
|
||
pub dormant_projects: Vec<DormantProject>,
|
||
/// 未加入任何产品组且无 repo_url 的项目
|
||
pub orphaned_projects: Vec<OrphanedProject>,
|
||
/// runtime_logs 近 7 天内有 error/warn 的产品组 id 列表
|
||
pub groups_with_inject_warn: Vec<String>,
|
||
/// win_path 和 wsl_path 均为空的项目数
|
||
pub projects_without_path: i64,
|
||
}
|
||
|
||
impl Default for QualityMetrics {
|
||
fn default() -> Self {
|
||
Self {
|
||
dormant_projects: vec![],
|
||
orphaned_projects: vec![],
|
||
groups_with_inject_warn: vec![],
|
||
projects_without_path: 0,
|
||
}
|
||
}
|
||
}
|
||
|
||
fn collect_quality_metrics() -> QualityMetrics {
|
||
let conn = match pool().get() {
|
||
Ok(c) => c,
|
||
Err(_) => return QualityMetrics::default(),
|
||
};
|
||
|
||
// 1. 休眠项目：last_push_at 超 30 天 且 有 repo_url
|
||
let dormant_projects: Vec<DormantProject> = {
|
||
let stmt = conn.prepare(
|
||
"SELECT pw.id, pp.name,
|
||
CAST(julianday('now') - julianday(pw.last_push_at) AS INTEGER) as days
|
||
FROM project_workspaces pw
|
||
JOIN project_profiles pp ON pp.id = pw.profile_id
|
||
WHERE (pp.repo_url IS NOT NULL AND pp.repo_url != '')
|
||
AND pw.last_push_at IS NOT NULL AND pw.last_push_at != ''
|
||
AND julianday('now') - julianday(pw.last_push_at) > 30
|
||
ORDER BY days DESC",
|
||
);
|
||
match stmt {
|
||
Err(_) => vec![],
|
||
Ok(mut stmt) => stmt
|
||
.query_map([], |row| {
|
||
Ok(DormantProject {
|
||
id: row.get(0)?,
|
||
name: row.get(1)?,
|
||
days_since_push: row.get(2)?,
|
||
})
|
||
})
|
||
.map(|rows| rows.flatten().collect())
|
||
.unwrap_or_default(),
|
||
}
|
||
};
|
||
|
||
// 2. 孤立项目：无 repo_url 且不在任何产品组
|
||
let orphaned_projects: Vec<OrphanedProject> = {
|
||
let stmt = conn.prepare(
|
||
"SELECT pw.id, pp.name
|
||
FROM project_workspaces pw
|
||
JOIN project_profiles pp ON pp.id = pw.profile_id
|
||
WHERE (pp.repo_url IS NULL OR pp.repo_url = '')
|
||
AND pw.id NOT IN (SELECT project_id FROM project_group_map)",
|
||
);
|
||
match stmt {
|
||
Err(_) => vec![],
|
||
Ok(mut stmt) => stmt
|
||
.query_map([], |row| {
|
||
Ok(OrphanedProject {
|
||
id: row.get(0)?,
|
||
name: row.get(1)?,
|
||
})
|
||
})
|
||
.map(|rows| rows.flatten().collect())
|
||
.unwrap_or_default(),
|
||
}
|
||
};
|
||
|
||
// 3. 近 7 天有注入 error/warn 的产品组（解析 context JSON 取 group_id）
|
||
let groups_with_inject_warn: Vec<String> = {
|
||
let stmt = conn.prepare(
|
||
"SELECT DISTINCT context FROM runtime_logs
|
||
WHERE category = 'mcp_inject'
|
||
AND level IN ('error', 'warn')
|
||
AND ts > datetime('now', '-7 days')
|
||
AND context IS NOT NULL",
|
||
);
|
||
let contexts: Vec<String> = match stmt {
|
||
Err(_) => vec![],
|
||
Ok(mut stmt) => stmt
|
||
.query_map([], |row| row.get::<_, String>(0))
|
||
.map(|rows| rows.flatten().collect())
|
||
.unwrap_or_default(),
|
||
};
|
||
|
||
let mut group_ids: Vec<String> = contexts
|
||
.iter()
|
||
.filter_map(|ctx| {
|
||
serde_json::from_str::<Value>(ctx)
|
||
.ok()
|
||
.and_then(|v| v["group_id"].as_str().map(|s| s.to_string()))
|
||
})
|
||
.collect();
|
||
group_ids.sort();
|
||
group_ids.dedup();
|
||
group_ids
|
||
};
|
||
|
||
// 4. 无路径项目数
|
||
let projects_without_path: i64 = conn
|
||
.query_row(
|
||
"SELECT COUNT(*) FROM project_workspaces
|
||
WHERE (win_path IS NULL OR win_path = '')
|
||
AND (wsl_path IS NULL OR wsl_path = '')",
|
||
[],
|
||
|row| row.get(0),
|
||
)
|
||
.unwrap_or(0);
|
||
|
||
QualityMetrics {
|
||
dormant_projects,
|
||
orphaned_projects,
|
||
groups_with_inject_warn,
|
||
projects_without_path,
|
||
}
|
||
}
|
||
|
||
/// 并行执行全部健康检查，返回结构化报告（内部复用入口，mcp_server 也可调用）
|
||
pub fn collect_health_report() -> HealthReport {
|
||
use std::thread;
|
||
let checked_at = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S").to_string();
|
||
|
||
let h_mcp = thread::spawn(check_mcp);
|
||
let h_git = thread::spawn(check_git_paths);
|
||
let h_proj = thread::spawn(check_project_paths);
|
||
let h_editor = thread::spawn(check_editor);
|
||
let h_db = thread::spawn(check_db_latency);
|
||
let h_quality = thread::spawn(collect_quality_metrics);
|
||
|
||
let items = vec![
|
||
h_mcp
|
||
.join()
|
||
.unwrap_or_else(|_| err_item("mcp", "MCP Server", "检测线程异常")),
|
||
h_git
|
||
.join()
|
||
.unwrap_or_else(|_| err_item("git_paths", "Git 仓库路径", "检测线程异常")),
|
||
h_proj
|
||
.join()
|
||
.unwrap_or_else(|_| err_item("project_paths", "项目本地路径", "检测线程异常")),
|
||
h_editor
|
||
.join()
|
||
.unwrap_or_else(|_| err_item("editor", "编辑器路径", "检测线程异常")),
|
||
h_db.join()
|
||
.unwrap_or_else(|_| err_item("db_latency", "数据库延迟", "检测线程异常")),
|
||
];
|
||
let quality = h_quality.join().unwrap_or_default();
|
||
|
||
HealthReport {
|
||
checked_at,
|
||
items,
|
||
quality,
|
||
}
|
||
}
|
||
|
||
#[tauri::command]
|
||
pub fn run_health_check() -> Result<HealthReport, String> {
|
||
Ok(collect_health_report())
|
||
}
|
||
|
||
fn expand_env(s: &str) -> String {
|
||
let mut result = s.to_string();
|
||
for (key, val) in std::env::vars() {
|
||
result = result.replace(&format!("%{key}%"), &val);
|
||
}
|
||
result
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn global_keys_contains_infra() {
|
||
assert!(GLOBAL_KEYS.contains(&"mcp_port"));
|
||
assert!(GLOBAL_KEYS.contains(&"wsl_distro"));
|
||
}
|
||
|
||
#[test]
|
||
fn space_specific_keys_not_in_global() {
|
||
// editor / dev_mode 是空间维度的配置，不应进入全局表
|
||
assert!(!GLOBAL_KEYS.contains(&"editor"));
|
||
assert!(!GLOBAL_KEYS.contains(&"dev_mode"));
|
||
}
|
||
|
||
#[test]
|
||
fn settings_routing_via_db() {
|
||
crate::db::conn_with_schema(); // 仅验证 schema 可正常建立，不依赖全局 pool
|
||
}
|
||
|
||
#[test]
|
||
fn mcp_health_check_uses_loopback_url() {
|
||
assert_eq!(
|
||
crate::mcp_server::mcp_health_url(27190),
|
||
"http://127.0.0.1:27190/health"
|
||
);
|
||
}
|
||
|
||
fn ready_evidence() -> AgentRuntimeEvidence {
|
||
AgentRuntimeEvidence {
|
||
configured: AgentRuntimeLayer::new(
|
||
AgentRuntimeState::Ready,
|
||
"lian-jing 指向本地 MCP 服务",
|
||
),
|
||
reachable: Ok("loopback 可达".to_string()),
|
||
handshake: Ok(()),
|
||
tool_names: Ok(CORE_AGENT_TOOLS
|
||
.iter()
|
||
.map(|name| name.to_string())
|
||
.collect()),
|
||
reload_required: false,
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn agent_runtime_ready_requires_all_layers() {
|
||
let status = build_agent_runtime_status("p1", ready_evidence());
|
||
|
||
assert!(status.ready);
|
||
assert_eq!(status.configured.state, AgentRuntimeState::Ready);
|
||
assert_eq!(status.reachable.state, AgentRuntimeState::Ready);
|
||
assert_eq!(status.handshake.state, AgentRuntimeState::Ready);
|
||
assert_eq!(status.tools_ready.state, AgentRuntimeState::Ready);
|
||
assert_eq!(status.reload_required.required, Some(false));
|
||
}
|
||
|
||
#[test]
|
||
fn agent_runtime_port_refusal_never_reports_ready() {
|
||
let mut evidence = ready_evidence();
|
||
evidence.reachable = Err("connection refused".to_string());
|
||
let status = build_agent_runtime_status("p1", evidence);
|
||
|
||
assert!(!status.ready);
|
||
assert_eq!(status.configured.state, AgentRuntimeState::Ready);
|
||
assert_eq!(status.reachable.state, AgentRuntimeState::Unavailable);
|
||
assert_eq!(status.handshake.state, AgentRuntimeState::Unavailable);
|
||
assert_eq!(status.tools_ready.state, AgentRuntimeState::Unavailable);
|
||
}
|
||
|
||
#[test]
|
||
fn agent_runtime_distinguishes_protocol_missing_and_reload_states() {
|
||
let mut protocol = ready_evidence();
|
||
protocol.handshake = Err("initialize 响应缺少 result".to_string());
|
||
let status = build_agent_runtime_status("p1", protocol);
|
||
assert_eq!(status.handshake.state, AgentRuntimeState::ProtocolError);
|
||
assert!(!status.ready);
|
||
|
||
let mut missing = ready_evidence();
|
||
missing.tool_names = Ok(vec!["get_diagnostics".to_string()]);
|
||
let status = build_agent_runtime_status("p1", missing);
|
||
assert_eq!(status.tools_ready.state, AgentRuntimeState::Missing);
|
||
assert!(status.tools_ready.detail.contains("verify_onboarding"));
|
||
|
||
let mut reload = ready_evidence();
|
||
reload.reload_required = true;
|
||
let status = build_agent_runtime_status("p1", reload);
|
||
assert_eq!(status.reload_required.state, AgentRuntimeState::Missing);
|
||
assert_eq!(status.reload_required.required, Some(true));
|
||
assert!(!status.ready);
|
||
|
||
let mut unconfigured = ready_evidence();
|
||
unconfigured.configured =
|
||
AgentRuntimeLayer::new(AgentRuntimeState::Missing, ".codex/config.toml 缺失");
|
||
let status = build_agent_runtime_status("p1", unconfigured);
|
||
assert_eq!(status.configured.state, AgentRuntimeState::Missing);
|
||
assert!(!status.ready);
|
||
}
|
||
|
||
#[test]
|
||
fn autostart_accepts_only_installed_release_executable() {
|
||
let (eligible, kind, _) = autostart_eligibility(
|
||
true,
|
||
Path::new(r"C:\Program Files\炼境\dev-manager-tauri.exe"),
|
||
);
|
||
assert!(!eligible);
|
||
assert_eq!(kind, "debug");
|
||
|
||
let (eligible, kind, _) = autostart_eligibility(
|
||
false,
|
||
Path::new(
|
||
r"E:\code-project\dev-manager-tauri\src-tauri\target\release\dev-manager-tauri.exe",
|
||
),
|
||
);
|
||
assert!(!eligible);
|
||
assert_eq!(kind, "release_uninstalled");
|
||
|
||
let (eligible, kind, _) = autostart_eligibility(
|
||
false,
|
||
Path::new(r"C:\Users\user\Downloads\dev-manager-tauri.exe"),
|
||
);
|
||
assert!(!eligible);
|
||
assert_eq!(kind, "release_uninstalled");
|
||
|
||
let (eligible, kind, detail) = autostart_eligibility(
|
||
false,
|
||
Path::new(
|
||
r"C:\Users\user\AppData\Local\Programs\dev-manager-tauri\dev-manager-tauri.exe",
|
||
),
|
||
);
|
||
assert!(eligible);
|
||
assert_eq!(kind, "installed_release");
|
||
assert!(detail.contains("正式安装版"));
|
||
}
|
||
|
||
#[test]
|
||
fn autostart_transition_is_idempotent_and_refuses_ineligible_enable() {
|
||
assert_eq!(
|
||
plan_autostart_action(false, false, true),
|
||
AutostartAction::RefuseEnable
|
||
);
|
||
assert_eq!(
|
||
plan_autostart_action(false, false, false),
|
||
AutostartAction::Noop
|
||
);
|
||
assert_eq!(
|
||
plan_autostart_action(true, false, false),
|
||
AutostartAction::Noop
|
||
);
|
||
assert_eq!(
|
||
plan_autostart_action(true, true, true),
|
||
AutostartAction::Noop
|
||
);
|
||
assert_eq!(
|
||
plan_autostart_action(true, false, true),
|
||
AutostartAction::Enable
|
||
);
|
||
assert_eq!(
|
||
plan_autostart_action(true, true, false),
|
||
AutostartAction::Disable
|
||
);
|
||
}
|
||
}
|