GithubBackup/clawpanel
1
0
Fork 0
mirror of https://github.com/qingchencloud/clawpanel.git synced 2026-05-11 18:10:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: 全局重构原生弹窗为自定义 Modal 并同步更新项目文档

Browse Source 
- 替换所有不可用的 `alert`, `confirm`, `prompt` 调用为异步的自定义 `Modal` 组件以适配 Tauri WebView 的 API 限制。
- 优化与重构核心服务组件接口，增加模型有效性测试 (`test_model`) 以及依赖更新支持。
- 同步补齐 `README.md` 与 `CHANGELOG.md` 新增的系统特性说明（含仪表盘、日记、存储、重构页面调整）。
This commit is contained in:
晴天
2026-02-28 03:42:19 +08:00
parent 75e94a7560
commit 84a6ab4d45
24 changed files with 1591 additions and 488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src-tauri/capabilities/default.json Normal file
View File

@@ -0,0 +1,9 @@
{
"identifier": "default",
"description": "ClawPanel 默认权限",
"windows": ["main"],
"permissions": [
"core:default",
"shell:allow-open"
]
}

2
src-tauri/gen/schemas/capabilities.json
View File

@@ -1 +1 @@
{}
{"default":{"identifier":"default","description":"ClawPanel 默认权限","local":true,"windows":["main"],"permissions":["core:default","shell:allow-open"]}}

266
src-tauri/src/commands/config.rs
View File

@@ -2,22 +2,17 @@
use serde_json::Value;
use std::fs;
use std::path::PathBuf;
use std::process::Command;
use crate::models::types::VersionInfo;
fn openclaw_dir() -> PathBuf {
dirs::home_dir()
.unwrap_or_default()
.join(".openclaw")
}
fn backups_dir() -> PathBuf {
openclaw_dir().join("backups")
super::openclaw_dir().join("backups")
}
#[tauri::command]
pub fn read_openclaw_config() -> Result<Value, String> {
let path = openclaw_dir().join("openclaw.json");
let path = super::openclaw_dir().join("openclaw.json");
let content = fs::read_to_string(&path)
.map_err(|e| format!("读取配置失败: {e}"))?;
serde_json::from_str(&content)
@@ -26,9 +21,9 @@ pub fn read_openclaw_config() -> Result<Value, String> {
#[tauri::command]
pub fn write_openclaw_config(config: Value) -> Result<(), String> {
let path = openclaw_dir().join("openclaw.json");
let path = super::openclaw_dir().join("openclaw.json");
// 备份
let bak = openclaw_dir().join("openclaw.json.bak");
let bak = super::openclaw_dir().join("openclaw.json.bak");
let _ = fs::copy(&path, &bak);
// 写入
let json = serde_json::to_string_pretty(&config)
@@ -39,7 +34,7 @@ pub fn write_openclaw_config(config: Value) -> Result<(), String> {
#[tauri::command]
pub fn read_mcp_config() -> Result<Value, String> {
let path = openclaw_dir().join("mcp.json");
let path = super::openclaw_dir().join("mcp.json");
if !path.exists() {
return Ok(Value::Object(Default::default()));
}
@@ -51,37 +46,87 @@ pub fn read_mcp_config() -> Result<Value, String> {
#[tauri::command]
pub fn write_mcp_config(config: Value) -> Result<(), String> {
let path = openclaw_dir().join("mcp.json");
let path = super::openclaw_dir().join("mcp.json");
let json = serde_json::to_string_pretty(&config)
.map_err(|e| format!("序列化失败: {e}"))?;
fs::write(&path, json)
.map_err(|e| format!("写入失败: {e}"))
}
#[tauri::command]
pub fn get_version_info() -> Result<VersionInfo, String> {
// 从 openclaw.json 的 meta.lastTouchedVersion 读取
let config = read_openclaw_config()?;
let current = config
.get("meta")
.and_then(|m| m.get("lastTouchedVersion"))
.and_then(|v| v.as_str())
.map(String::from);
/// 获取本地安装的 openclaw 版本号
fn get_local_version() -> Option<String> {
let output = Command::new("openclaw")
.arg("--version")
.output()
.ok()?;
let raw = String::from_utf8_lossy(&output.stdout).trim().to_string();
// 格式可能是 "openclaw 2026.2.23" 或纯版本号
let version = raw
.split_whitespace()
.last()
.filter(|s| !s.is_empty())
.map(String::from)?;
Some(version)
}
/// 从 npm registry 获取最新版本号，超时 5 秒
async fn get_latest_version() -> Option<String> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(5))
.build()
.ok()?;
let resp = client
.get("https://registry.npmjs.org/@qingchencloud%2Fopenclaw-zh/latest")
.send()
.await
.ok()?;
let json: Value = resp.json().await.ok()?;
json.get("version")
.and_then(|v| v.as_str())
.map(String::from)
}
#[tauri::command]
pub async fn get_version_info() -> Result<VersionInfo, String> {
let current = get_local_version();
let latest = get_latest_version().await;
let update_available = match (&current, &latest) {
(Some(c), Some(l)) => l != c,
_ => false,
};
Ok(VersionInfo {
current,
latest: None,
update_available: false,
latest,
update_available,
})
}
/// 执行 npm 全局升级 openclaw
#[tauri::command]
pub async fn upgrade_openclaw() -> Result<String, String> {
let output = Command::new("npm")
.args(["install", "-g", "@qingchencloud/openclaw-zh@latest"])
.output()
.map_err(|e| format!("执行升级命令失败: {e}"))?;
let stderr = String::from_utf8_lossy(&output.stderr).to_string();
if !output.status.success() {
return Err(format!("升级失败: {stderr}"));
}
// 获取升级后的版本号
let new_ver = get_local_version().unwrap_or_else(|| "未知".into());
Ok(format!("升级成功，当前版本: {new_ver}"))
}
#[tauri::command]
pub fn check_installation() -> Result<Value, String> {
let openclaw_dir = openclaw_dir();
let installed = openclaw_dir.join("openclaw.json").exists();
let dir = super::openclaw_dir();
let installed = dir.join("openclaw.json").exists();
let mut result = serde_json::Map::new();
result.insert("installed".into(), Value::Bool(installed));
result.insert("path".into(), Value::String(openclaw_dir.to_string_lossy().to_string()));
result.insert("path".into(), Value::String(dir.to_string_lossy().to_string()));
Ok(Value::Object(result))
}
@@ -94,6 +139,13 @@ pub fn write_env_file(path: String, config: String) -> Result<(), String> {
} else {
PathBuf::from(&path)
};
// 安全限制：只允许写入 ~/.openclaw/ 目录下的文件
let openclaw_base = super::openclaw_dir();
if !expanded.starts_with(&openclaw_base) {
return Err("只允许写入 ~/.openclaw/ 目录下的文件".to_string());
}
if let Some(parent) = expanded.parent() {
let _ = fs::create_dir_all(parent);
}
@@ -121,8 +173,11 @@ pub fn list_backups() -> Result<Value, String> {
let name = path.file_name().unwrap_or_default().to_string_lossy().to_string();
let meta = fs::metadata(&path).ok();
let size = meta.as_ref().map(|m| m.len()).unwrap_or(0);
// macOS 支持 created()，fallback 到 modified()
let created = meta
.and_then(|m| m.modified().ok())
.and_then(|m| {
m.created().ok().or_else(|| m.modified().ok())
})
.and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
.map(|d| d.as_secs())
.unwrap_or(0);
@@ -148,7 +203,7 @@ pub fn create_backup() -> Result<Value, String> {
fs::create_dir_all(&dir)
.map_err(|e| format!("创建备份目录失败: {e}"))?;
let src = openclaw_dir().join("openclaw.json");
let src = super::openclaw_dir().join("openclaw.json");
if !src.exists() {
return Err("openclaw.json 不存在".into());
}
@@ -176,7 +231,7 @@ pub fn restore_backup(name: String) -> Result<(), String> {
if !backup_path.exists() {
return Err(format!("备份文件不存在: {name}"));
}
let target = openclaw_dir().join("openclaw.json");
let target = super::openclaw_dir().join("openclaw.json");
// 恢复前先自动备份当前配置
if target.exists() {
@@ -201,39 +256,33 @@ pub fn delete_backup(name: String) -> Result<(), String> {
.map_err(|e| format!("删除失败: {e}"))
}
/// 重载 Gateway 服务（unload + load plist）
/// 获取当前用户 UID
fn get_uid() -> Result<u32, String> {
let output = Command::new("id")
.arg("-u")
.output()
.map_err(|e| format!("获取 UID 失败: {e}"))?;
String::from_utf8_lossy(&output.stdout)
.trim()
.parse::<u32>()
.map_err(|e| format!("解析 UID 失败: {e}"))
}
/// 重载 Gateway 服务（使用 kickstart -k 强制重启）
#[tauri::command]
pub fn reload_gateway() -> Result<String, String> {
let home = dirs::home_dir().unwrap_or_default();
let plist = format!(
"{}/Library/LaunchAgents/ai.openclaw.gateway.plist",
home.display()
);
if !std::path::Path::new(&plist).exists() {
return Err("Gateway plist 不存在".into());
}
// 先 unload，忽略错误
let _ = std::process::Command::new("launchctl")
.args(["unload", &plist])
.output();
std::thread::sleep(std::time::Duration::from_millis(500));
let output = std::process::Command::new("launchctl")
.args(["load", &plist])
let uid = get_uid()?;
let target = format!("gui/{uid}/ai.openclaw.gateway");
let output = Command::new("launchctl")
.args(["kickstart", "-k", &target])
.output()
.map_err(|e| format!("重载 Gateway 失败: {e}"))?;
if !output.status.success() {
.map_err(|e| format!("重载失败: {e}"))?;
if output.status.success() {
Ok("Gateway 已重载".to_string())
} else {
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.trim().is_empty() {
return Err(format!("重载 Gateway 失败: {stderr}"));
}
Err(format!("重载失败: {stderr}"))
}
Ok("Gateway 已重载".into())
}
/// 测试模型连通性：向 provider 发送一个简单的 chat completion 请求
@@ -308,3 +357,106 @@ pub async fn test_model(
Ok(reply)
}
/// 获取服务商的远程模型列表（调用 /models 接口）
#[tauri::command]
pub async fn list_remote_models(
base_url: String,
api_key: String,
) -> Result<Vec<String>, String> {
let url = format!("{}/models", base_url.trim_end_matches('/'));
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(15))
.build()
.map_err(|e| format!("创建 HTTP 客户端失败: {e}"))?;
let mut req = client.get(&url);
if !api_key.is_empty() {
req = req.header("Authorization", format!("Bearer {api_key}"));
}
let resp = req.send().await.map_err(|e| {
if e.is_timeout() {
"请求超时 (15s)，该服务商可能不支持模型列表接口".to_string()
} else if e.is_connect() {
format!("连接失败，请检查接口地址是否正确: {e}")
} else {
format!("请求失败: {e}")
}
})?;
let status = resp.status();
let text = resp.text().await.unwrap_or_default();
if !status.is_success() {
let msg = serde_json::from_str::<serde_json::Value>(&text)
.ok()
.and_then(|v| {
v.get("error")
.and_then(|e| e.get("message"))
.and_then(|m| m.as_str())
.map(String::from)
})
.unwrap_or_else(|| format!("HTTP {status}"));
return Err(format!("获取模型列表失败: {msg}"));
}
// 解析 OpenAI 格式的 /models 响应
let ids = serde_json::from_str::<serde_json::Value>(&text)
.ok()
.and_then(|v| {
let data = v.get("data")?.as_array()?;
let mut ids: Vec<String> = data
.iter()
.filter_map(|m| m.get("id").and_then(|id| id.as_str()).map(String::from))
.collect();
ids.sort();
Some(ids)
})
.unwrap_or_default();
if ids.is_empty() {
return Err("该服务商返回了空的模型列表，可能不支持 /models 接口".to_string());
}
Ok(ids)
}
/// 安装 Gateway 服务（执行 openclaw gateway install）
#[tauri::command]
pub fn install_gateway() -> Result<String, String> {
let output = Command::new("openclaw")
.args(["gateway", "install"])
.output()
.map_err(|e| format!("安装失败: {e}"))?;
if output.status.success() {
Ok("Gateway 服务已安装".to_string())
} else {
let stderr = String::from_utf8_lossy(&output.stderr);
Err(format!("安装失败: {stderr}"))
}
}
/// 卸载 Gateway 服务（先 bootout 再删除 plist）
#[tauri::command]
pub fn uninstall_gateway() -> Result<String, String> {
let uid = get_uid()?;
let target = format!("gui/{uid}/ai.openclaw.gateway");
// 先停止服务
let _ = Command::new("launchctl")
.args(["bootout", &target])
.output();
// 删除 plist 文件
let home = dirs::home_dir().unwrap_or_default();
let plist = home.join("Library/LaunchAgents/ai.openclaw.gateway.plist");
if plist.exists() {
fs::remove_file(&plist)
.map_err(|e| format!("删除 plist 失败: {e}"))?;
}
Ok("Gateway 服务已卸载".to_string())
}

44
src-tauri/src/commands/extensions.rs
View File

@@ -59,6 +59,27 @@ fn cftunnel_bin() -> String {
"cftunnel".to_string()
}
/// 通过 launchctl 检测 cftunnel 服务实际运行状态
fn check_cftunnel_launchctl() -> Option<(Option<u64>, bool)> {
let output = Command::new("launchctl")
.args(["list"])
.output()
.ok()?;
let text = String::from_utf8_lossy(&output.stdout);
for line in text.lines() {
if line.contains("com.cftunnel") {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 3 {
let pid = parts[0].parse::<u64>().ok();
// 第一列是 PID（数字表示在运行，- 表示未运行）
let running = pid.is_some();
return Some((pid, running));
}
}
}
None
}
#[tauri::command]
pub fn get_cftunnel_status() -> Result<Value, String> {
let bin = cftunnel_bin();
@@ -87,6 +108,19 @@ pub fn get_cftunnel_status() -> Result<Value, String> {
}
}
// 补充检测：如果 cftunnel status 报已停止，但 launchctl 显示进程在跑，以实际为准
let reported_running = result.get("running").and_then(|v| v.as_bool()).unwrap_or(false);
if !reported_running {
if let Some((pid, running)) = check_cftunnel_launchctl() {
if running {
result.insert("running".into(), Value::Bool(true));
if let Some(p) = pid {
result.insert("pid".into(), Value::Number(p.into()));
}
}
}
}
// 获取路由列表
if let Ok(out) = Command::new(&bin).arg("list").output() {
let text = String::from_utf8_lossy(&out.stdout);
@@ -100,12 +134,14 @@ pub fn get_cftunnel_status() -> Result<Value, String> {
#[tauri::command]
pub fn cftunnel_action(action: String) -> Result<(), String> {
let bin = cftunnel_bin();
match action.as_str() {
"up" | "down" => {}
let args = match action.as_str() {
"up" => vec!["up"],
"down" => vec!["down"],
"restart" => vec!["restart"],
_ => return Err(format!("不支持的操作: {action}")),
}
};
let output = Command::new(&bin)
.arg(&action)
.args(&args)
.output()
.map_err(|e| format!("执行 cftunnel {action} 失败: {e}"))?;

76
src-tauri/src/commands/logs.rs
View File

@@ -1,6 +1,7 @@
/// 日志读取命令
/// 使用 BufReader + Seek 避免 OOM，限制最大读取量
use std::fs;
use std::io::{BufRead, BufReader};
use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
use std::path::PathBuf;
fn log_dir() -> PathBuf {
@@ -23,16 +24,44 @@ fn log_path(log_name: &str) -> PathBuf {
}
#[tauri::command]
pub fn read_log_tail(log_name: String, lines: usize) -> Result<String, String> {
pub fn read_log_tail(log_name: String, lines: Option<u32>) -> Result<String, String> {
let lines = lines.unwrap_or(200) as usize;
let path = log_path(&log_name);
if !path.exists() {
return Ok(String::new());
}
let content = fs::read_to_string(&path)
let mut file = fs::File::open(&path)
.map_err(|e| format!("打开日志失败: {e}"))?;
let file_len = file
.metadata()
.map_err(|e| format!("获取文件元数据失败: {e}"))?
.len();
// 最多从尾部读取 1MB，避免 OOM
let max_read: u64 = 1024 * 1024;
let start_pos = if file_len > max_read {
file_len - max_read
} else {
0
};
file.seek(SeekFrom::Start(start_pos))
.map_err(|e| format!("Seek 失败: {e}"))?;
let mut buf = String::new();
file.read_to_string(&mut buf)
.map_err(|e| format!("读取日志失败: {e}"))?;
let all_lines: Vec<&str> = content.lines().collect();
let mut all_lines: Vec<&str> = buf.lines().collect();
// 如果从中间开始读，第一行可能不完整，跳过
if start_pos > 0 && all_lines.len() > 1 {
all_lines.remove(0);
}
// 取最后 N 行
let start = if all_lines.len() > lines {
all_lines.len() - lines
} else {
@@ -46,24 +75,53 @@ pub fn read_log_tail(log_name: String, lines: usize) -> Result<String, String> {
pub fn search_log(
log_name: String,
query: String,
max_results: usize,
max_results: Option<u32>,
) -> Result<Vec<String>, String> {
let max_results = max_results.unwrap_or(50) as usize;
let path = log_path(&log_name);
if !path.exists() {
return Ok(vec![]);
}
let file = fs::File::open(&path)
let mut file = fs::File::open(&path)
.map_err(|e| format!("打开日志失败: {e}"))?;
let file_len = file
.metadata()
.map_err(|e| format!("获取文件元数据失败: {e}"))?
.len();
// 搜索最多读取尾部 2MB，避免 OOM，同时保证搜索最新内容
let max_read: u64 = 2 * 1024 * 1024;
let start_pos = if file_len > max_read {
file_len - max_read
} else {
0
};
file.seek(SeekFrom::Start(start_pos))
.map_err(|e| format!("Seek 失败: {e}"))?;
let reader = BufReader::new(file);
let query_lower = query.to_lowercase();
let results: Vec<String> = reader
let mut matched: Vec<String> = reader
.lines()
.filter_map(|l| l.ok())
.filter(|l| l.to_lowercase().contains(&query_lower))
.take(max_results)
.collect();
Ok(results)
// 如果从中间开始读，第一条匹配可能是不完整行，跳过
if start_pos > 0 && !matched.is_empty() {
matched.remove(0);
}
// 取最后 N 条（最新的匹配结果）
let start = if matched.len() > max_results {
matched.len() - max_results
} else {
0
};
Ok(matched[start..].to_vec())
}

59
src-tauri/src/commands/memory.rs
View File

@@ -3,18 +3,13 @@ use std::fs;
use std::io::Write;
use std::path::PathBuf;
fn openclaw_dir() -> PathBuf {
dirs::home_dir()
.unwrap_or_default()
.join(".openclaw")
}
fn memory_dir(category: &str) -> PathBuf {
fn memory_dir(category: &str) -> std::path::PathBuf {
let base = super::openclaw_dir();
match category {
"memory" => openclaw_dir().join("workspace").join("memory"),
"archive" => openclaw_dir().join("workspace-memory"),
"core" => openclaw_dir().join("workspace"),
_ => openclaw_dir().join("workspace").join("memory"),
"memory" => base.join("workspace").join("memory"),
"archive" => base.join("workspace-memory"),
"core" => base.join("workspace"),
_ => base.join("workspace").join("memory"),
}
}
@@ -62,8 +57,8 @@ fn collect_files(
#[tauri::command]
pub fn read_memory_file(path: String) -> Result<String, String> {
// 安全检查：路径不能包含 ..
if path.contains("..") {
// 安全检查：路径不能包含 ..、绝对路径、空字节
if path.contains("..") || path.starts_with('/') || path.contains('\0') {
return Err("非法路径".to_string());
}
@@ -85,36 +80,32 @@ pub fn read_memory_file(path: String) -> Result<String, String> {
}
#[tauri::command]
pub fn write_memory_file(path: String, content: String) -> Result<(), String> {
if path.contains("..") {
pub fn write_memory_file(path: String, content: String, category: Option<String>) -> Result<(), String> {
// 安全检查：路径不能包含 ..、绝对路径、空字节
if path.contains("..") || path.starts_with('/') || path.contains('\0') {
return Err("非法路径".to_string());
}
let candidates = [
memory_dir("memory").join(&path),
memory_dir("archive").join(&path),
memory_dir("core").join(&path),
];
let cat = category.unwrap_or_else(|| "memory".to_string());
let base = match cat.as_str() {
"memory" => super::openclaw_dir().join("workspace").join("memory"),
"archive" => super::openclaw_dir().join("workspace-memory"),
"core" => super::openclaw_dir().join("workspace"),
_ => return Err(format!("未知分类: {cat}")),
};
for candidate in &candidates {
if candidate.exists() {
return fs::write(candidate, &content)
.map_err(|e| format!("写入失败: {e}"));
}
let full_path = base.join(&path);
// 确保父目录存在
if let Some(parent) = full_path.parent() {
fs::create_dir_all(parent).map_err(|e| format!("创建目录失败: {e}"))?;
}
// 默认写入 memory 目录
let target = memory_dir("memory").join(&path);
if let Some(parent) = target.parent() {
let _ = fs::create_dir_all(parent);
}
fs::write(&target, &content)
.map_err(|e| format!("写入失败: {e}"))
fs::write(&full_path, &content).map_err(|e| format!("写入失败: {e}"))
}
#[tauri::command]
pub fn delete_memory_file(path: String) -> Result<(), String> {
if path.contains("..") {
// 安全检查：路径不能包含 ..、绝对路径、空字节
if path.contains("..") || path.starts_with('/') || path.contains('\0') {
return Err("非法路径".to_string());
}

9
src-tauri/src/commands/mod.rs
View File

@@ -1,5 +1,14 @@
use std::path::PathBuf;
pub mod config;
pub mod extensions;
pub mod logs;
pub mod memory;
pub mod service;
/// 获取 OpenClaw 配置目录 (~/.openclaw/)
pub fn openclaw_dir() -> PathBuf {
dirs::home_dir()
.unwrap_or_default()
.join(".openclaw")
}

212
src-tauri/src/commands/service.rs
View File

@@ -1,27 +1,36 @@
/// 服务管理命令 (macOS launchd)
/// 动态扫描 ~/Library/LaunchAgents/ 下的 openclaw/cftunnel 相关 plist
/// 只扫描 OpenClaw 核心服务 (ai.openclaw.* / com.openclaw.guardian.* / com.openclaw.watchdog)
/// 使用新版 launchctl bootstrap/bootout/kickstart API
use std::collections::HashMap;
use std::fs;
use std::process::Command;
use crate::models::types::ServiceStatus;
/// 友好名称映射
/// 获取当前用户 UID
fn current_uid() -> Result<u32, String> {
let output = Command::new("id")
.arg("-u")
.output()
.map_err(|e| format!("获取 UID 失败: {e}"))?;
let uid_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
uid_str.parse::<u32>().map_err(|e| format!("解析 UID 失败: {e}"))
}
/// OpenClaw 官方服务的友好名称映射
fn description_map() -> HashMap<&'static str, &'static str> {
HashMap::from([
("ai.openclaw.gateway", "OpenClaw Gateway"),
("com.openclaw.guardian.watch", "健康监控 (60s)"),
("com.openclaw.guardian.backup", "配置备份 (3600s)"),
("com.openclaw.watchdog", "看门狗 (120s)"),
("com.openclaw.webhook-router", "Webhook 路由"),
("com.openclaw.webhook-tunnel", "Webhook SSH 隧道"),
("com.openclaw.cf-tunnel", "Cloudflare Tunnel (旧)"),
("com.cftunnel.cloudflared", "cftunnel 隧道服务"),
("actions.runner.2221186349-qingchen.openclaw-mac", "GitHub Actions Runner"),
("ai.openclaw.node", "OpenClaw Node Host"),
])
}
/// 动态扫描 LaunchAgents 目录，找出所有 openclaw/cftunnel 相关 plist
/// OpenClaw 官方服务前缀（ai.openclaw.gateway / ai.openclaw.node 等）
const OPENCLAW_PREFIXES: &[&str] = &[
"ai.openclaw.",
];
/// 动态扫描 LaunchAgents 目录，只返回 OpenClaw 核心服务
fn scan_plist_labels() -> Vec<String> {
let home = dirs::home_dir().unwrap_or_default();
let agents_dir = home.join("Library/LaunchAgents");
@@ -30,12 +39,12 @@ fn scan_plist_labels() -> Vec<String> {
if let Ok(entries) = fs::read_dir(&agents_dir) {
for entry in entries.flatten() {
let name = entry.file_name().to_string_lossy().to_string();
if (name.contains("openclaw") || name.contains("cftunnel"))
&& name.ends_with(".plist")
{
// 文件名去掉 .plist 就是 label
let label = name.trim_end_matches(".plist").to_string();
labels.push(label);
if !name.ends_with(".plist") {
continue;
}
let label = name.trim_end_matches(".plist");
if OPENCLAW_PREFIXES.iter().any(|p| label.starts_with(p)) {
labels.push(label.to_string());
}
}
}
@@ -52,42 +61,65 @@ fn plist_path(label: &str) -> String {
)
}
/// 用 `launchctl print gui/{uid}/{label}` 检测单个服务状态
/// 返回 (running, pid)
fn check_service_status(uid: u32, label: &str) -> (bool, Option<u32>) {
let target = format!("gui/{}/{}", uid, label);
let output = Command::new("launchctl")
.args(["print", &target])
.output();
let Ok(out) = output else {
return (false, None);
};
// launchctl print 返回非零 → 服务未注册
if !out.status.success() {
return (false, None);
}
let stdout = String::from_utf8_lossy(&out.stdout);
let mut pid: Option<u32> = None;
let mut running = false;
for line in stdout.lines() {
// 只解析顶层字段（单个 tab 缩进），忽略嵌套的 state = active 等
if !line.starts_with('\t') || line.starts_with("\t\t") {
continue;
}
let trimmed = line.trim();
if trimmed.starts_with("pid = ") {
if let Ok(p) = trimmed["pid = ".len()..].trim().parse::<u32>() {
pid = Some(p);
}
}
if trimmed.starts_with("state = ") {
let state = trimmed["state = ".len()..].trim();
running = state == "running";
}
}
(running, pid)
}
#[tauri::command]
pub fn get_services_status() -> Result<Vec<ServiceStatus>, String> {
let output = Command::new("launchctl")
.arg("list")
.output()
.map_err(|e| format!("执行 launchctl 失败: {e}"))?;
let stdout = String::from_utf8_lossy(&output.stdout);
let uid = current_uid()?;
let labels = scan_plist_labels();
let desc_map = description_map();
let mut results = Vec::new();
for label in &labels {
let mut status = ServiceStatus {
let (running, pid) = check_service_status(uid, label);
results.push(ServiceStatus {
label: label.clone(),
pid: None,
running: false,
pid,
running,
description: desc_map
.get(label.as_str())
.unwrap_or(&"")
.to_string(),
};
// 解析 launchctl list 输出: PID\tStatus\tLabel
for line in stdout.lines() {
let parts: Vec<&str> = line.split('\t').collect();
if parts.len() >= 3 && parts[2] == label {
if let Ok(pid) = parts[0].trim().parse::<u32>() {
status.pid = Some(pid);
status.running = true;
}
// PID 为 "-" 但 label 存在于 launchctl list 中 → 已加载但未运行
break;
}
}
results.push(status);
});
}
Ok(results)
@@ -95,57 +127,115 @@ pub fn get_services_status() -> Result<Vec<ServiceStatus>, String> {
#[tauri::command]
pub fn start_service(label: String) -> Result<(), String> {
let uid = current_uid()?;
let path = plist_path(&label);
let output = Command::new("launchctl")
.args(["load", &path])
.output()
.map_err(|e| format!("启动失败: {e}"))?;
let domain_target = format!("gui/{}", uid);
let service_target = format!("gui/{}/{}", uid, label);
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.trim().is_empty() {
// bootstrap 加载 plist
let bootstrap_out = Command::new("launchctl")
.args(["bootstrap", &domain_target, &path])
.output()
.map_err(|e| format!("bootstrap 失败: {e}"))?;
if !bootstrap_out.status.success() {
let stderr = String::from_utf8_lossy(&bootstrap_out.stderr);
// 如果已经加载过，忽略该错误，继续 kickstart
if !stderr.contains("already bootstrapped") && !stderr.trim().is_empty() {
return Err(format!("启动 {label} 失败: {stderr}"));
}
}
// kickstart 触发服务运行
let kickstart_out = Command::new("launchctl")
.args(["kickstart", &service_target])
.output()
.map_err(|e| format!("kickstart 失败: {e}"))?;
if !kickstart_out.status.success() {
let stderr = String::from_utf8_lossy(&kickstart_out.stderr);
if !stderr.trim().is_empty() {
return Err(format!("kickstart {label} 失败: {stderr}"));
}
}
Ok(())
}
#[tauri::command]
pub fn stop_service(label: String) -> Result<(), String> {
let path = plist_path(&label);
let uid = current_uid()?;
let service_target = format!("gui/{}/{}", uid, label);
let output = Command::new("launchctl")
.args(["unload", &path])
.args(["bootout", &service_target])
.output()
.map_err(|e| format!("停止失败: {e}"))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.trim().is_empty() {
// 忽略"未加载"类错误
if !stderr.contains("No such process")
&& !stderr.contains("Could not find specified service")
&& !stderr.trim().is_empty()
{
return Err(format!("停止 {label} 失败: {stderr}"));
}
}
Ok(())
}
#[tauri::command]
pub fn restart_service(label: String) -> Result<(), String> {
let uid = current_uid()?;
let path = plist_path(&label);
// 先 unload，忽略错误（可能本来就没加载）
let domain_target = format!("gui/{}", uid);
let service_target = format!("gui/{}/{}", uid, label);
// 第一步：bootout 停止服务（忽略未加载错误）
let _ = Command::new("launchctl")
.args(["unload", &path])
.args(["bootout", &service_target])
.output();
std::thread::sleep(std::time::Duration::from_millis(500));
let output = Command::new("launchctl")
.args(["load", &path])
// 第二步：轮询等待旧进程退出，最多等 3 秒
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(3);
loop {
let (running, _) = check_service_status(uid, &label);
if !running {
break;
}
if std::time::Instant::now() >= deadline {
break; // 超时后继续尝试
}
std::thread::sleep(std::time::Duration::from_millis(200));
}
// 第三步：bootstrap 重新加载 plist
let bootstrap_out = Command::new("launchctl")
.args(["bootstrap", &domain_target, &path])
.output()
.map_err(|e| format!("重启失败: {e}"))?;
.map_err(|e| format!("重启 bootstrap 失败: {e}"))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
if !stderr.trim().is_empty() {
return Err(format!("重启 {label} 失败: {stderr}"));
if !bootstrap_out.status.success() {
let stderr = String::from_utf8_lossy(&bootstrap_out.stderr);
if !stderr.contains("already bootstrapped") && !stderr.trim().is_empty() {
return Err(format!("重启 {label} 失败 (bootstrap): {stderr}"));
}
}
// 第四步：kickstart -k 强制重启
let kickstart_out = Command::new("launchctl")
.args(["kickstart", "-k", &service_target])
.output()
.map_err(|e| format!("重启 kickstart 失败: {e}"))?;
if !kickstart_out.status.success() {
let stderr = String::from_utf8_lossy(&kickstart_out.stderr);
if !stderr.trim().is_empty() {
return Err(format!("重启 {label} 失败 (kickstart): {stderr}"));
}
}
Ok(())
}

4
src-tauri/src/lib.rs
View File

@@ -21,6 +21,10 @@ pub fn run() {
config::delete_backup,
config::reload_gateway,
config::test_model,
config::list_remote_models,
config::upgrade_openclaw,
config::install_gateway,
config::uninstall_gateway,
// 服务
service::get_services_status,
service::start_service,

3
src-tauri/tauri.conf.json
View File

@@ -21,8 +21,9 @@
"resizable": true
}
],
"withGlobalTauri": true,
"security": {
"csp": null
"csp": "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' http://localhost:* http://127.0.0.1:* http://192.168.*.* https://* http://*; img-src 'self' data:"
}
},
"bundle": {