dsh模块、快捷键调整

This commit is contained in:
zhongluofeng committed 2026-09-28 18:05:29 +08:00
1 parent ff1d5cd517
commit 7e65825d3e
54 files changed
+7082 -109

No files matched your search

+2035 -10
View File
File diff suppressed because it is too large. Load diff
+2 -2
View File
@@ -14,7 +14,7 @@
"tauri": "tauri"
},
"dependencies": {
"@lucide/vue": "^1.28.0",
"@lucide/vue": "^1.48.0",
"@tailwindcss/vite": "^4.3.2",
"@tauri-apps/api": "^2",
"@tauri-apps/plugin-autostart": "~2",
@@ -34,7 +34,7 @@
"pinia": "^3.0.4",
"pinyin-pro": "^3.28.2",
"qrcode": "^1.5.4",
"reka-ui": "^2.10.1",
"reka-ui": "^2.10.5",
"tailwind-merge": "^3.6.0",
"tailwindcss": "^4.3.2",
"vue": "^3.5.13",
+11
View File
@@ -22,6 +22,10 @@ pub mod windows {
/// 文件管理器独立窗口。**单例**(label 固定,不含会话 id):
/// 它不绑定会话,左右两栏各自选择连接,因此没有「每会话一个窗口」的语义。
pub const FILE_WINDOW: &str = "file-window";
/// dsh 模块的 Web UI 独立窗口(内容是远端 `http://127.0.0.1:<port>`,
/// 因此**不登记 capability**:远端页面不应获得任何 Tauri 权限)。
#[allow(dead_code)]
pub const DSH_WEB: &str = "dsh-web";
}
/// Tauri 事件名(与前端 constants::EVENTS 对应)
@@ -123,4 +127,11 @@ pub mod events {
pub const DOWNLOAD_REMOVED: &str = "download-removed";
/// 浏览器扩展通过 HTTP API 新增下载(负载 { id },前端据以为该任务创建专属下载窗口)
pub const DOWNLOAD_EXTENSION_ADDED: &str = "download-extension-added";
// dsh 模块:安装/下载进度(负载见 dsh::types::DshInstallProgress)
pub const DSH_INSTALL_PROGRESS: &str = "dsh-install-progress";
// dsh 模块:服务进程状态(负载见 dsh::types::DshServerStatus)
pub const DSH_SERVER_STATE: &str = "dsh-server-state";
/// dsh 模块:全局快捷键触发「打开独立窗口」(无负载)。
/// 窗口由前端创建(它持有带令牌的地址与 label 判重),Rust 侧只负责注册快捷键。
pub const DSH_OPEN_WINDOW: &str = "dsh-open-window";
}
+253
View File
@@ -0,0 +1,253 @@
//! AI 装载:把主设置(AI 服务)里的供应商映射进 dsh 的 `$DSH_HOME/settings.yaml`,
//! 并在启动服务时以环境变量注入 API Key。
//!
//! 安全姿态(对齐 `crate::ai` 与 `crate::secrets`):**密钥不落盘**。
//! settings.yaml 里只写 `apiKeyEnv`(环境变量名),明文由
//! [`crate::ai::provider_api_key`] 从系统凭据管理器读出后随子进程环境注入。
//!
//! 合并规则:只替换 `llm-pi-ai.providers` 下本模块管理的 `thing-*` 键与
//! `agent-default-model`,用户自己写的其它段落(profile patch / 第三方插件配置)
//! 原样保留;写盘前把旧文件备份为 `settings.yaml.bak`。
use serde_yaml::{Mapping, Value};
use tauri::AppHandle;
use super::types::{DshAiPreview, DshAiProvider};
use super::DshManager;
/// 本模块写入 settings.yaml 的供应商键前缀。
const PROVIDER_PREFIX: &str = "thing-";
/// `llm-pi-ai` 段名(dsh 的通用 OpenAI 兼容提供方插件)。
const LLM_SECTION: &str = "llm-pi-ai";
/// 默认模型段名。
const DEFAULT_MODEL_SECTION: &str = "agent-default-model";
impl DshManager {
/// dsh 侧供应商键(`thing-<id>`,只保留小写字母数字与短横线)。
fn dsh_provider_id(id: &str) -> String {
let sanitized: String = id
.trim()
.to_lowercase()
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
.collect();
format!("{PROVIDER_PREFIX}{sanitized}")
}
/// 环境变量名(`THING_AI_<ID>_KEY`)。
fn env_name(id: &str) -> String {
let sanitized: String = id
.trim()
.to_uppercase()
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
.collect();
format!("THING_AI_{sanitized}_KEY")
}
/// settings.yaml 路径(`$DSH_HOME/settings.yaml`)。
pub fn dsh_settings_path(&self) -> std::path::PathBuf {
self.home_dir().join("settings.yaml")
}
/// 当前将被映射的供应商列表(enabled 且 baseUrl 非空)。
pub fn ai_providers(&self) -> Vec<DshAiProvider> {
let settings = crate::ai::AiManager::load_settings_sync(&self.data_dir);
settings
.providers
.iter()
.filter(|p| p.enabled && !p.base_url.trim().is_empty() && !p.model.trim().is_empty())
.map(|p| DshAiProvider {
id: p.id.clone(),
name: p.name.clone(),
env_name: Self::env_name(&p.id),
base_url: p.base_url.clone(),
model: p.model.clone(),
has_key: !crate::ai::provider_api_key(&p.id).is_empty(),
})
.collect()
}
/// 构造本模块管理的配置片段(`llm-pi-ai.providers` + `agent-default-model`)。
fn build_patch(&self) -> (Mapping, Value, Option<String>, Option<String>) {
let settings = crate::ai::AiManager::load_settings_sync(&self.data_dir);
let mut providers = Mapping::new();
let mut default_pair: Option<(String, String)> = None;
let wanted = self.load_settings().provider_id;
for p in settings.providers.iter() {
if !p.enabled || p.base_url.trim().is_empty() || p.model.trim().is_empty() {
continue;
}
let dsh_id = Self::dsh_provider_id(&p.id);
let mut entry = Mapping::new();
entry.insert(
Value::String("displayName".into()),
Value::String(if p.name.trim().is_empty() {
p.id.clone()
} else {
p.name.clone()
}),
);
entry.insert(
Value::String("api".into()),
Value::String("openai-completions".into()),
);
entry.insert(
Value::String("baseURL".into()),
Value::String(p.base_url.trim().trim_end_matches('/').to_string()),
);
entry.insert(
Value::String("apiKeyEnv".into()),
Value::String(Self::env_name(&p.id)),
);
// 模型目录:当前模型 + 常见上下文窗口(字段名以 dsh 的 catalog 为准,
// 这里只写最稳定的 id/name,避免写错字段导致 dsh 拒绝配置)
let mut model = Mapping::new();
model.insert(Value::String("id".into()), Value::String(p.model.clone()));
model.insert(Value::String("name".into()), Value::String(p.model.clone()));
entry.insert(
Value::String("models".into()),
Value::Sequence(vec![Value::Mapping(model)]),
);
providers.insert(Value::String(dsh_id.clone()), Value::Mapping(entry));
let is_wanted = p.id == wanted || (wanted.is_empty() && default_pair.is_none());
if is_wanted {
default_pair = Some((dsh_id, p.model.clone()));
}
}
let default_value = match &default_pair {
Some((provider, model)) => {
let mut m = Mapping::new();
m.insert(Value::String("provider".into()), Value::String(provider.clone()));
m.insert(Value::String("model".into()), Value::String(model.clone()));
Value::Mapping(m)
}
None => Value::Null,
};
let default_provider = default_pair.as_ref().map(|(p, _)| p.clone());
let default_model = default_pair.map(|(_, m)| m);
(providers, default_value, default_provider, default_model)
}
/// 预览将要写入的 YAML(不含明文密钥)。
pub fn ai_preview(&self) -> DshAiPreview {
let (providers, default_value, default_provider, default_model) = self.build_patch();
let mut root = Mapping::new();
if !default_value.is_null() {
root.insert(Value::String(DEFAULT_MODEL_SECTION.into()), default_value);
}
let mut llm = Mapping::new();
llm.insert(Value::String("providers".into()), Value::Mapping(providers));
root.insert(Value::String(LLM_SECTION.into()), Value::Mapping(llm));
let yaml = serde_yaml::to_string(&Value::Mapping(root))
.unwrap_or_else(|e| format!("# 生成预览失败: {e}"));
DshAiPreview {
yaml,
providers: self.ai_providers(),
default_provider,
default_model,
settings_path: self.dsh_settings_path().to_string_lossy().to_string(),
}
}
/// 生成/合并 `$DSH_HOME/settings.yaml`(写盘前备份旧文件)。
pub fn ai_sync(&self, _app: &AppHandle) -> Result<(), String> {
let (providers, default_value, _, _) = self.build_patch();
let path = self.dsh_settings_path();
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent).map_err(|e| format!("创建 $DSH_HOME 失败: {e}"))?;
}
// 读现有文档(缺失/非映射时用空映射起步)
let existing = std::fs::read_to_string(&path).ok();
let mut doc = existing
.as_deref()
.and_then(|t| serde_yaml::from_str::<Value>(t).ok())
.filter(|v| v.is_mapping())
.unwrap_or_else(|| Value::Mapping(Mapping::new()));
let root = doc.as_mapping_mut().ok_or_else(|| "settings.yaml 结构非法".to_string())?;
// 备份
if existing.is_some() {
std::fs::write(path.with_extension("yaml.bak"), existing.as_deref().unwrap_or_default())
.map_err(|e| format!("备份 settings.yaml 失败: {e}"))?;
}
// llm-pi-ai.providers:只替换本模块管理的 thing-* 键
let llm_key = Value::String(LLM_SECTION.into());
let llm_entry = root
.entry(llm_key)
.or_insert_with(|| Value::Mapping(Mapping::new()));
if !llm_entry.is_mapping() {
*llm_entry = Value::Mapping(Mapping::new());
}
let llm_map = llm_entry.as_mapping_mut().expect("已保证为映射");
let providers_key = Value::String("providers".into());
let providers_entry = llm_map
.entry(providers_key)
.or_insert_with(|| Value::Mapping(Mapping::new()));
if !providers_entry.is_mapping() {
*providers_entry = Value::Mapping(Mapping::new());
}
let providers_map = providers_entry.as_mapping_mut().expect("已保证为映射");
// 先清掉上一次由本模块写入的键(用户自建的其它键保留)
let stale: Vec<Value> = providers_map
.keys()
.filter(|k| {
k.as_str()
.map(|s| s.starts_with(PROVIDER_PREFIX))
.unwrap_or(false)
})
.cloned()
.collect();
for key in stale {
providers_map.remove(&key);
}
for (key, value) in providers.iter() {
providers_map.insert(key.clone(), value.clone());
}
// agent-default-model
if default_value.is_null() {
root.remove(&Value::String(DEFAULT_MODEL_SECTION.into()));
} else {
root.insert(Value::String(DEFAULT_MODEL_SECTION.into()), default_value);
}
let text = serde_yaml::to_string(&doc).map_err(|e| format!("序列化 settings.yaml 失败: {e}"))?;
std::fs::write(&path, text).map_err(|e| format!("写入 settings.yaml 失败: {e}"))?;
crate::logger::log_info(
"dsh",
&format!("已同步 AI 供应商到 {}", path.display()),
);
Ok(())
}
/// 启动服务时注入的环境变量(供应商密钥 + DeepSeek 官方变量兜底)。
pub fn ai_env_vars(&self) -> Vec<(String, String)> {
let settings = crate::ai::AiManager::load_settings_sync(&self.data_dir);
let mut vars: Vec<(String, String)> = Vec::new();
for p in settings.providers.iter() {
if !p.enabled || p.base_url.trim().is_empty() || p.model.trim().is_empty() {
continue;
}
let key = crate::ai::provider_api_key(&p.id);
if key.is_empty() {
continue;
}
vars.push((Self::env_name(&p.id), key.clone()));
// DeepSeek 官方通道:dsh 内置 provider 直接读 DEEPSEEK_API_KEY
let is_deepseek = p.id.eq_ignore_ascii_case("deepseek")
|| p.preset.eq_ignore_ascii_case("deepseek")
|| p.base_url.contains("api.deepseek.com");
if is_deepseek {
vars.push(("DEEPSEEK_API_KEY".into(), key));
}
}
vars
}
}
+232
View File
@@ -0,0 +1,232 @@
//! dsh 模块的 Tauri 命令层。
//!
//! 前端统一经 `@/lib/bindings` 的 `commands.dsh*` 调用。
//! 进度事件 `dsh-install-progress`、状态事件 `dsh-server-state` 见
//! `crate::constants::events`(与 `src/lib/constants.ts` 的 `EVENTS` 对应)。
use tauri::Manager;
use tauri::{AppHandle, State};
use tauri_plugin_opener::OpenerExt;
use super::types::{
DshAiPreview, DshEnvStatus, DshInstallStatus, DshNpmRegistryInfo, DshServerStatus, DshSettings,
DshUpdateInfo, NodeStatus,
};
use super::DshManager;
/// 环境总览:Node / dsh / 服务状态 + 模块设置(模块首屏一次拿全)。
///
/// 声明为 `async`:Tauri 的**同步**命令在主线程执行,而本命令要跑
/// `node --version` 子进程探测,放主线程会造成界面卡顿。
/// (async 命令带 `State<'_>` 引用参数时必须返回 `Result`,故这里包一层 Ok。)
#[tauri::command]
#[specta::specta]
pub async fn dsh_env_status(state: State<'_, DshManager>) -> Result<DshEnvStatus, String> {
Ok(DshEnvStatus {
node: state.node_status(),
dsh: state.install_status(),
server: state.server_status(),
settings: state.load_settings(),
})
}
/// 重新探测 Node(系统 PATH + 托管目录)。同样因执行 `node --version` 而用 async。
#[tauri::command]
#[specta::specta]
pub async fn dsh_node_detect(state: State<'_, DshManager>) -> Result<NodeStatus, String> {
Ok(state.node_status())
}
/// 下载并安装便携 Node(`version` 为空 = 自动取满足要求的最新版)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_node_install(
app: AppHandle,
state: State<'_, DshManager>,
version: Option<String>,
) -> Result<NodeStatus, String> {
state.node_install(&app, version).await
}
/// 安装 dsh(`version` 为空 = latest)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_install(
app: AppHandle,
state: State<'_, DshManager>,
version: Option<String>,
) -> Result<DshInstallStatus, String> {
state.install(&app, version).await
}
/// 更新 dsh 到 latest(更新前停止服务,避免文件被占用)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_update(
app: AppHandle,
state: State<'_, DshManager>,
) -> Result<DshInstallStatus, String> {
state.stop_server(&app);
state.install(&app, None).await
}
/// 卸载 dsh(停止服务并删除包目录;保留设置与 $DSH_HOME)。
#[tauri::command]
#[specta::specta]
pub fn dsh_uninstall(app: AppHandle, state: State<'_, DshManager>) -> Result<(), String> {
state.uninstall(&app)
}
/// 取消进行中的下载 / 安装。
#[tauri::command]
#[specta::specta]
pub fn dsh_cancel_install(state: State<'_, DshManager>) {
state.request_cancel();
}
/// 查询 npm 上的可用版本。
#[tauri::command]
#[specta::specta]
pub async fn dsh_check_update(state: State<'_, DshManager>) -> Result<DshUpdateInfo, String> {
state.check_update().await
}
/// 读取「本次安装实际使用的 npm 源」及其来源。
///
/// 设置为空时 npm 会用自己配置链里的源(含系统 Node 的 `~/.npmrc`),
/// 这里把解析结果回给前端展示,让用户能看出「到底走的是哪个源」。
/// async:内部要跑 `node <npm-cli.js> config get registry` 子进程。
#[tauri::command]
#[specta::specta]
pub async fn dsh_npm_registry_info(
state: State<'_, DshManager>,
) -> Result<DshNpmRegistryInfo, String> {
Ok(state.npm_registry_info())
}
#[tauri::command]
#[specta::specta]
pub fn dsh_get_settings(state: State<'_, DshManager>) -> DshSettings {
state.load_settings()
}
/// 保存设置(即时生效;端口等改动在下次启动服务时生效)。
#[tauri::command]
#[specta::specta]
pub fn dsh_save_settings(
state: State<'_, DshManager>,
settings: DshSettings,
) -> Result<DshSettings, String> {
state.save_settings(settings)
}
/// 启动 dsh Web 服务。async:内部要 spawn 子进程 + 读凭据 + 写 settings.yaml,
/// 同步命令会在主线程执行从而卡住界面。
#[tauri::command]
#[specta::specta]
pub async fn dsh_start(app: AppHandle, state: State<'_, DshManager>) -> Result<DshServerStatus, String> {
state.start_server(&app)
}
/// 停止 dsh Web 服务。
#[tauri::command]
#[specta::specta]
pub async fn dsh_stop(app: AppHandle, state: State<'_, DshManager>) -> Result<DshServerStatus, String> {
state.stop_server(&app);
Ok(state.server_status())
}
/// 重启 dsh Web 服务。
#[tauri::command]
#[specta::specta]
pub async fn dsh_restart(app: AppHandle, state: State<'_, DshManager>) -> Result<DshServerStatus, String> {
state.stop_server(&app);
// Windows 上端口释放有延迟,稍等再起,避免 bind 预检误判占用
// (用异步 sleep:同步命令在主线程执行,阻塞 500ms 会冻界面)
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
state.start_server(&app)
}
/// 预览将写入 `$DSH_HOME/settings.yaml` 的内容(不含明文密钥)。
#[tauri::command]
#[specta::specta]
pub fn dsh_ai_preview(state: State<'_, DshManager>) -> DshAiPreview {
state.ai_preview()
}
/// 执行 AI 配置同步(合并写入 settings.yaml,写前备份)。
#[tauri::command]
#[specta::specta]
pub fn dsh_ai_sync(app: AppHandle, state: State<'_, DshManager>) -> Result<DshAiPreview, String> {
state.ai_sync(&app)?;
Ok(state.ai_preview())
}
/// 读取服务日志尾部。
#[tauri::command]
#[specta::specta]
pub fn dsh_log_tail(state: State<'_, DshManager>, lines: u32) -> String {
state.log_tail(lines as usize)
}
/// 读取 dsh 安装输出(npm 的 stdout/stderr 尾部)。
///
/// 只存在内存里(每次安装开始时清空),供「安装引导 → dsh 本体」页临时展示,
/// **不写应用日志、不落盘**。前端在安装进行中轮询这个命令。
#[tauri::command]
#[specta::specta]
pub fn dsh_install_log(state: State<'_, DshManager>) -> String {
state.install_log()
}
#[tauri::command]
#[specta::specta]
pub fn dsh_log_clear(state: State<'_, DshManager>) {
state.clear_log();
}
/// 在资源管理器中打开 dsh 模块目录。
#[tauri::command]
#[specta::specta]
pub fn dsh_open_dir(app: AppHandle, state: State<'_, DshManager>) -> Result<(), String> {
app.opener()
.open_path(state.root().to_string_lossy().to_string(), None::<&str>)
.map_err(|e| format!("打开目录失败: {e}"))
}
/// 注册(或切换)「打开 dsh 独立窗口」全局快捷键;传空字符串则注销。
///
/// 按下时只 emit `dsh-open-window` 事件,**窗口由前端创建**:前端才持有带令牌的
/// 启动地址,也能用 label 判重复用已开窗口(与截图模块「快捷键 → 事件 → 前端开窗」同构)。
#[tauri::command]
#[specta::specta]
pub async fn dsh_register_shortcut(app: AppHandle, shortcut: String) -> Result<(), String> {
crate::shortcut::register_shortcut(&app, "dsh", &shortcut, |a| {
use tauri::Emitter;
let _ = a.emit(crate::constants::events::DSH_OPEN_WINDOW, ());
})
}
/// 注销「打开 dsh 独立窗口」全局快捷键。
#[tauri::command]
#[specta::specta]
pub async fn dsh_unregister_shortcut(app: AppHandle) -> Result<(), String> {
crate::shortcut::unregister_shortcut(&app, "dsh");
Ok(())
}
/// 供 `setup.rs` 在应用启动时按设置自启服务。
pub fn autostart_if_enabled(app: &AppHandle) {
let manager = app.state::<DshManager>();
let settings = manager.load_settings();
if !settings.auto_start {
return;
}
if !manager.install_status().installed {
crate::logger::log_warn("dsh", "设置了自动启动,但 dsh 尚未安装,跳过");
return;
}
if let Err(e) = manager.start_server(app) {
crate::logger::log_warn("dsh", &format!("自动启动 dsh 服务失败: {e}"));
}
}
+397
View File
@@ -0,0 +1,397 @@
//! dsh 本体的安装 / 更新 / 卸载与版本查询。
//!
//! 安装方式:用当前解析出的 Node 自带的 npm,把 `@deepseek-ai/dsh` 装进模块目录
//! (`npm install --prefix {app_data}/dsh`)。好处是版本可锁、可配镜像源、可复用
//! 已下载的依赖,且启动时直接 `node <bin 入口>`,不依赖 PATH 上的全局 shim。
//!
//! npm 调用形态:`node <npm-cli.js> install ...`(不走 npm.cmd,理由见 `node.rs`)。
use std::io::{BufRead, BufReader};
use std::path::PathBuf;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use tauri::{AppHandle, Emitter};
use super::node::NODE_CANCELLED;
use super::types::{DshInstallProgress, DshInstallStatus, DshNpmRegistryInfo, DshUpdateInfo, DSH_PACKAGE};
use super::DshManager;
impl DshManager {
/// dsh 包目录
fn package_dir(&self) -> PathBuf {
self.install_root()
.join("node_modules")
.join("@deepseek-ai")
.join("dsh")
}
/// 已安装版本(读 package.json,不起进程)
pub fn installed_version(&self) -> Option<String> {
let text = std::fs::read_to_string(self.package_dir().join("package.json")).ok()?;
let value: serde_json::Value = serde_json::from_str(&text).ok()?;
value
.get("version")
.and_then(|v| v.as_str())
.map(|s| s.to_string())
}
/// dsh bin 入口(`package.json` 的 `bin.dsh`),启动服务时直接 `node <入口>`。
pub fn bin_entry(&self) -> Option<PathBuf> {
let dir = self.package_dir();
let text = std::fs::read_to_string(dir.join("package.json")).ok()?;
let value: serde_json::Value = serde_json::from_str(&text).ok()?;
let rel = match value.get("bin") {
Some(serde_json::Value::String(s)) => s.clone(),
Some(serde_json::Value::Object(map)) => map.get("dsh")?.as_str()?.to_string(),
_ => return None,
};
let entry = dir.join(rel);
entry.exists().then_some(entry)
}
/// 安装状态
pub fn install_status(&self) -> DshInstallStatus {
let version = self.installed_version();
let entry = self.bin_entry();
DshInstallStatus {
installed: version.is_some() && entry.is_some(),
version,
entry: entry.map(|p| p.to_string_lossy().to_string()),
dir: self.install_root().to_string_lossy().to_string(),
}
}
/// 模块设置里**显式**填写的 npm 源(空 = 未指定,交给 npm 自己解析)。
///
/// 与 [`Self::npm_registry_info`] 的区别:这里只认模块设置。安装时只在
/// 显式填写的情况下才传 `--registry`,其余情况让 npm 走自己的配置链
/// (环境变量 > 安装目录 `.npmrc` > 用户 `~/.npmrc` > 内置),
/// 这样「系统 node 以前配过的镜像」会被自动沿用。
fn registry_setting(&self) -> String {
self.load_settings()
.npm_registry
.trim()
.trim_end_matches('/')
.to_string()
}
/// npm 自身解析出的源(`node <npm-cli.js> config get registry`)。
///
/// 未检测到 Node/npm、或 npm 执行失败时为 None。cwd 取安装目录——
/// npm 的「项目级配置」来自 cwd 下的 `.npmrc`,要与真实安装保持一致。
pub fn npm_config_registry(&self) -> Option<String> {
let env = self.resolve_node_env()?;
let npm = env.npm?;
let mut cmd = std::process::Command::new(&env.node_exe);
cmd.arg(&npm).args(["config", "get", "registry"]);
// 安装目录可能还没创建(首次安装):退回模块目录,保证能起来
let install_root = self.install_root();
cmd.current_dir(if install_root.exists() {
install_root
} else {
self.root.clone()
});
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let out = cmd.output().ok()?;
if !out.status.success() {
return None;
}
let text = String::from_utf8_lossy(&out.stdout);
text.lines()
.map(|l| l.trim())
.find(|l| !l.is_empty())
.map(|l| l.trim_end_matches('/').to_string())
}
/// 本次安装/查询实际使用的源 + 来源(供 UI 展示与快捷切换)。
pub fn npm_registry_info(&self) -> DshNpmRegistryInfo {
let setting = self.registry_setting();
let npm_registry = self.npm_config_registry();
let (effective, source) = if !setting.is_empty() {
(setting.clone(), "setting")
} else if let Some(npm) = npm_registry.as_ref() {
(npm.clone(), "npm")
} else {
("https://registry.npmjs.org".to_string(), "fallback")
};
DshNpmRegistryInfo {
effective,
source: source.to_string(),
npm_registry,
setting,
}
}
/// 版本查询(reqwest)用的源:与安装保持一致(设置 → npm 配置 → 官方源)。
///
/// 之前这里在设置为空时硬编码官方源,导致「安装走国内镜像、检查更新却直连
/// npmjs.org」的不一致。
fn registry_for_query(&self) -> String {
self.npm_registry_info().effective
}
/// 查询 npm 上的可用版本(`dist-tags.latest` + 版本列表)。
pub async fn check_update(&self) -> Result<DshUpdateInfo, String> {
let url = format!("{}/{DSH_PACKAGE}", self.registry_for_query());
let resp = self
.http_client(30)
.get(&url)
.send()
.await
.map_err(|e| format!("查询 npm 版本失败: {e}"))?;
if !resp.status().is_success() {
return Err(format!("查询 npm 版本失败: HTTP {}", resp.status().as_u16()));
}
let value: serde_json::Value = resp
.json()
.await
.map_err(|e| format!("解析 npm 响应失败: {e}"))?;
let latest = value
.get("dist-tags")
.and_then(|t| t.get("latest"))
.and_then(|v| v.as_str())
.ok_or_else(|| "npm 响应缺少 dist-tags.latest".to_string())?
.to_string();
let mut versions: Vec<String> = value
.get("versions")
.and_then(|v| v.as_object())
.map(|m| m.keys().cloned().collect())
.unwrap_or_default();
// 取尾部若干(近似按发布顺序),再反转成最新在前
if versions.len() > 20 {
versions = versions.split_off(versions.len() - 20);
}
versions.reverse();
let current = self.installed_version();
Ok(DshUpdateInfo {
has_update: current.as_deref() != Some(latest.as_str()),
current,
latest,
versions,
})
}
/// 安装 / 更新 dsh(`version` 为空 = 装 latest)。
pub async fn install(&self, app: &AppHandle, version: Option<String>) -> Result<DshInstallStatus, String> {
self.cancel.store(false, Ordering::SeqCst);
// 每次安装开始清空上一次的输出缓冲
self.clear_install_log();
let result = self.install_inner(app, version).await;
self.cancel.store(false, Ordering::SeqCst);
if let Err(ref e) = result {
if e != NODE_CANCELLED {
self.push_install_log(&format!("[错误] {e}"));
self.emit_progress(app, "error", 0, 0, None, e);
}
}
result
}
async fn install_inner(&self, app: &AppHandle, version: Option<String>) -> Result<DshInstallStatus, String> {
let env = self
.resolve_node_env()
.ok_or_else(|| "未找到可用的 Node,请先完成第 1 步".to_string())?;
if !super::satisfies_node_requirement(&env.version) {
return Err(format!(
"当前 Node {} 不满足 dsh 要求({}),请先安装合规的 Node",
env.version,
super::NODE_REQUIRED
));
}
let npm = env
.npm
.clone()
.ok_or_else(|| "未找到 npm(Node 分发中缺少 npm-cli.js)".to_string())?;
let spec = version
.as_deref()
.map(|v| v.trim())
.filter(|v| !v.is_empty())
.map(|v| format!("{DSH_PACKAGE}@{v}"))
.unwrap_or_else(|| DSH_PACKAGE.to_string());
let install_dir = self.install_root();
// npm 的 prefix 目录不存在时由 npm 自己创建;这里先建一次,避免
// 自定义到新盘符目录时 npm 因父级缺失报 ENOENT
std::fs::create_dir_all(&install_dir)
.map_err(|e| format!("创建安装目录失败({}): {e}", install_dir.display()))?;
let mut args: Vec<String> = vec![
npm.to_string_lossy().to_string(),
"install".into(),
"--prefix".into(),
install_dir.to_string_lossy().to_string(),
spec.clone(),
"--no-fund".into(),
"--no-audit".into(),
"--loglevel".into(),
"info".into(),
];
let registry = self.registry_setting();
if !registry.is_empty() {
// 只在显式指定时才覆盖 npm 自己的配置链
args.push("--registry".into());
args.push(registry);
}
self.emit_progress(
app,
"installing",
0,
0,
None,
&format!("正在安装 {spec}(依赖较多,请稍候)..."),
);
// npm 不输出百分比:percent 恒为 0(前端按不确定进度展示),
// message 跟随 npm 自身的汇总行(`added N packages` 等)更新。
//
// 逐行输出**只进内存缓冲**(安装引导页临时展示),不写应用日志:
// npm 的 72 个依赖会刷出上千行,进应用日志只会淹没真正的运行日志。
let progress_app = app.clone();
let install_ring = self.install_ring_handle();
let on_line = Arc::new(move |line: &str| {
super::push_bounded(&install_ring, super::INSTALL_RING_CAPACITY, line);
let trimmed = line.trim();
if trimmed.starts_with("added ")
|| trimmed.starts_with("changed ")
|| trimmed.starts_with("removed ")
|| trimmed.starts_with("up to date")
{
let _ = progress_app.emit(
crate::constants::events::DSH_INSTALL_PROGRESS,
DshInstallProgress {
stage: "installing".into(),
percent: 0,
downloaded_bytes: 0,
total_bytes: None,
message: trimmed.to_string(),
},
);
}
});
let node_exe = env.node_exe.clone();
let pid_ref = self.install_pid.clone();
let result = tauri::async_runtime::spawn_blocking(move || {
run_npm(node_exe, args, install_dir, pid_ref, on_line)
})
.await
.map_err(|e| format!("安装任务执行失败: {e}"))?;
self.install_pid.store(0, Ordering::SeqCst);
if self.cancel.load(Ordering::SeqCst) {
return Err(NODE_CANCELLED.into());
}
result?;
let status = self.install_status();
if !status.installed {
return Err("npm 安装结束,但未找到 dsh 入口(请查看日志)".into());
}
self.emit_progress(
app,
"done",
100,
0,
None,
&format!(
"dsh {} 安装完成",
status.version.as_deref().unwrap_or("unknown")
),
);
crate::logger::log_info(
"dsh",
&format!(
"dsh 安装完成: {}",
status.version.as_deref().unwrap_or("unknown")
),
);
Ok(status)
}
/// 卸载 dsh:停止服务并删除包目录(保留设置与 $DSH_HOME)。
pub fn uninstall(&self, app: &AppHandle) -> Result<(), String> {
self.stop_server(app);
let dir = self.package_dir();
if dir.exists() {
std::fs::remove_dir_all(&dir).map_err(|e| format!("删除 dsh 目录失败: {e}"))?;
}
Ok(())
}
}
/// 同步执行 npm(阻塞线程内),逐行读输出交给 `on_line`;pid 记录供取消时 taskkill。
fn run_npm(
node_exe: PathBuf,
args: Vec<String>,
cwd: PathBuf,
pid_ref: Arc<std::sync::atomic::AtomicU64>,
on_line: Arc<dyn Fn(&str) + Send + Sync>,
) -> Result<(), String> {
let mut cmd = std::process::Command::new(&node_exe);
cmd.args(&args);
cmd.current_dir(&cwd);
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.stdin(std::process::Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let mut child = cmd
.spawn()
.map_err(|e| format!("启动 npm 失败({}): {e}", node_exe.display()))?;
let pid = child.id();
pid_ref.store(pid as u64, Ordering::SeqCst);
let stdout = child.stdout.take();
let stderr = child.stderr.take();
// 末 40 行留作失败时的错误摘要
let tail = Arc::new(std::sync::Mutex::new(Vec::<String>::new()));
let mut handles = Vec::new();
let pipes: [Option<Box<dyn std::io::Read + Send>>; 2] = [
stdout.map(|p| Box::new(p) as Box<dyn std::io::Read + Send>),
stderr.map(|p| Box::new(p) as Box<dyn std::io::Read + Send>),
];
for pipe in pipes.into_iter().flatten() {
let on_line = on_line.clone();
let tail = tail.clone();
handles.push(std::thread::spawn(move || {
let reader = BufReader::new(pipe);
for line in reader.lines().map_while(Result::ok) {
on_line(&line);
if let Ok(mut t) = tail.lock() {
if t.len() >= 40 {
t.remove(0);
}
t.push(line);
}
}
}));
}
let status = child.wait();
for h in handles {
let _ = h.join();
}
pid_ref.store(0, Ordering::SeqCst);
let status = status.map_err(|e| format!("等待 npm 结束失败: {e}"))?;
if status.success() {
return Ok(());
}
let text = tail.lock().map(|t| t.join("\n")).unwrap_or_default();
let chars: Vec<char> = text.chars().collect();
let skip = chars.len().saturating_sub(800);
Err(format!(
"npm 退出码 {}: {}",
status.code().unwrap_or(-1),
chars[skip..].iter().collect::<String>()
))
}
+484
View File
@@ -0,0 +1,484 @@
//! dsh 模块(DeepSeek Harness 外壳)。
//!
//! 模块定位:为 DeepSeek Harness(npm 包 `@deepseek-ai/dsh`)做安装、更新与
//! 生命周期管理,并把主设置里的 AI 供应商(含 DeepSeek API Key)装载给 dsh。
//! 模块页不内嵌浏览器,dsh 的 Web UI 通过独立窗口 / 系统浏览器打开。
//!
//! 目录布局(`{app_data_dir}/dsh`):
//! ```text
//! settings.json 模块自身设置(版本号 + 自愈)
//! node/ 便携 Node(仅系统 Node 不可用时)
//! node_modules/ @deepseek-ai/dsh 本地安装(npm --prefix)
//! home/ $DSH_HOME(settings.yaml / profiles / 会话)
//! workspace/ 默认工作区(dsh 进程的启动目录)
//! logs/web.log dsh 服务输出
//! ```
//!
//! 安全姿态:模块设置不含任何密钥;API Key 只在 spawn 子进程时以环境变量注入
//! (明文来自系统凭据管理器,见 [`crate::secrets`]),不写 dsh 的
//! `.credentials.yaml`、不落日志、不过前端。
mod ai_sync;
mod commands;
mod install;
mod node;
mod server;
mod types;
pub use commands::{
dsh_ai_preview, dsh_ai_sync, dsh_cancel_install, dsh_check_update, dsh_env_status,
dsh_get_settings, dsh_install, dsh_install_log, dsh_log_clear, dsh_log_tail,
dsh_node_detect, dsh_node_install, dsh_npm_registry_info, dsh_open_dir,
dsh_register_shortcut, dsh_restart, dsh_save_settings, dsh_start, dsh_stop,
dsh_uninstall, dsh_unregister_shortcut, dsh_update,
};
pub use commands::autostart_if_enabled;
// 仅重导出模块自身与子模块会经 `super::` 用到的类型(其余由各子模块直接从 types 取)
pub use types::{DshInstallProgress, DshSettings, NODE_REQUIRED};
use std::collections::VecDeque;
use std::path::PathBuf;
use std::process::Child;
use std::sync::atomic::{AtomicBool, AtomicU64};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tauri::AppHandle;
/// 设置内存缓存有效期(与其他模块的 500ms 一致)。
const SETTINGS_CACHE_TTL: Duration = Duration::from_millis(500);
/// 日志环形缓冲保留的最大行数(供「日志」页签快速读取)。
const LOG_RING_CAPACITY: usize = 500;
/// 安装输出缓冲保留的最大行数(npm 输出较啰嗦,只留最近一段)。
const INSTALL_RING_CAPACITY: usize = 200;
/// 服务进程条目(自管 stdio,不走 ProcessManager)。
pub(crate) struct ServerEntry {
pub child: Child,
pub pid: u32,
pub port: u16,
/// 启动时间(unix 秒)
pub started_at: i64,
}
struct SettingsCacheEntry {
read_at: Instant,
settings: DshSettings,
}
/// 解析出的 Node 运行环境。
pub(crate) struct NodeEnv {
/// system | managed
pub source: &'static str,
pub node_exe: PathBuf,
/// npm 入口(`node_modules/npm/bin/npm-cli.js`,用 `node <此路径>` 调用)
pub npm: Option<PathBuf>,
pub version: String,
}
/// dsh 模块管理器(Tauri State)。
pub struct DshManager {
/// 应用数据目录(`{app_data_dir}`)
data_dir: PathBuf,
/// 模块根目录(`{app_data_dir}/dsh`)
root: PathBuf,
settings_cache: Mutex<Option<SettingsCacheEntry>>,
/// 安装/下载取消标志
cancel: Arc<AtomicBool>,
/// 安装子进程 pid(取消时 taskkill /T)
install_pid: Arc<AtomicU64>,
/// 服务进程
server: Mutex<Option<ServerEntry>>,
/// 启动串行化锁(防并发双开)
start_lock: Mutex<()>,
/// HTTP 就绪标志
ready: Arc<AtomicBool>,
/// 本次进程的「带 token 启动地址」(从 dsh stdout 抓取)。
/// dsh web 的浏览器鉴权靠它首次访问换取 cookie,没它就只会拿到 401。
launch_url: Arc<Mutex<Option<String>>>,
/// 最近一次启动错误(端口占用 / 进程立即退出)
server_error: Mutex<Option<String>>,
/// 日志环形缓冲
log_ring: Arc<Mutex<VecDeque<String>>>,
/// 安装(npm)输出缓冲:只在模块页临时展示,**不落应用日志、不落盘**
install_ring: Arc<Mutex<VecDeque<String>>>,
}
impl DshManager {
pub fn new(app_data_dir: PathBuf) -> Self {
let root = app_data_dir.join("dsh");
for d in ["node", "logs", "home", "workspace"] {
std::fs::create_dir_all(root.join(d)).ok();
}
Self {
data_dir: app_data_dir,
root,
settings_cache: Mutex::new(None),
cancel: Arc::new(AtomicBool::new(false)),
install_pid: Arc::new(AtomicU64::new(0)),
server: Mutex::new(None),
start_lock: Mutex::new(()),
ready: Arc::new(AtomicBool::new(false)),
launch_url: Arc::new(Mutex::new(None)),
server_error: Mutex::new(None),
log_ring: Arc::new(Mutex::new(VecDeque::with_capacity(LOG_RING_CAPACITY))),
install_ring: Arc::new(Mutex::new(VecDeque::with_capacity(INSTALL_RING_CAPACITY))),
}
}
/// 模块根目录(「在文件夹中打开」用)
pub fn root(&self) -> &PathBuf {
&self.root
}
/// 便携 Node 目录
pub fn node_dir(&self) -> PathBuf {
self.root.join("node")
}
/// dsh 本体的安装根目录(npm `--prefix` 目标)。
///
/// 设置留空 = 模块目录。自定义时**只有 dsh 本体与它的 node_modules 跟随**,
/// 便携 Node / `$DSH_HOME` / 日志 / 模块设置仍留在应用数据目录——自定义路径
/// 若被移动或卸载,至少配置与日志还读得到,排障不会失联。
pub fn install_root(&self) -> PathBuf {
let raw = self.load_settings().install_dir;
let raw = raw.trim();
if raw.is_empty() {
self.root.clone()
} else {
PathBuf::from(raw)
}
}
/// `$DSH_HOME`
pub fn home_dir(&self) -> PathBuf {
let settings = self.load_settings();
if settings.dsh_home_mode == "user" {
dirs::home_dir()
.map(|h| h.join(".dsh"))
.unwrap_or_else(|| self.root.join("home"))
} else {
self.root.join("home")
}
}
/// dsh 进程的启动目录(工作区)
pub fn workspace_dir(&self) -> PathBuf {
let settings = self.load_settings();
let raw = settings.workspace.trim();
let dir = if raw.is_empty() {
self.root.join("workspace")
} else {
PathBuf::from(raw)
};
std::fs::create_dir_all(&dir).ok();
dir
}
pub fn log_path(&self) -> PathBuf {
self.root.join("logs").join("web.log")
}
pub fn settings_path(&self) -> PathBuf {
self.root.join("settings.json")
}
// ---------- 设置 ----------
pub fn load_settings(&self) -> DshSettings {
if let Ok(cache) = self.settings_cache.lock() {
if let Some(entry) = cache.as_ref() {
if entry.read_at.elapsed() < SETTINGS_CACHE_TTL {
return entry.settings.clone();
}
}
}
let mut settings = std::fs::read_to_string(self.settings_path())
.ok()
.and_then(|t| serde_json::from_str::<DshSettings>(&t).ok())
.unwrap_or_default();
let changed = settings.heal();
if changed {
self.write_settings(&settings).ok();
}
if let Ok(mut cache) = self.settings_cache.lock() {
*cache = Some(SettingsCacheEntry {
read_at: Instant::now(),
settings: settings.clone(),
});
}
settings
}
pub fn save_settings(&self, mut settings: DshSettings) -> Result<DshSettings, String> {
// 自定义安装目录必须是绝对路径:npm 的 --prefix 用相对路径会落到
// 进程当前目录(开发期即仓库根目录),这种"看起来生效其实装错地方"最难排查
let custom = settings.install_dir.trim();
if !custom.is_empty() && !std::path::Path::new(custom).is_absolute() {
return Err("dsh 安装目录必须是绝对路径(如 D:/Thing/dsh)".to_string());
}
settings.heal();
self.write_settings(&settings)?;
if let Ok(mut cache) = self.settings_cache.lock() {
*cache = Some(SettingsCacheEntry {
read_at: Instant::now(),
settings: settings.clone(),
});
}
Ok(settings)
}
fn write_settings(&self, settings: &DshSettings) -> Result<(), String> {
let json = serde_json::to_string_pretty(settings)
.map_err(|e| format!("序列化 dsh 设置失败: {e}"))?;
std::fs::write(self.settings_path(), json).map_err(|e| format!("写入 dsh 设置失败: {e}"))
}
// ---------- 日志 ----------
/// 追加一行到环形缓冲 + 落盘(服务输出走这里)。
pub(crate) fn push_log(&self, line: &str) {
push_log_shared(&self.log_ring, &self.log_path(), line);
}
/// 读取日志:优先环形缓冲;为空时回落到文件尾部。
pub fn log_tail(&self, lines: usize) -> String {
let lines = lines.clamp(1, LOG_RING_CAPACITY);
if let Ok(ring) = self.log_ring.lock() {
if !ring.is_empty() {
let skip = ring.len().saturating_sub(lines);
return ring
.iter()
.skip(skip)
.cloned()
.collect::<Vec<_>>()
.join("\n");
}
}
let text = std::fs::read_to_string(self.log_path()).unwrap_or_default();
let all: Vec<&str> = text.lines().collect();
let skip = all.len().saturating_sub(lines);
all[skip..].join("\n")
}
pub fn clear_log(&self) {
if let Ok(mut ring) = self.log_ring.lock() {
ring.clear();
}
std::fs::write(self.log_path(), b"").ok();
}
// ---------- 安装输出(仅内存,供安装引导页临时展示) ----------
/// 追加一行安装输出(已过滤疑似密钥)。
pub(crate) fn push_install_log(&self, line: &str) {
push_bounded(&self.install_ring, INSTALL_RING_CAPACITY, line);
}
/// 读取当前安装输出(每次安装开始时清空)。
pub fn install_log(&self) -> String {
self.install_ring
.lock()
.map(|r| r.iter().cloned().collect::<Vec<_>>().join("\n"))
.unwrap_or_default()
}
pub(crate) fn clear_install_log(&self) {
if let Ok(mut ring) = self.install_ring.lock() {
ring.clear();
}
}
/// 安装输出缓冲句柄(阻塞线程内的 on_line 闭包持有;'static 需要)。
pub(crate) fn install_ring_handle(
&self,
) -> Arc<Mutex<VecDeque<String>>> {
self.install_ring.clone()
}
// ---------- 代理 ----------
/// 按设置解析代理地址(mihomo mixed 端口)。返回 None 表示直连。
///
/// 只读代理模块设置文件里的 mixedPort,并用一次 300ms TCP 探测确认内核在线;
/// 内核没起来时静默直连(与 download_engine / translate 的降级姿态一致)。
pub(crate) fn proxy_url(&self) -> Option<String> {
if !self.load_settings().use_proxy {
return None;
}
let text = std::fs::read_to_string(self.data_dir.join("proxy").join("settings.json")).ok()?;
let value: serde_json::Value = serde_json::from_str(&text).ok()?;
let port = value.get("mixedPort").and_then(|v| v.as_u64())?;
if port == 0 || port > u16::MAX as u64 {
return None;
}
let port = port as u16;
let addr = std::net::SocketAddr::from(([127, 0, 0, 1], port));
if std::net::TcpStream::connect_timeout(&addr, Duration::from_millis(300)).is_err() {
return None;
}
Some(format!("http://127.0.0.1:{port}"))
}
// ---------- 事件 ----------
/// 推送安装/下载进度(stage: download | extracting | installing | done | error)。
pub(crate) fn emit_progress(
&self,
app: &AppHandle,
stage: &str,
percent: u8,
downloaded_bytes: u64,
total_bytes: Option<u64>,
message: &str,
) {
use tauri::Emitter;
let _ = app.emit(
crate::constants::events::DSH_INSTALL_PROGRESS,
DshInstallProgress {
stage: stage.into(),
percent,
downloaded_bytes,
total_bytes,
message: message.into(),
},
);
}
/// 推送服务状态(启动/停止/就绪变化时)。
pub(crate) fn emit_server_state(&self, app: &AppHandle) {
use tauri::Emitter;
let status = self.server_status();
let _ = app.emit(crate::constants::events::DSH_SERVER_STATE, status);
}
/// 构造 reqwest 客户端:按代理设置决定是否走 mihomo。
pub(crate) fn http_client(&self, timeout_secs: u64) -> reqwest::Client {
let mut builder = reqwest::Client::builder()
.user_agent("thing-app")
.timeout(Duration::from_secs(timeout_secs));
if let Some(proxy) = self.proxy_url() {
if let Ok(p) = reqwest::Proxy::all(&proxy) {
builder = builder.proxy(p);
}
}
builder.build().unwrap_or_else(|_| reqwest::Client::new())
}
}
/// 过滤日志行里的疑似密钥(`sk-` 形态)与 URL 里的会话令牌。
pub(crate) fn sanitize_log_line(line: &str) -> String {
let line = mask_token_in_url(line);
let mut out = String::with_capacity(line.len());
for token in line.split_inclusive(char::is_whitespace) {
let trimmed = token.trim_end();
if trimmed.starts_with("sk-") && trimmed.len() > 12 {
out.push_str("sk-***");
out.push_str(&token[trimmed.len()..]);
} else {
out.push_str(token);
}
}
out
}
/// 掩码 URL 里的 `token=` 取值(`?token=xxx` → `?token=***`)。
///
/// dsh web 的浏览器会话令牌等同于「对该 loopback 服务(能执行代码)的完全访问权」,
/// 不该落进应用日志与 logs/web.log;真正的带令牌地址经 IPC 单独给前端使用。
fn mask_token_in_url(line: &str) -> String {
const NEEDLE: &str = "token=";
let mut out = String::with_capacity(line.len());
let mut cursor = 0usize;
while let Some(rel) = line[cursor..].find(NEEDLE) {
let start = cursor + rel + NEEDLE.len();
out.push_str(&line[cursor..start]);
let after = &line[start..];
let end = after
.find(|c: char| c.is_whitespace() || matches!(c, ')' | ',' | '"' | '\'' | '&'))
.unwrap_or(after.len());
out.push_str("***");
cursor = start + end;
}
out.push_str(&line[cursor..]);
out
}
/// 从 dsh 输出行里解析「带 token 的启动地址」。
///
/// `dsh web` 就绪后会打印(见 dsh-web-app 的 announceReady):
/// `dsh web: http://127.0.0.1:3080/?token=<随机令牌> (LAN: http://<lan>:3080/?token=<...>)`
///
/// 浏览器鉴权靠这个地址首次访问换取签名 cookie(dsh-client-connection 的 BrowserAuth);
/// 令牌是**每次进程随机生成**的,无法推导,只能从输出里取。
/// 取第一个(loopback)地址,忽略随后的 LAN 地址。
pub(crate) fn parse_launch_url(line: &str) -> Option<String> {
let start = line.find("http://").or_else(|| line.find("https://"))?;
let rest = &line[start..];
let end = rest.find(char::is_whitespace).unwrap_or(rest.len());
let url = rest[..end].trim_end_matches(|c: char| c == ')' || c == ',');
url.contains("token=").then(|| url.to_string())
}
/// 共享的日志写入(服务 stdout/stderr reader 线程与探测线程用)。
///
/// reader 线程拿不到 `&DshManager`(需要 'static),因此把环形缓冲与日志路径
/// 单独传进来。
pub(crate) fn push_log_shared(
ring: &Arc<Mutex<VecDeque<String>>>,
log_path: &PathBuf,
line: &str,
) {
let line = push_bounded(ring, LOG_RING_CAPACITY, line);
if let Ok(mut f) = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(log_path)
{
use std::io::Write;
let _ = writeln!(f, "{line}");
}
}
/// 有界环形缓冲追加(**不落盘**),返回写入后的文本。
///
/// 安装输出走这里:只要内存,不写应用日志、不写文件——用户明确要求安装日志
/// 仅在安装引导页临时展示(npm 输出啰嗦,进应用日志只会淹没真正的运行日志)。
pub(crate) fn push_bounded(
ring: &Arc<Mutex<VecDeque<String>>>,
capacity: usize,
line: &str,
) -> String {
let line = sanitize_log_line(line);
if let Ok(mut r) = ring.lock() {
if r.len() >= capacity {
r.pop_front();
}
r.push_back(line.clone());
}
line
}
/// 解析 "v24.9.0" / "24.9.0" → (24, 9, 0)
pub(crate) fn parse_version(raw: &str) -> Option<(u32, u32, u32)> {
let cleaned = raw.trim().trim_start_matches('v');
let core = cleaned.split('-').next().unwrap_or(cleaned);
let mut it = core.split('.');
let major = it.next()?.parse::<u32>().ok()?;
let minor = it.next().unwrap_or("0").parse::<u32>().ok()?;
let patch = it.next().unwrap_or("0").parse::<u32>().ok()?;
Some((major, minor, patch))
}
/// 是否满足 dsh 的要求:`^22.19.0 || >=24.0.0`
pub(crate) fn satisfies_node_requirement(raw: &str) -> bool {
let Some((major, minor, patch)) = parse_version(raw) else {
return false;
};
match major {
22 => (minor, patch) >= (19, 0),
24.. => true,
_ => false,
}
}
+399
View File
@@ -0,0 +1,399 @@
//! Node 运行环境:探测系统 Node / 下载并解压便携 Node。
//!
//! dsh 要求 Node `^22.19.0 || >=24.0.0`。策略(用户已确认):
//! 优先复用 PATH 上的系统 Node,版本不满足或缺失时才下载官方便携版到
//! `{app_data}/dsh/node`(官方 zip 内含 npm/npx,因此托管 Node 自带 npm)。
use std::fs;
use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use std::sync::atomic::Ordering;
use futures_util::StreamExt;
use tauri::AppHandle;
use super::types::{NodeStatus, NODE_REQUIRED};
use super::{satisfies_node_requirement, DshManager, NodeEnv};
/// 用户取消时返回的错误信息(前端静默处理,不弹错误 toast)。
pub(crate) const NODE_CANCELLED: &str = "已取消";
impl DshManager {
/// 系统 PATH 上的 node.exe
pub fn system_node(&self) -> Option<PathBuf> {
which_node()
}
/// 托管便携 Node 的 node.exe
pub fn managed_node(&self) -> Option<PathBuf> {
let exe = self.node_dir().join(if cfg!(windows) { "node.exe" } else { "bin/node" });
exe.exists().then_some(exe)
}
/// 解析实际使用的 Node 环境(按 nodeSource 设置)。
pub fn resolve_node_env(&self) -> Option<NodeEnv> {
let settings = self.load_settings();
let system = self.system_node();
let managed = self.managed_node();
let system_ok = system
.as_ref()
.and_then(|p| node_version(p))
.map(|v| satisfies_node_requirement(&v))
.unwrap_or(false);
// 选定 (是否托管, 可执行文件)
let chosen: Option<(bool, PathBuf)> = match settings.node_source.as_str() {
"system" => system.map(|p| (false, p)),
"managed" => managed.map(|p| (true, p)),
// auto:系统满足即复用,否则回落托管;两者都没有时退回系统 Node 仅用于展示版本
_ => {
if system_ok {
system.map(|p| (false, p))
} else {
managed
.map(|p| (true, p))
.or_else(|| system.map(|p| (false, p)))
}
}
};
let (is_managed, exe) = chosen?;
let version = node_version(&exe).unwrap_or_default();
let npm = npm_cli_js(&exe);
Some(NodeEnv {
source: if is_managed { "managed" } else { "system" },
node_exe: exe,
npm,
version,
})
}
/// 当前 Node 状态(供 UI 首屏展示)。
pub fn node_status(&self) -> NodeStatus {
match self.resolve_node_env() {
Some(env) => {
let satisfies = satisfies_node_requirement(&env.version);
NodeStatus {
source: if env.source == "managed" { "managed".into() } else { "system".into() },
path: Some(env.node_exe.to_string_lossy().to_string()),
version: Some(env.version),
satisfies,
required: NODE_REQUIRED.into(),
}
}
None => NodeStatus {
source: "none".into(),
path: None,
version: None,
satisfies: false,
required: NODE_REQUIRED.into(),
},
}
}
/// 下载并安装便携 Node(进度经 `dsh-install-progress` 推送)。
///
/// `version` 为空时自动解析满足要求的最新版本(优先 LTS)。
pub async fn node_install(&self, app: &AppHandle, version: Option<String>) -> Result<NodeStatus, String> {
if !cfg!(windows) {
return Err("便携 Node 安装仅支持 Windows,请改用系统 Node(nodeSource = system)".into());
}
self.cancel.store(false, Ordering::SeqCst);
let result = self.node_install_inner(app, version).await;
self.cancel.store(false, Ordering::SeqCst);
if let Err(ref e) = result {
if e != NODE_CANCELLED {
self.emit_progress(app, "error", 0, 0, None, e);
}
}
result
}
async fn node_install_inner(&self, app: &AppHandle, version: Option<String>) -> Result<NodeStatus, String> {
let base = self.node_mirror_base();
let version = match version.filter(|v| !v.trim().is_empty()) {
Some(v) => normalize_version(&v),
None => {
self.emit_progress(app, "download", 0, 0, None, "正在解析 Node 版本...");
let requested = self.load_settings().managed_node_version;
if requested.trim().is_empty() {
self.resolve_latest_node_version(&base).await?
} else {
normalize_version(&requested)
}
}
};
let arch = platform_arch();
let url = format!("{base}/{version}/node-{version}-{arch}.zip");
let zip_path = self.node_dir().join("node-download.zip");
self.emit_progress(
app,
"download",
1,
0,
None,
&format!("正在下载 Node {version}..."),
);
self.download_to_file(app, &url, &zip_path, "正在下载 Node").await?;
if self.cancel.load(Ordering::SeqCst) {
let _ = fs::remove_file(&zip_path);
return Err(NODE_CANCELLED.into());
}
// 解压:官方 zip 顶层是 node-vX-win-x64/,剥掉这一层直接落到 node/
self.emit_progress(app, "extracting", 92, 0, None, "正在解压...");
let dest = self.node_dir();
if dest.exists() {
fs::remove_dir_all(&dest).map_err(|e| format!("清理旧 Node 目录失败: {e}"))?;
}
fs::create_dir_all(&dest).map_err(|e| format!("创建 Node 目录失败: {e}"))?;
if let Err(e) = extract_zip_strip_top(&zip_path, &dest) {
let _ = fs::remove_file(&zip_path);
return Err(format!("解压 Node 失败: {e}"));
}
let _ = fs::remove_file(&zip_path);
let exe = dest.join("node.exe");
if !exe.exists() {
return Err("解压后未找到 node.exe".into());
}
let actual = node_version(&exe).unwrap_or(version.clone());
self.emit_progress(app, "done", 100, 0, None, &format!("Node {actual} 安装完成"));
crate::logger::log_info("dsh", &format!("便携 Node 安装完成: {actual} ({})", exe.display()));
Ok(self.node_status())
}
/// 托管 Node 的镜像基址(`{base}/{version}/node-{version}-win-x64.zip`)。
fn node_mirror_base(&self) -> String {
let mirror = self.load_settings().node_mirror;
let mirror = mirror.trim().trim_end_matches('/');
if mirror.is_empty() {
"https://nodejs.org/dist".to_string()
} else {
mirror.to_string()
}
}
/// 解析满足要求的最新 Node 版本(优先 LTS)。
async fn resolve_latest_node_version(&self, base: &str) -> Result<String, String> {
let url = format!("{base}/index.json");
let resp = self
.http_client(30)
.get(&url)
.send()
.await
.map_err(|e| format!("获取 Node 版本列表失败: {e}"))?;
if !resp.status().is_success() {
return Err(format!("获取 Node 版本列表失败: HTTP {}", resp.status().as_u16()));
}
let list: Vec<serde_json::Value> = resp
.json()
.await
.map_err(|e| format!("解析 Node 版本列表失败: {e}"))?;
let mut latest_lts: Option<(u32, u32, u32, String)> = None;
let mut latest_any: Option<(u32, u32, u32, String)> = None;
for item in list {
let Some(version) = item.get("version").and_then(|v| v.as_str()) else {
continue;
};
if !satisfies_node_requirement(version) {
continue;
}
let Some(parsed) = super::parse_version(version) else {
continue;
};
let is_lts = item.get("lts").map(|l| !l.is_null() && l != false).unwrap_or(false);
if latest_any.as_ref().map(|(maj, min, pat, _)| (parsed.0, parsed.1, parsed.2) > (*maj, *min, *pat)).unwrap_or(true) {
latest_any = Some((parsed.0, parsed.1, parsed.2, version.to_string()));
}
if is_lts
&& latest_lts
.as_ref()
.map(|(maj, min, pat, _)| (parsed.0, parsed.1, parsed.2) > (*maj, *min, *pat))
.unwrap_or(true)
{
latest_lts = Some((parsed.0, parsed.1, parsed.2, version.to_string()));
}
}
latest_lts
.or(latest_any)
.map(|(_, _, _, v)| v)
.ok_or_else(|| "未找到满足 dsh 要求的 Node 版本".to_string())
}
/// 流式下载到文件(带取消 + 进度事件,percent 0-90)。
pub(crate) async fn download_to_file(
&self,
app: &AppHandle,
url: &str,
dest: &Path,
label: &str,
) -> Result<(), String> {
let resp = self
.http_client(1800)
.get(url)
.send()
.await
.map_err(|e| format!("请求下载失败({url}): {e}"))?;
let status = resp.status();
if !status.is_success() {
return Err(format!("下载返回 HTTP {}", status.as_u16()));
}
let total = resp.content_length();
let mut file = fs::File::create(dest).map_err(|e| format!("创建文件失败: {e}"))?;
let mut stream = resp.bytes_stream();
let mut downloaded: u64 = 0;
let mut last_percent: u8 = 0;
while let Some(chunk) = stream.next().await {
if self.cancel.load(Ordering::SeqCst) {
drop(file);
fs::remove_file(dest).ok();
return Err(NODE_CANCELLED.into());
}
let chunk = chunk.map_err(|e| format!("下载中断: {e}"))?;
file.write_all(&chunk).map_err(|e| format!("写入文件失败: {e}"))?;
downloaded += chunk.len() as u64;
let percent = total
.filter(|t| *t > 0)
.map(|t| ((downloaded as f64 / t as f64) * 90.0) as u8)
.unwrap_or(0)
.min(90);
if percent >= last_percent + 1 {
last_percent = percent;
self.emit_progress(
app,
"download",
percent,
downloaded,
total,
&format!("{label} {:.1} MB", downloaded as f64 / 1048576.0),
);
}
}
file.flush().ok();
self.emit_progress(app, "download", 90, downloaded, total, "下载完成");
Ok(())
}
/// 请求取消(下载 / 安装 / 解压均轮询此标志)。
pub(crate) fn request_cancel(&self) {
self.cancel.store(true, Ordering::SeqCst);
let pid = self.install_pid.load(Ordering::SeqCst);
if pid > 0 {
taskkill_tree(pid);
}
}
}
/// 官方分发包的平台标识(Windows x64 / arm64)。
fn platform_arch() -> &'static str {
match std::env::consts::ARCH {
"aarch64" => "win-arm64",
_ => "win-x64",
}
}
/// PATH 上查找 node 可执行文件。
fn which_node() -> Option<PathBuf> {
let name = if cfg!(windows) { "node.exe" } else { "node" };
let path_var = std::env::var_os("PATH")?;
for dir in std::env::split_paths(&path_var) {
let candidate = dir.join(name);
if candidate.is_file() {
return Some(candidate);
}
}
None
}
/// 取 node 目录下的 npm 入口(`node_modules/npm/bin/npm-cli.js`)。
///
/// 直接 `node npm-cli.js` 而不是 `npm.cmd`:`.cmd` 在 Windows 上无法被
/// CreateProcess 直接执行(需经 `cmd /C`,而 cmd 的引号规则易踩坑),
/// 且批处理 shim 会多出一层进程影响取消时的进程树清理。
fn npm_cli_js(node_exe: &Path) -> Option<PathBuf> {
let dir = node_exe.parent()?;
let candidates = [
dir.join("node_modules").join("npm").join("bin").join("npm-cli.js"),
dir.join("lib").join("node_modules").join("npm").join("bin").join("npm-cli.js"),
];
candidates.into_iter().find(|p| p.is_file())
}
/// 执行 `node --version` 取版本号。
fn node_version(node_exe: &Path) -> Option<String> {
let mut cmd = std::process::Command::new(node_exe);
cmd.arg("--version");
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let out = cmd.output().ok()?;
if !out.status.success() {
return None;
}
let text = String::from_utf8_lossy(&out.stdout).trim().to_string();
(!text.is_empty()).then_some(text)
}
/// 规范化版本号:补上 `v` 前缀。
fn normalize_version(raw: &str) -> String {
let t = raw.trim();
if t.starts_with('v') {
t.to_string()
} else {
format!("v{t}")
}
}
/// 解压 zip 并剥掉顶层目录(Node 官方分发包顶层是 `node-vX-win-x64/`)。
pub(crate) fn extract_zip_strip_top(zip_path: &Path, dest: &Path) -> Result<(), String> {
let file = fs::File::open(zip_path).map_err(|e| format!("打开 zip 失败: {e}"))?;
let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("读取 zip 失败: {e}"))?;
for i in 0..archive.len() {
let mut entry = archive.by_index(i).map_err(|e| format!("读取条目失败: {e}"))?;
let Some(name) = entry.enclosed_name() else {
continue;
};
// 剥掉第一层目录;顶层目录条目本身(只有一个组件)跳过
let mut comps = name.components();
comps.next();
let rel: PathBuf = comps.map(|c| c.as_os_str()).collect();
if rel.as_os_str().is_empty() {
continue;
}
let outpath = dest.join(&rel);
if entry.is_dir() {
fs::create_dir_all(&outpath).map_err(|e| e.to_string())?;
} else {
if let Some(parent) = outpath.parent() {
fs::create_dir_all(parent).map_err(|e| e.to_string())?;
}
let mut outfile = fs::File::create(&outpath).map_err(|e| e.to_string())?;
let mut buf = [0u8; 8192];
loop {
let n = entry.read(&mut buf).map_err(|e| e.to_string())?;
if n == 0 {
break;
}
outfile.write_all(&buf[..n]).map_err(|e| e.to_string())?;
}
}
}
Ok(())
}
/// 强杀进程树(安装子进程取消用)。
pub(crate) fn taskkill_tree(pid: u64) {
let mut cmd = std::process::Command::new("taskkill");
cmd.args(["/F", "/T", "/PID", &pid.to_string()])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.stdin(std::process::Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let _ = cmd.status();
}
+316
View File
@@ -0,0 +1,316 @@
//! dsh 服务进程生命周期:spawn(自管 stdio)→ 就绪探测 → 日志落盘 → 停止。
//!
//! 进程形态参照 `music/bridge.rs` 的长驻子进程:stdout/stderr 各起一个 reader 线程,
//! 逐行写入日志环形缓冲与 `logs/web.log`;子进程加入 Job Object,应用退出时由
//! 系统自动回收。启动命令为 `node <dsh bin 入口> web --port <端口> --no-open`:
//! `--no-open` 让 dsh 不要自己弹出系统浏览器(由本模块的按钮决定何时打开)。
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{SocketAddr, TcpListener, TcpStream};
use std::process::{Command, Stdio};
use std::sync::atomic::Ordering;
use std::time::{Duration, Instant};
use tauri::AppHandle;
use super::types::DshServerStatus;
use super::{DshManager, ServerEntry};
/// 就绪探测总时长上限。
const READY_TIMEOUT: Duration = Duration::from_secs(60);
impl DshManager {
/// 进程是否存活。
fn server_running(&self) -> bool {
let mut guard = match self.server.lock() {
Ok(g) => g,
Err(_) => return false,
};
match guard.as_mut() {
Some(entry) => entry
.child
.try_wait()
.ok()
.map(|w| w.is_none())
.unwrap_or(false),
None => false,
}
}
/// 当前服务状态。
pub fn server_status(&self) -> DshServerStatus {
let running = self.server_running();
// 运行中一律用**进程实际使用的端口**(设置可能在启动后被改过,
// 此时 UI 展示的地址必须仍是真正监听的那个)
let entry = self
.server
.lock()
.ok()
.and_then(|g| g.as_ref().map(|e| (e.pid, e.port, e.started_at)));
let (pid, port, started_at) = match (running, entry) {
(true, Some((pid, port, started_at))) => (Some(pid), port, Some(started_at)),
_ => (None, self.load_settings().port, None),
};
DshServerStatus {
running,
ready: running && self.ready.load(Ordering::SeqCst),
pid,
port,
url: format!("http://127.0.0.1:{port}"),
launch_url: if running {
self.launch_url.lock().ok().and_then(|g| g.clone())
} else {
None
},
started_at,
error: self.server_error.lock().ok().and_then(|g| g.clone()),
}
}
/// 启动 dsh Web 服务(幂等:已在运行直接返回当前状态)。
pub fn start_server(&self, app: &AppHandle) -> Result<DshServerStatus, String> {
if self.server_running() {
return Ok(self.server_status());
}
let _guard = self.start_lock.lock().map_err(|e| e.to_string())?;
if self.server_running() {
return Ok(self.server_status());
}
// 清理可能残留的旧条目
if let Ok(mut g) = self.server.lock() {
g.take();
}
self.ready.store(false, Ordering::SeqCst);
if let Ok(mut g) = self.server_error.lock() {
*g = None;
}
// 上一进程的令牌必须清掉:沿用旧令牌会让新进程的首次访问仍然 401
if let Ok(mut g) = self.launch_url.lock() {
*g = None;
}
let settings = self.load_settings();
let port = settings.port;
let env = self
.resolve_node_env()
.ok_or_else(|| "未找到可用的 Node,请先完成环境安装".to_string())?;
if !super::satisfies_node_requirement(&env.version) {
return Err(format!(
"当前 Node {} 不满足 dsh 要求({})",
env.version,
super::NODE_REQUIRED
));
}
let entry = self
.bin_entry()
.ok_or_else(|| "未安装 dsh,请先完成安装".to_string())?;
// 端口预检:dsh 自身在端口占用时的报错不够直观,这里提前给出可读错误
if let Err(e) = TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], port))) {
let msg = format!("端口 {port} 不可用({e}),请在配置中更换端口");
self.set_server_error(&msg);
return Err(msg);
}
// 同步 AI 供应商配置(写 settings.yaml + 收集环境变量)
if settings.ai_sync {
if let Err(e) = self.ai_sync(app) {
// 同步失败不阻塞启动,只记日志(用户可在 dsh 内手动配置)
crate::logger::log_warn("dsh", &format!("AI 配置同步失败(继续启动): {e}"));
}
}
let env_vars = self.ai_env_vars();
let mut cmd = Command::new(&env.node_exe);
cmd.arg(&entry)
.arg("web")
.arg("--port")
.arg(port.to_string())
.arg("--no-open");
cmd.current_dir(self.workspace_dir());
cmd.env("DSH_HOME", self.home_dir());
for (key, value) in env_vars {
cmd.env(key, value);
}
cmd.stdout(Stdio::piped())
.stderr(Stdio::piped())
.stdin(Stdio::null());
crate::process_manager::setup_creation_flags(&mut cmd);
let mut child = cmd.spawn().map_err(|e| {
let msg = format!("启动 dsh 失败({}): {e}", env.node_exe.display());
self.set_server_error(&msg);
msg
})?;
let pid = child.id();
crate::process_manager::assign_to_job(&child);
let stdout = child.stdout.take();
let stderr = child.stderr.take();
if let Ok(mut g) = self.server.lock() {
*g = Some(ServerEntry {
child,
pid,
port,
started_at: chrono::Utc::now().timestamp(),
});
}
// 输出 → 日志。stdout 额外承担「抓取带令牌启动地址」的职责:
// dsh 就绪后打印 `dsh web: http://127.0.0.1:<port>/?token=<令牌>`,
// 浏览器鉴权靠这个地址换 cookie(我们传了 --no-open,没别人替它换)。
let ring = self.log_ring_handle();
let log_path = self.log_path();
if let Some(out) = stdout {
spawn_stdout_reader(out, ring.clone(), log_path.clone(), self.launch_url.clone(), app.clone());
}
if let Some(err) = stderr {
spawn_log_reader(err, ring, log_path);
}
crate::logger::log_info(
"dsh",
&format!("dsh 服务已启动 (pid: {pid}, 端口: {port})"),
);
self.emit_server_state(app);
// 就绪探测(后台线程,不阻塞启动返回)
self.spawn_ready_probe(app.clone(), port);
Ok(self.server_status())
}
/// 停止 dsh 服务(kill 快速返回,wait 移到后台线程)。
pub fn stop_server(&self, app: &AppHandle) {
let entry = self.server.lock().ok().and_then(|mut g| g.take());
self.ready.store(false, Ordering::SeqCst);
if let Ok(mut g) = self.launch_url.lock() {
*g = None;
}
if let Some(mut entry) = entry {
// 先杀进程树(dsh 可能派生子进程),再关本进程句柄
super::node::taskkill_tree(entry.pid as u64);
let _ = entry.child.kill();
std::thread::spawn(move || {
let _ = entry.child.wait();
});
crate::logger::log_info("dsh", &format!("dsh 服务已停止 (pid: {})", entry.pid));
}
self.emit_server_state(app);
}
fn set_server_error(&self, message: &str) {
if let Ok(mut g) = self.server_error.lock() {
*g = Some(message.to_string());
}
}
/// 就绪探测:轮询 HTTP,成功置 ready;进程提前退出则记录错误原因。
fn spawn_ready_probe(&self, app: AppHandle, port: u16) {
std::thread::spawn(move || {
use tauri::Manager;
let deadline = Instant::now() + READY_TIMEOUT;
loop {
{
let manager = app.state::<DshManager>();
if http_probe(port) {
manager.ready.store(true, Ordering::SeqCst);
manager.emit_server_state(&app);
return;
}
if !manager.server_running() {
// 进程已退出:不必等到超时
let line = "dsh 服务进程已退出,未能就绪(详见日志)".to_string();
manager.push_log(&line);
manager.set_server_error(&line);
crate::logger::log_warn("dsh", &line);
manager.emit_server_state(&app);
return;
}
}
if Instant::now() >= deadline {
break;
}
std::thread::sleep(Duration::from_millis(500));
}
let manager = app.state::<DshManager>();
manager.emit_server_state(&app);
});
}
/// 日志环形缓冲句柄(reader/探测线程持有)。
pub(crate) fn log_ring_handle(&self) -> std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<String>>> {
self.log_ring.clone()
}
}
/// 起一个 reader 线程把子进程输出逐行写进日志(stdout 与 stderr 类型不同,故泛型化)。
fn spawn_log_reader<R: Read + Send + 'static>(
pipe: R,
ring: std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<String>>>,
log_path: std::path::PathBuf,
) {
std::thread::spawn(move || {
let reader = BufReader::new(pipe);
for line in reader.lines().map_while(Result::ok) {
super::push_log_shared(&ring, &log_path, &line);
}
});
}
/// stdout reader:写日志之外,还从 `dsh web: ...?token=<令牌>` 行里抓取启动地址。
///
/// 抓到后置入 `launch_url` 并推送状态事件,前端据此启用「独立窗口 / 浏览器打开」。
/// 注意锁的粒度:先算好是否需要通知再释放锁——`emit_server_state` 会读
/// `launch_url`,持锁调用会自锁。
fn spawn_stdout_reader<R: Read + Send + 'static>(
pipe: R,
ring: std::sync::Arc<std::sync::Mutex<std::collections::VecDeque<String>>>,
log_path: std::path::PathBuf,
launch_url: std::sync::Arc<std::sync::Mutex<Option<String>>>,
app: tauri::AppHandle,
) {
std::thread::spawn(move || {
let reader = BufReader::new(pipe);
for line in reader.lines().map_while(Result::ok) {
// 先解析原文(落日志时 token 会被掩码)
let parsed = super::parse_launch_url(&line);
if let Some(url) = parsed {
let changed = match launch_url.lock() {
Ok(mut slot) => {
let changed = slot.as_deref() != Some(url.as_str());
if changed {
*slot = Some(url);
}
changed
}
Err(_) => false,
};
if changed {
use tauri::Manager;
if let Some(manager) = app.try_state::<DshManager>() {
manager.emit_server_state(&app);
}
}
}
super::push_log_shared(&ring, &log_path, &line);
}
});
}
/// 极简 HTTP 探测:TCP 连上并收到以 `HTTP/` 开头的响应即视为就绪。
fn http_probe(port: u16) -> bool {
let addr = SocketAddr::from(([127, 0, 0, 1], port));
let Ok(mut stream) = TcpStream::connect_timeout(&addr, Duration::from_millis(500)) else {
return false;
};
let _ = stream.set_read_timeout(Some(Duration::from_millis(800)));
let req = format!("GET / HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n");
if stream.write_all(req.as_bytes()).is_err() {
return false;
}
let mut buf = [0u8; 16];
match stream.read(&mut buf) {
Ok(n) if n >= 5 => &buf[..5] == b"HTTP/",
_ => false,
}
}
+239
View File
@@ -0,0 +1,239 @@
//! dsh 模块(DeepSeek Harness 外壳)的数据类型。
//!
//! 全部走 specta 导出到 `src/lib/bindings.ts`,字段 camelCase。
use serde::{Deserialize, Serialize};
use specta::Type;
/// dsh 对 Node 的版本要求(`^22.19.0 || >=24.0.0`)。
pub const NODE_REQUIRED: &str = "^22.19.0 || >=24.0.0";
/// dsh npm 包名。
pub const DSH_PACKAGE: &str = "@deepseek-ai/dsh";
/// 默认 Web UI 端口。
pub const DEFAULT_PORT: u16 = 3080;
/// 默认「打开独立窗口」全局快捷键(与 quickpanel/截图等同为全局快捷键,格式见
/// `keyboard-types` 的 `Modifiers+Code`:修饰键名大小写不敏感,数字键名即 `5`)。
pub const DEFAULT_SHORTCUT: &str = "Alt+D";
/// 模块设置(`{app_data}/dsh/settings.json`)。
///
/// 独立文件,**不写** `thing_app_settings`(appStore 的 SETTINGS_VERSION 迁移会清空用户设置)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", default)]
pub struct DshSettings {
/// 结构版本号;变更时按版本校正字段
pub version: u32,
/// Node 来源偏好:auto(系统优先,缺失回落托管)| system | managed
pub node_source: String,
/// 指定下载的 Node 版本(空 = 自动取满足要求的最新版)
pub managed_node_version: String,
/// Node 分发包镜像前缀(空 = 官方 nodejs.org;国内可用 npmmirror)
pub node_mirror: String,
/// npm registry(空 = 官方源)
pub npm_registry: String,
/// 下载 Node / npm 安装是否走代理模块(mihomo mixed 端口)
pub use_proxy: bool,
/// Web UI 端口(dsh 的 `--port` 参数)
pub port: u16,
/// 应用启动时自动拉起 dsh 服务
pub auto_start: bool,
/// 全局快捷键:打开 dsh Web 独立窗口(空 = 未启用)
pub shortcut: String,
/// $DSH_HOME 模式:managed({app_data}/dsh/home)| user(~/.dsh)
pub dsh_home_mode: String,
/// 工作区目录(空 = {app_data}/dsh/workspace),即 dsh 进程的启动目录
pub workspace: String,
/// dsh 本体的安装目录(npm `--prefix` 目标,即 node_modules 所在位置)。
/// 空 = {app_data}/dsh。
/// 只有 dsh 本体与它的 node_modules 跟随此设置;便携 Node、$DSH_HOME、
/// 日志与模块设置仍固定在应用数据目录,避免自定义路径失效时连配置都读不到。
pub install_dir: String,
/// 映射为 dsh 默认模型的 Thing AI 供应商 id
pub provider_id: String,
/// 启动前自动同步 settings.yaml
pub ai_sync: bool,
}
impl Default for DshSettings {
fn default() -> Self {
Self {
version: 1,
node_source: "auto".into(),
managed_node_version: String::new(),
node_mirror: String::new(),
npm_registry: String::new(),
use_proxy: true,
port: DEFAULT_PORT,
auto_start: false,
shortcut: DEFAULT_SHORTCUT.into(),
dsh_home_mode: "managed".into(),
workspace: String::new(),
install_dir: String::new(),
provider_id: "deepseek".into(),
ai_sync: true,
}
}
}
impl DshSettings {
/// 自愈:非法/越界字段夹回默认;版本推进。返回是否发生变更。
pub fn heal(&mut self) -> bool {
let mut changed = false;
if !matches!(self.node_source.as_str(), "auto" | "system" | "managed") {
self.node_source = "auto".into();
changed = true;
}
if !matches!(self.dsh_home_mode.as_str(), "managed" | "user") {
self.dsh_home_mode = "managed".into();
changed = true;
}
if self.port == 0 {
self.port = DEFAULT_PORT;
changed = true;
}
if self.version < 1 {
self.version = 1;
changed = true;
}
// v1 → v2:默认「打开独立窗口」快捷键从 Ctrl+5 改为 Alt+D。
// 仍等于旧默认值 = 用户没改过,直接迁移;改过(或清空禁用)的原样保留 ——
// 版本号已推进,之后即使再改回旧键位也不会被改写(同 translate 的 heal 约定)。
if self.version < 2 {
if self.shortcut.trim().eq_ignore_ascii_case("ctrl+5") {
self.shortcut = DEFAULT_SHORTCUT.to_string();
}
self.version = 2;
changed = true;
}
changed
}
}
/// Node 运行环境状态。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct NodeStatus {
/// system | managed | none
pub source: String,
/// node.exe 路径
pub path: Option<String>,
/// 版本号(如 v24.9.0)
pub version: Option<String>,
/// 是否满足 dsh 的版本要求
pub satisfies: bool,
/// 版本要求文案(供 UI 展示)
pub required: String,
}
/// dsh 本体安装状态。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshInstallStatus {
pub installed: bool,
pub version: Option<String>,
/// bin 入口(dist/bin.js 绝对路径)
pub entry: Option<String>,
/// 安装目录
pub dir: String,
}
/// dsh 服务进程状态。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshServerStatus {
/// 进程存活
pub running: bool,
/// HTTP 端口已可访问
pub ready: bool,
pub pid: Option<u32>,
pub port: u16,
/// 规范地址(不含令牌,用于界面展示)
pub url: String,
/// 带令牌的启动地址(**用于打开界面**)。
///
/// dsh web 的浏览器鉴权是「进程级随机令牌 → 首次访问换 cookie」:
/// 直接访问 [`Self::url`] 只会拿到 401。令牌每次启动都不同,只能从
/// dsh 的输出里抓取,因此进程刚起来时这里可能为 None(等它打印)。
pub launch_url: Option<String>,
/// 启动时间(unix 秒)
pub started_at: Option<i64>,
/// 启动失败原因(端口占用 / 进程立即退出等)
pub error: Option<String>,
}
/// 模块首屏环境总览。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshEnvStatus {
pub node: NodeStatus,
pub dsh: DshInstallStatus,
pub server: DshServerStatus,
pub settings: DshSettings,
}
/// 安装/下载进度事件载荷(与 kernel/music 同构)。
/// stage: download | extracting | installing | done | error
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshInstallProgress {
pub stage: String,
pub percent: u8,
#[specta(type = f64)]
pub downloaded_bytes: u64,
#[specta(type = Option<f64>)]
pub total_bytes: Option<u64>,
pub message: String,
}
/// dsh 版本更新信息。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshUpdateInfo {
pub current: Option<String>,
pub latest: String,
pub has_update: bool,
/// 可选版本(倒序,最多 20 个)
pub versions: Vec<String>,
}
/// npm 源信息(安装引导页展示「本次实际用哪个源」并提供快捷切换)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshNpmRegistryInfo {
/// 本次安装/查询实际会使用的源(已去掉末尾 `/`)
pub effective: String,
/// effective 的来源:setting(模块设置显式指定)| npm(npm 自身配置链)| fallback(默认官方源)
pub source: String,
/// npm 自身解析出的源(环境变量 > 安装目录 .npmrc > 用户 ~/.npmrc > 内置),
/// 未检测到 Node/npm 时为 None
pub npm_registry: Option<String>,
/// 模块设置里显式填写的值(空 = 未指定,交给 npm 解析)
pub setting: String,
}
/// AI 供应商映射结果(预览用,不含明文密钥)。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshAiProvider {
/// Thing 侧供应商 id
pub id: String,
pub name: String,
/// 写入 settings.yaml 的 apiKeyEnv 变量名
pub env_name: String,
pub base_url: String,
pub model: String,
/// 凭据管理器中是否已配置密钥
pub has_key: bool,
}
/// settings.yaml 同步预览。
#[derive(Debug, Clone, Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DshAiPreview {
/// 将被写入的 YAML 文本(密钥位置只有环境变量名)
pub yaml: String,
pub providers: Vec<DshAiProvider>,
pub default_provider: Option<String>,
pub default_model: Option<String>,
pub settings_path: String,
}
+40 -2
View File
@@ -4,6 +4,7 @@ mod ai;
mod clipboard;
mod constants;
mod download_engine;
mod dsh;
mod logger;
mod mihomo_manager;
mod monitor_kernel;
@@ -73,6 +74,13 @@ use music::{
AudioEngine, MusicManager, RemoteManager, SmtcController, SmtcMetaCache,
};
use network_monitor::network_status;
use dsh::{
dsh_ai_preview, dsh_ai_sync, dsh_cancel_install, dsh_check_update, dsh_env_status,
dsh_get_settings, dsh_install, dsh_install_log, dsh_log_clear, dsh_log_tail,
dsh_node_detect, dsh_node_install, dsh_npm_registry_info, dsh_open_dir,
dsh_register_shortcut, dsh_restart, dsh_save_settings, dsh_start, dsh_stop,
dsh_uninstall, dsh_unregister_shortcut, dsh_update,
};
use osd_window::{
osd_apply_overlay_style, osd_begin_drag, osd_set_bounds, osd_set_click_through,
osd_set_topmost, osd_start_drag_watch, osd_start_game_watch, osd_start_topmost_watch,
@@ -309,6 +317,13 @@ fn export_bindings() {
terminal_history_clear, terminal_history_run,
// AI 命令助手(P2)——与 `run()` 里那份保持一致,否则 bindings.ts 缺类型
terminal_ai_engines, terminal_ai_suggest,
// dsh(22)——与 `run()` 里那份保持一致,否则 bindings.ts 缺类型
dsh_env_status, dsh_node_detect, dsh_node_install, dsh_install, dsh_update,
dsh_uninstall, dsh_cancel_install, dsh_check_update, dsh_npm_registry_info,
dsh_get_settings, dsh_save_settings, dsh_register_shortcut,
dsh_unregister_shortcut, dsh_start, dsh_stop, dsh_restart,
dsh_ai_preview, dsh_ai_sync, dsh_log_tail, dsh_install_log, dsh_log_clear,
dsh_open_dir,
])
.export(Typescript::default(), "../src/lib/bindings.ts")
.expect("failed to export bindings");
@@ -332,7 +347,7 @@ pub fn run() {
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_dialog::init())
// 截图快捷键改由 screenshot::shortcut::register_shortcut(on_shortcut)按需注册,
// 支持自定义;默认 Ctrl+Alt+A 由前端 store 启动时注册
// 支持自定义;默认 F3 由前端 store 启动时注册
.plugin(tauri_plugin_global_shortcut::Builder::new().build())
.plugin(tauri_plugin_notification::init())
.plugin(
@@ -724,7 +739,30 @@ pub fn run() {
terminal_save_template,
// AI 命令助手(P2)
terminal_ai_engines,
terminal_ai_suggest
terminal_ai_suggest,
// dsh(22)
dsh_env_status,
dsh_node_detect,
dsh_node_install,
dsh_install,
dsh_update,
dsh_uninstall,
dsh_cancel_install,
dsh_check_update,
dsh_npm_registry_info,
dsh_get_settings,
dsh_save_settings,
dsh_register_shortcut,
dsh_unregister_shortcut,
dsh_start,
dsh_stop,
dsh_restart,
dsh_ai_preview,
dsh_ai_sync,
dsh_log_tail,
dsh_install_log,
dsh_log_clear,
dsh_open_dir
])
.setup(setup::init)
.on_window_event(|window, event| {
+4
View File
@@ -117,6 +117,10 @@ enum Control {
struct Session {
shared: Arc<Shared>,
ctrl: Sender<Control>,
/// 播放线程句柄:**故意不 join**(见 `stop_current` 的说明),唯一作用是与会话
/// 同生共死 —— 会话 Arc 释放时它一起被丢弃,丢弃即 detach,线程收到 Stop 后
/// 自行收尾并释放输出流。因为从不解绑/join,此字段除「持有」外没有任何读取。
#[allow(dead_code)]
handle: JoinHandle<()>,
}
+2 -2
View File
@@ -523,7 +523,7 @@ impl MusicManager {
/// 解析桥接要用的 Python 运行时。
/// 便携版优先:musicdl 只装入便携运行时,系统 Python 无法保证装有 musicdl;
/// 无便携版时退回系统 Python(此时 search 会报 musicdl 未安装,引导用户装便携版)。
pub fn resolve_python(&self) -> Result<PythonEnv, String> {
pub(crate) fn resolve_python(&self) -> Result<PythonEnv, String> {
if let Some(env) = self.detect_bundled_python() {
return Ok(env);
}
@@ -534,7 +534,7 @@ impl MusicManager {
}
/// 便携 Python 是否可用(exe 存在且能跑 --version)
pub fn detect_bundled_python(&self) -> Option<PythonEnv> {
pub(crate) fn detect_bundled_python(&self) -> Option<PythonEnv> {
detect_bundled_python_at(&self.bundled_python_exe())
}
+11 -1
View File
@@ -77,6 +77,12 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
let _ = ai.load_settings();
app.manage(ai);
// ===== dsh 模块:DshManager(DeepSeek Harness 外壳) =====
// 仅注册状态:Node/dsh 的安装、服务进程与 settings.yaml 同步都在命令调用时按需触发
// (启动阶段只有 autoStart 开启时才拉起服务,见 init 末尾)。
let dsh = crate::dsh::DshManager::new(app_data_dir.clone());
app.manage(dsh);
// ===== 翻译模块:TranslateManager =====
// 仅注册状态:设置与密钥都在命令调用时按需读取,启动阶段不发任何网络请求
// (模型可用性校验因此改为懒校验:首次翻译失败时解释原因 + 设置页手动拉取模型列表)。
@@ -181,8 +187,12 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
monitor.auto_start_on_launch(app.handle());
}
// dsh:开启"自动启动"且已安装时拉起 Web 服务(后台线程执行就绪探测,不阻塞启动)。
// 「打开独立窗口」快捷键由前端 dshStore 启动时注册(同截图模块约定)。
crate::dsh::autostart_if_enabled(app.handle());
// 截图快捷键由前端 screenshotStore 启动时调用 screenshot_register_shortcut 注册
// (支持自定义,默认 Ctrl+Alt+A),此处不再硬编码注册
// (支持自定义,默认 F3),此处不再硬编码注册
Ok(())
}
+21 -3
View File
@@ -662,9 +662,10 @@ impl Default for TemplateEntry {
/// - 新建/关闭标签用 `Ctrl+Shift+T/W`,与浏览器习惯一致。
/// - 跳转标签用 `Alt+1..9`:`Ctrl+数字` 已被翻译模块的 `Ctrl+2`(翻译面板)占用,
/// 而 `Alt+数字` 在终端里通常不产生控制字符,冲突面最小。
/// - `newDetachedWindow`(`Ctrl+3`)是这张表里唯一**全局**生效的一条:它由前端
///- `newDetachedWindow`(`Alt+T`)是这张表里唯一**全局**生效的一条:它由前端
/// `TerminalQuickLaunch` 注册成系统级热键(任意应用前台可触发),放在这里只为
/// 跟着终端设置一起存与改。`Ctrl+2` 已被翻译面板占用,`Ctrl+3` 是空闲的相邻键位。
/// 跟着终端设置一起存与改。`Alt+T` 与翻译面板的 `Alt+F`、dsh 的 `Alt+D`
/// 同处 `Alt+字母` 段,互不冲突。
pub fn default_shortcuts() -> Vec<ShortcutBinding> {
let pairs: &[(&str, &str)] = &[
("copy", "Ctrl+Shift+C"),
@@ -692,7 +693,7 @@ pub fn default_shortcuts() -> Vec<ShortcutBinding> {
// action(未知 action 会被剔除),前端设置表里有而这里没有 = 用户改完下次启动就被清掉。
("detachWindow", "Ctrl+Shift+N"),
// 全局生效的一条(见上方说明):新建独立窗口 + 选择会话
("newDetachedWindow", "Ctrl+3"),
("newDetachedWindow", "Alt+T"),
];
pairs
.iter()
@@ -832,6 +833,23 @@ impl TerminalSettings {
changed = true;
}
// v2 → v3:新建独立窗口的默认键位从 Ctrl+3 改为 Alt+T(Ctrl+数字 与
// 翻译面板、终端「Alt+数字 跳标签」两处分段冲突,统一收到 Alt+字母)。
// 仍等于旧默认值 = 用户没改过,直接迁移;改过的原样保留。
if self.version < 3 {
if let Some(binding) = self
.shortcuts
.iter_mut()
.find(|s| s.action == "newDetachedWindow")
{
if binding.keys.trim().eq_ignore_ascii_case("ctrl+3") {
binding.keys = "Alt+T".to_string();
}
}
self.version = 3;
changed = true;
}
changed
}
}
+15 -2
View File
@@ -190,7 +190,7 @@ impl Default for TranslateEngineConfig {
pub struct SelectionSettings {
/// 总开关:打开翻译面板时是否尝试读取当前划词作为候选
pub enabled: bool,
/// 打开翻译面板的全局快捷键(默认 Ctrl+2)
/// 打开翻译面板的全局快捷键(默认 Alt+F)
#[serde(default = "default_panel_shortcut")]
pub panel_shortcut: String,
/// 取词方式:
@@ -209,7 +209,7 @@ pub struct SelectionSettings {
}
fn default_panel_shortcut() -> String {
"Ctrl+2".to_string()
"Alt+F".to_string()
}
impl Default for SelectionSettings {
@@ -427,6 +427,19 @@ impl TranslateSettings {
self.version = 2;
changed = true;
}
// v2 → v3:翻译面板默认快捷键从 Ctrl+2 改为 Alt+F(把 Ctrl+数字 让给终端)。
// 仍等于旧默认值 = 用户没改过,直接迁移;改过或已清空的原样保留。
if self.version < 3 {
if self.selection
.panel_shortcut
.trim()
.eq_ignore_ascii_case("ctrl+2")
{
self.selection.panel_shortcut = default_panel_shortcut();
}
self.version = 3;
changed = true;
}
changed
}
}
+27
View File
@@ -0,0 +1,27 @@
<script lang="ts" setup>
import type { StepperRootEmits, StepperRootProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperRoot, useForwardPropsEmits } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperRootProps & { class?: HTMLAttributes["class"] }>()
const emits = defineEmits<StepperRootEmits>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardPropsEmits(delegatedProps, emits)
</script>
<template>
<StepperRoot
v-slot="slotProps"
:class="cn(
'flex gap-2',
props.class,
)"
v-bind="forwarded"
>
<slot v-bind="slotProps" />
</StepperRoot>
</template>
@@ -0,0 +1,19 @@
<script lang="ts" setup>
import type { StepperDescriptionProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperDescription, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperDescriptionProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperDescription v-slot="slotProps" v-bind="forwarded" :class="cn('text-xs text-muted-foreground', props.class)">
<slot v-bind="slotProps" />
</StepperDescription>
</template>
@@ -0,0 +1,32 @@
<script lang="ts" setup>
import type { StepperIndicatorProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperIndicator, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperIndicatorProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperIndicator
v-slot="slotProps"
v-bind="forwarded"
:class="cn(
'inline-flex items-center justify-center rounded-full text-muted-foreground/50 w-8 h-8',
// Disabled
'group-data-[disabled]:text-muted-foreground group-data-[disabled]:opacity-50',
// Active
'group-data-[state=active]:bg-primary group-data-[state=active]:text-primary-foreground',
// Completed
'group-data-[state=completed]:bg-accent group-data-[state=completed]:text-accent-foreground',
props.class,
)"
>
<slot v-bind="slotProps" />
</StepperIndicator>
</template>
+23
View File
@@ -0,0 +1,23 @@
<script lang="ts" setup>
import type { StepperItemProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperItem, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperItemProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperItem
v-slot="slotProps"
v-bind="forwarded"
:class="cn('flex items-center gap-2 group data-[disabled]:pointer-events-none', props.class)"
>
<slot v-bind="slotProps" />
</StepperItem>
</template>
@@ -0,0 +1,27 @@
<script lang="ts" setup>
import type { StepperSeparatorProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperSeparator, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperSeparatorProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperSeparator
v-bind="forwarded"
:class="cn(
'bg-muted',
// Disabled
'group-data-[disabled]:bg-muted group-data-[disabled]:opacity-50',
// Completed
'group-data-[state=completed]:bg-accent',
props.class,
)"
/>
</template>
@@ -0,0 +1,19 @@
<script lang="ts" setup>
import type { StepperTitleProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperTitle, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperTitleProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperTitle v-bind="forwarded" :class="cn('text-md font-semibold whitespace-nowrap', props.class)">
<slot />
</StepperTitle>
</template>
@@ -0,0 +1,22 @@
<script lang="ts" setup>
import type { StepperTriggerProps } from "reka-ui"
import type { HTMLAttributes } from "vue"
import { reactiveOmit } from "@vueuse/core"
import { StepperTrigger, useForwardProps } from "reka-ui"
import { cn } from "@/lib/utils"
const props = defineProps<StepperTriggerProps & { class?: HTMLAttributes["class"] }>()
const delegatedProps = reactiveOmit(props, "class")
const forwarded = useForwardProps(delegatedProps)
</script>
<template>
<StepperTrigger
v-bind="forwarded"
:class="cn('p-1 flex flex-col items-center text-center gap-1 rounded-md', props.class)"
>
<slot />
</StepperTrigger>
</template>
+7
View File
@@ -0,0 +1,7 @@
export { default as Stepper } from "./Stepper.vue"
export { default as StepperDescription } from "./StepperDescription.vue"
export { default as StepperIndicator } from "./StepperIndicator.vue"
export { default as StepperItem } from "./StepperItem.vue"
export { default as StepperSeparator } from "./StepperSeparator.vue"
export { default as StepperTitle } from "./StepperTitle.vue"
export { default as StepperTrigger } from "./StepperTrigger.vue"
+212 -1
View File
@@ -853,6 +853,73 @@ export const commands = {
* 帮助模型理解「接着上一步做什么」。
*/
terminalAiSuggest: (engineId: string, intent: string, context: string) => __TAURI_INVOKE<CommandSuggestion[]>("terminal_ai_suggest", { engineId, intent, context }),
/**
* 环境总览:Node / dsh / 服务状态 + 模块设置(模块首屏一次拿全)。
*
* 声明为 `async`:Tauri 的**同步**命令在主线程执行,而本命令要跑
* `node --version` 子进程探测,放主线程会造成界面卡顿。
* (async 命令带 `State<'_>` 引用参数时必须返回 `Result`,故这里包一层 Ok。)
*/
dshEnvStatus: () => __TAURI_INVOKE<DshEnvStatus>("dsh_env_status"),
/** 重新探测 Node(系统 PATH + 托管目录)。同样因执行 `node --version` 而用 async。 */
dshNodeDetect: () => __TAURI_INVOKE<NodeStatus>("dsh_node_detect"),
/** 下载并安装便携 Node(`version` 为空 = 自动取满足要求的最新版)。 */
dshNodeInstall: (version: string | null) => __TAURI_INVOKE<NodeStatus>("dsh_node_install", { version }),
/** 安装 dsh(`version` 为空 = latest)。 */
dshInstall: (version: string | null) => __TAURI_INVOKE<DshInstallStatus>("dsh_install", { version }),
/** 更新 dsh 到 latest(更新前停止服务,避免文件被占用)。 */
dshUpdate: () => __TAURI_INVOKE<DshInstallStatus>("dsh_update"),
/** 卸载 dsh(停止服务并删除包目录;保留设置与 $DSH_HOME)。 */
dshUninstall: () => __TAURI_INVOKE<null>("dsh_uninstall"),
/** 取消进行中的下载 / 安装。 */
dshCancelInstall: () => __TAURI_INVOKE<void>("dsh_cancel_install"),
/** 查询 npm 上的可用版本。 */
dshCheckUpdate: () => __TAURI_INVOKE<DshUpdateInfo>("dsh_check_update"),
/**
* 读取「本次安装实际使用的 npm 源」及其来源。
*
* 设置为空时 npm 会用自己配置链里的源(含系统 Node 的 `~/.npmrc`),
* 这里把解析结果回给前端展示,让用户能看出「到底走的是哪个源」。
* async:内部要跑 `node <npm-cli.js> config get registry` 子进程。
*/
dshNpmRegistryInfo: () => __TAURI_INVOKE<DshNpmRegistryInfo>("dsh_npm_registry_info"),
dshGetSettings: () => __TAURI_INVOKE<DshSettings>("dsh_get_settings"),
/** 保存设置(即时生效;端口等改动在下次启动服务时生效)。 */
dshSaveSettings: (settings: DshSettings) => __TAURI_INVOKE<DshSettings>("dsh_save_settings", { settings }),
/**
* 注册(或切换)「打开 dsh 独立窗口」全局快捷键;传空字符串则注销。
*
* 按下时只 emit `dsh-open-window` 事件,**窗口由前端创建**:前端才持有带令牌的
* 启动地址,也能用 label 判重复用已开窗口(与截图模块「快捷键 → 事件 → 前端开窗」同构)。
*/
dshRegisterShortcut: (shortcut: string) => __TAURI_INVOKE<null>("dsh_register_shortcut", { shortcut }),
/** 注销「打开 dsh 独立窗口」全局快捷键。 */
dshUnregisterShortcut: () => __TAURI_INVOKE<null>("dsh_unregister_shortcut"),
/**
* 启动 dsh Web 服务。async:内部要 spawn 子进程 + 读凭据 + 写 settings.yaml,
* 同步命令会在主线程执行从而卡住界面。
*/
dshStart: () => __TAURI_INVOKE<DshServerStatus>("dsh_start"),
/** 停止 dsh Web 服务。 */
dshStop: () => __TAURI_INVOKE<DshServerStatus>("dsh_stop"),
/** 重启 dsh Web 服务。 */
dshRestart: () => __TAURI_INVOKE<DshServerStatus>("dsh_restart"),
/** 预览将写入 `$DSH_HOME/settings.yaml` 的内容(不含明文密钥)。 */
dshAiPreview: () => __TAURI_INVOKE<DshAiPreview>("dsh_ai_preview"),
/** 执行 AI 配置同步(合并写入 settings.yaml,写前备份)。 */
dshAiSync: () => __TAURI_INVOKE<DshAiPreview>("dsh_ai_sync"),
/** 读取服务日志尾部。 */
dshLogTail: (lines: number) => __TAURI_INVOKE<string>("dsh_log_tail", { lines }),
/**
* 读取 dsh 安装输出(npm 的 stdout/stderr 尾部)。
*
* 只存在内存里(每次安装开始时清空),供「安装引导 → dsh 本体」页临时展示,
* **不写应用日志、不落盘**。前端在安装进行中轮询这个命令。
*/
dshInstallLog: () => __TAURI_INVOKE<string>("dsh_install_log"),
dshLogClear: () => __TAURI_INVOKE<void>("dsh_log_clear"),
/** 在资源管理器中打开 dsh 模块目录。 */
dshOpenDir: () => __TAURI_INVOKE<null>("dsh_open_dir"),
};
/* Types */
@@ -1365,6 +1432,136 @@ export type DownloaderSettings = {
btUseProxy?: boolean,
};
/** settings.yaml 同步预览。 */
export type DshAiPreview = {
/** 将被写入的 YAML 文本(密钥位置只有环境变量名) */
yaml: string,
providers: DshAiProvider[],
defaultProvider: string | null,
defaultModel: string | null,
settingsPath: string,
};
/** AI 供应商映射结果(预览用,不含明文密钥)。 */
export type DshAiProvider = {
/** Thing 侧供应商 id */
id: string,
name: string,
/** 写入 settings.yaml 的 apiKeyEnv 变量名 */
envName: string,
baseUrl: string,
model: string,
/** 凭据管理器中是否已配置密钥 */
hasKey: boolean,
};
/** 模块首屏环境总览。 */
export type DshEnvStatus = {
node: NodeStatus,
dsh: DshInstallStatus,
server: DshServerStatus,
settings: DshSettings,
};
/** dsh 本体安装状态。 */
export type DshInstallStatus = {
installed: boolean,
version: string | null,
/** bin 入口(dist/bin.js 绝对路径) */
entry: string | null,
/** 安装目录 */
dir: string,
};
/** npm 源信息(安装引导页展示「本次实际用哪个源」并提供快捷切换)。 */
export type DshNpmRegistryInfo = {
/** 本次安装/查询实际会使用的源(已去掉末尾 `/`) */
effective: string,
/** effective 的来源:setting(模块设置显式指定)| npm(npm 自身配置链)| fallback(默认官方源) */
source: string,
/**
* npm 自身解析出的源(环境变量 > 安装目录 .npmrc > 用户 ~/.npmrc > 内置),
* 未检测到 Node/npm 时为 None
*/
npmRegistry: string | null,
/** 模块设置里显式填写的值(空 = 未指定,交给 npm 解析) */
setting: string,
};
/** dsh 服务进程状态。 */
export type DshServerStatus = {
/** 进程存活 */
running: boolean,
/** HTTP 端口已可访问 */
ready: boolean,
pid: number | null,
port: number,
/** 规范地址(不含令牌,用于界面展示) */
url: string,
/**
* 带令牌的启动地址(**用于打开界面**)。
*
* dsh web 的浏览器鉴权是「进程级随机令牌 → 首次访问换 cookie」:
* 直接访问 [`Self::url`] 只会拿到 401。令牌每次启动都不同,只能从
* dsh 的输出里抓取,因此进程刚起来时这里可能为 None(等它打印)。
*/
launchUrl: string | null,
/** 启动时间(unix 秒) */
startedAt: number | null,
/** 启动失败原因(端口占用 / 进程立即退出等) */
error: string | null,
};
/**
* 模块设置(`{app_data}/dsh/settings.json`)。
*
* 独立文件,**不写** `thing_app_settings`(appStore 的 SETTINGS_VERSION 迁移会清空用户设置)。
*/
export type DshSettings = {
/** 结构版本号;变更时按版本校正字段 */
version?: number,
/** Node 来源偏好:auto(系统优先,缺失回落托管)| system | managed */
nodeSource?: string,
/** 指定下载的 Node 版本(空 = 自动取满足要求的最新版) */
managedNodeVersion?: string,
/** Node 分发包镜像前缀(空 = 官方 nodejs.org;国内可用 npmmirror) */
nodeMirror?: string,
/** npm registry(空 = 官方源) */
npmRegistry?: string,
/** 下载 Node / npm 安装是否走代理模块(mihomo mixed 端口) */
useProxy?: boolean,
/** Web UI 端口(dsh 的 `--port` 参数) */
port?: number,
/** 应用启动时自动拉起 dsh 服务 */
autoStart?: boolean,
/** 全局快捷键:打开 dsh Web 独立窗口(空 = 未启用) */
shortcut?: string,
/** $DSH_HOME 模式:managed({app_data}/dsh/home)| user(~/.dsh) */
dshHomeMode?: string,
/** 工作区目录(空 = {app_data}/dsh/workspace),即 dsh 进程的启动目录 */
workspace?: string,
/**
* dsh 本体的安装目录(npm `--prefix` 目标,即 node_modules 所在位置)。
* 空 = {app_data}/dsh。
* 只有 dsh 本体与它的 node_modules 跟随此设置;便携 Node、$DSH_HOME、
* 日志与模块设置仍固定在应用数据目录,避免自定义路径失效时连配置都读不到。
*/
installDir?: string,
/** 映射为 dsh 默认模型的 Thing AI 供应商 id */
providerId?: string,
/** 启动前自动同步 settings.yaml */
aiSync?: boolean,
};
/** dsh 版本更新信息。 */
export type DshUpdateInfo = {
current: string | null,
latest: string,
hasUpdate: boolean,
/** 可选版本(倒序,最多 20 个) */
versions: string[],
};
/** 重复类型 */
export type DuplicateKind =
/** 无重复 */
@@ -1787,6 +1984,20 @@ export type MusicSettings = {
remoteDevices?: RemoteDeviceMeta[],
};
/** Node 运行环境状态。 */
export type NodeStatus = {
/** system | managed | none */
source: string,
/** node.exe 路径 */
path: string | null,
/** 版本号(如 v24.9.0) */
version: string | null,
/** 是否满足 dsh 的版本要求 */
satisfies: boolean,
/** 版本要求文案(供 UI 展示) */
required: string,
};
/** 划词结果悬浮窗外观(P1 生效)。 */
export type PopupSettings = {
/** 正文字号(逻辑像素) */
@@ -2079,7 +2290,7 @@ export type Segment = {
export type SelectionSettings = {
/** 总开关:打开翻译面板时是否尝试读取当前划词作为候选 */
enabled?: boolean,
/** 打开翻译面板的全局快捷键(默认 Ctrl+2) */
/** 打开翻译面板的全局快捷键(默认 Alt+F) */
panelShortcut?: string,
/**
* 取词方式:
+20
View File
@@ -20,6 +20,13 @@ export const WINDOWS = {
translatePopup: 'translate-popup',
/** 单个终端独立窗口,实际 label = `terminal-window-<sessionId>` */
terminalWindow: 'terminal-window',
/**
* dsh 模块的 Web UI 独立窗口。
* 内容为远端 `http://127.0.0.1:<port>`,因此**不登记 capability**——
* 远端页面不应获得任何 Tauri 权限(Windows 平台上 label 未命中任何 capability
* 时,webview 仍可正常加载与交互,只是拿不到 IPC)。
*/
dshWeb: 'dsh-web',
} as const
/** Tauri 事件名(前端 emit / listen 与 Rust constants::events 对应) */
@@ -49,9 +56,13 @@ export const EVENTS = {
// 截图
screenshotBegin: 'screenshot-begin',
screenshotOverlayReady: 'screenshot-overlay-ready',
/** 覆盖层握手请求:主窗口每次发起截图前询问覆盖层是否已注册好 begin 监听(覆盖层以 screenshotOverlayReady 应答) */
screenshotOverlayPing: 'screenshot-overlay-ping',
screenshotShortcut: 'screenshot-shortcut',
screenshotPinShortcut: 'screenshot-pin-shortcut',
screenshotPinReady: 'screenshot-pin-ready',
/** 贴图窗口握手请求(同覆盖层):贴图窗口以 screenshotPinReady 应答 */
screenshotPinPing: 'screenshot-pin-ping',
screenshotPinShow: 'screenshot-pin-show',
screenshotExported: 'screenshot-exported',
/** 滚动截图会话:实时进度 { width, height, auto } */
@@ -64,6 +75,8 @@ export const EVENTS = {
scrollToEditor: 'screenshot-scroll-to-editor',
/** 常驻编辑器窗口挂载完成(store 等待后下发加载事件) */
screenshotEditorReady: 'screenshot-editor-ready',
/** 编辑器握手请求(同覆盖层):编辑器以 screenshotEditorReady 应答 */
screenshotEditorPing: 'screenshot-editor-ping',
/** 通知常驻编辑器窗口加载编辑器图片槽中的新图(raw IPC 取出) */
screenshotEditorLoad: 'screenshot-editor-load',
// 内核安装进度
@@ -127,6 +140,13 @@ export const EVENTS = {
downloadRemoved: 'download-removed',
/** 浏览器扩展通过 HTTP API 新增下载(负载 { id },前端据以为该任务创建专属下载窗口) */
downloadExtensionAdded: 'download-extension-added',
// dsh 模块
/** 安装/下载进度(负载见 src/types/dsh.ts 的 DshInstallProgress) */
dshInstallProgress: 'dsh-install-progress',
/** 服务进程状态(负载见 src/types/dsh.ts 的 DshServerStatus) */
dshServerState: 'dsh-server-state',
/** 全局快捷键按下:打开 dsh 独立窗口(无负载) */
dshOpenWindow: 'dsh-open-window',
} as const
/** localStorage 存储键 */
+7 -4
View File
@@ -17,9 +17,12 @@
* SIGINT(中断当前命令),这是不可协商的——把它映射成「复制」会让所有用户
* 失去中断能力。因此复制粘贴用 `Ctrl+Shift+C/V`(Windows Terminal 惯例)。
*
* 2. **避开项目已有的全局快捷键**。`Ctrl+2` 已被翻译模块占用(取词翻译面板),
* 所以标签跳转用 `Alt+1..9` —— 在终端里 `Alt+数字` 通常不产生控制字符,
* 冲突面最小,且符合「切标签」的直觉。
* 2. **避开 `Ctrl+数字`**。项目里全局快捷键曾用过 `Ctrl+2`(翻译面板)与
* `Ctrl+3`(新建独立窗口),现已统一收进 `Alt+字母` 段;标签跳转用
* `Alt+1..9` —— 在终端里 `Alt+数字` 通常不产生控制字符,冲突面最小,
* 且符合「切标签」的直觉。
* 全局那几条都落在 `Alt+字母`(翻译面板 `Alt+F`、dsh `Alt+D`、
* 新建独立窗口 `Alt+T`),彼此不冲突,`Ctrl+数字` 整段留空。
*
* # 唯一一条「全局」动作:`newDetachedWindow`
*
@@ -199,7 +202,7 @@ export const TERMINAL_ACTIONS: TerminalAction[] = [
label: '新建独立窗口',
group: '会话',
description: '全局生效(任意界面按下):打开独立终端窗口并选择要启动的会话',
defaultKeys: 'Ctrl+3'
defaultKeys: 'Alt+T'
}
]
+6
View File
@@ -119,6 +119,12 @@ if (matched) {
screenshotStore.initPinShortcutListener().catch(e => console.error('Screenshot pin shortcut listener init error:', e))
screenshotStore.initPinShortcutRegistration().catch(e => console.error('Screenshot pin shortcut registration init error:', e))
})
// dsh 模块:应用级初始化全局快捷键(注册 + 监听「打开独立窗口」事件)。
// 放这里而不是模块挂载时:快捷键要在任意模块下都能用,模块卸载不能把它带走。
void import('./stores/dshStore').then(({ useDshStore }) => {
useDshStore().initGlobalShortcut().catch(e => console.error('dsh shortcut init error:', e))
})
})
}
+170
View File
@@ -0,0 +1,170 @@
<script setup lang="ts">
/**
* dsh 模块主页面(DeepSeek Harness 外壳)。
*
* 页面只承载「状态 + 配置 + 日志」,**不内嵌** dsh 的 Web UI:
* dsh 界面通过「独立窗口」(Tauri WebviewWindow 直接加载 http://127.0.0.1:<端口>)
* 或「浏览器打开」(系统默认浏览器)访问。
*
* 布局遵循项目规范:模块根 `min-h-full p-5`(滚动归属主滚动区),
* Tab 行不渲染(注册给 TitleBar 常驻切换器)。
*/
import { onMounted, onUnmounted, ref } from 'vue'
import {
ExternalLink,
Loader2,
Play,
RotateCw,
Square,
AppWindow,
FolderOpen
} from '@lucide/vue'
import { Tabs, TabsContent } from '@/components/ui/tabs'
import { Button } from '@/components/ui/button'
import { Card, CardContent } from '@/components/ui/card'
import { useModuleTabs } from '@/lib/use-module-tabs'
import { useDshStore } from '@/stores/dshStore'
import SetupStepper from './components/SetupStepper.vue'
import DshSettingsPanel from './components/DshSettingsPanel.vue'
import DshLogPanel from './components/DshLogPanel.vue'
const store = useDshStore()
const activeTab = ref('setup')
useModuleTabs(
'dsh',
activeTab,
[
{ value: 'setup', label: '状态' },
{ value: 'settings', label: '设置' },
{ value: 'logs', label: '日志' }
],
{ alwaysVisible: true }
)
onMounted(async () => {
await store.init()
})
onUnmounted(() => {
store.stopListeners()
})
</script>
<template>
<div class="min-h-full p-5">
<Tabs v-model="activeTab" class="flex min-h-full w-full flex-col">
<TabsContent value="setup" class="tab-animate">
<div class="flex flex-col gap-4">
<!-- 状态横幅:状态区 → 指标区 → 操作区(UI_DESIGN_SYSTEM §3.4) -->
<Card class="!py-0 !gap-0">
<CardContent class="flex flex-wrap items-center gap-x-6 gap-y-3 px-4 py-4">
<div class="flex items-center gap-2.5">
<span
v-if="!store.initialized"
class="flex items-center gap-1.5 text-[13px] text-muted-foreground"
>
<Loader2 class="size-3.5 animate-spin" />加载中
</span>
<template v-else>
<span
v-if="store.running"
class="flex items-center gap-1.5 text-[13px] text-success"
>
<span class="size-2 rounded-full bg-success status-dot-pulse" />运行中
</span>
<span
v-else
class="flex items-center gap-1.5 text-[13px] text-muted-foreground"
>
<span class="size-2 rounded-full bg-muted-foreground" />已停止
</span>
</template>
<span class="text-[13px] text-fg-secondary">DeepSeek Harness</span>
</div>
<div class="flex min-w-24 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">dsh</span>
<span
class="text-lg font-semibold tabular-nums"
:class="store.installed ? 'text-foreground' : 'text-danger'"
>{{ store.install?.version ?? '未安装' }}</span>
</div>
<div class="flex min-w-24 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">Node</span>
<span
class="text-lg font-semibold tabular-nums"
:class="store.nodeReady ? 'text-foreground' : 'text-danger'"
>{{ store.node?.version ?? '未检测到' }}</span>
</div>
<div class="flex min-w-40 flex-col gap-0.5">
<span class="text-[11px] text-muted-foreground">服务地址</span>
<span class="truncate font-mono text-[13px] text-fg-secondary">{{ store.displayUrl }}</span>
</div>
<div class="ml-auto flex flex-wrap gap-2">
<Button
v-if="!store.running"
size="sm"
:disabled="!store.envReady || store.starting"
@click="store.start()"
>
<Loader2 v-if="store.starting" class="size-3.5 animate-spin" />
<Play v-else class="size-3.5" />启动
</Button>
<template v-else>
<Button size="sm" variant="outline" :disabled="store.starting" @click="store.restart()">
<Loader2 v-if="store.starting" class="size-3.5 animate-spin" />
<RotateCw v-else class="size-3.5" />重启
</Button>
<Button size="sm" variant="destructive" :disabled="store.stopping" @click="store.stop()">
<Loader2 v-if="store.stopping" class="size-3.5 animate-spin" />
<Square v-else class="size-3.5" />停止
</Button>
</template>
<Button size="sm" variant="outline" :disabled="!store.canOpen" @click="store.openWebWindow()">
<AppWindow class="size-3.5" />独立窗口
</Button>
<Button size="sm" variant="outline" :disabled="!store.canOpen" @click="store.openInBrowser()">
<ExternalLink class="size-3.5" />浏览器打开
</Button>
</div>
</CardContent>
</Card>
<!-- 服务启动失败的可见原因(否则只有日志里能看到) -->
<Card v-if="store.server?.error" class="!py-0 !gap-0">
<CardContent class="flex items-start gap-2 px-4 py-3">
<span class="text-[13px] text-danger">{{ store.server.error }}</span>
<Button class="ml-auto shrink-0" size="xs" variant="outline" @click="store.openDir()">
<FolderOpen class="size-3" />打开目录
</Button>
</CardContent>
</Card>
<!-- 已监听但还没打印带令牌的启动地址:此时打开界面只会拿到 401,故先等待 -->
<Card v-else-if="store.ready && !store.canOpen" class="!py-0 !gap-0">
<CardContent class="flex items-center gap-2 px-4 py-3">
<Loader2 class="size-3.5 shrink-0 animate-spin text-muted-foreground" />
<span class="text-[13px] text-fg-secondary">
等待 dsh 输出访问地址(浏览器鉴权令牌需要它换 cookie,稍候即可打开)
</span>
</CardContent>
</Card>
<SetupStepper />
</div>
</TabsContent>
<TabsContent value="settings" class="tab-animate">
<DshSettingsPanel />
</TabsContent>
<TabsContent value="logs" class="tab-animate">
<DshLogPanel />
</TabsContent>
</Tabs>
</div>
</template>
@@ -0,0 +1,54 @@
<script setup lang="ts">
/**
* dsh 服务日志面板:读取服务进程 stdout/stderr 的尾部输出。
*
* 日志在 Rust 侧同时写入 `{app_data}/dsh/logs/web.log` 与内存环形缓冲
* (最多 500 行),因此这里读到的是最近一段,不随运行时长无限增长。
* 读取时已过滤疑似密钥(`sk-` 形态)的行内片段。
*/
import { onMounted } from 'vue'
import { FolderOpen, RefreshCw, Trash2 } from '@lucide/vue'
import { Button } from '@/components/ui/button'
import { Card, CardContent } from '@/components/ui/card'
import { useDshStore } from '@/stores/dshStore'
const store = useDshStore()
onMounted(() => {
void store.loadLogs()
})
</script>
<template>
<div class="flex flex-col gap-3">
<div class="flex flex-wrap items-center gap-2">
<span class="text-[13px] font-medium text-foreground">服务日志</span>
<span class="text-xs text-muted-foreground">
{{ store.progress ? store.progress.message : '最近 300 行' }}
</span>
<div class="ml-auto flex gap-2">
<Button size="sm" variant="outline" :disabled="store.loadingLogs" @click="store.loadLogs()">
<RefreshCw class="size-3.5" :class="store.loadingLogs && 'animate-spin'" />刷新
</Button>
<Button size="sm" variant="outline" @click="store.openDir()">
<FolderOpen class="size-3.5" />打开目录
</Button>
<Button size="sm" variant="ghost" @click="store.clearLogs()">
<Trash2 class="size-3.5" />清空
</Button>
</div>
</div>
<Card class="!py-0 !gap-0">
<CardContent class="px-4 py-3">
<pre
v-if="store.logs.trim()"
class="max-h-[420px] overflow-auto whitespace-pre-wrap break-all font-mono text-[11px] leading-relaxed text-fg-secondary"
>{{ store.logs }}</pre>
<p v-else class="py-6 text-center text-xs text-muted-foreground">
暂无日志。启动服务后这里会显示 dsh 的输出。
</p>
</CardContent>
</Card>
</div>
</template>
@@ -0,0 +1,363 @@
<script setup lang="ts">
/**
* dsh 模块设置页。
*
* 版式与音乐模块设置页一致:**标题放在卡片内部**(Card → CardHeader/CardTitle +
* CardContent),卡片之间 `gap-4`;卡片内的一行行设置项复用业务组件 `SettingRow`
* (左标签+说明、右控件),用 1px 分隔线隔开。
*
* 约定:设置项改动**立即生效**(无保存按钮),端口与工作区在下次启动服务时生效。
* 成功提示省略,仅错误经 store 内的 `toast.error` 提示。
*/
import { computed, nextTick, onMounted, onUnmounted, ref, watch } from 'vue'
import { toast } from 'vue-sonner'
import { Cpu, FolderOpen, Keyboard, RefreshCw, Server, Sparkles, Zap } from '@lucide/vue'
import { Button } from '@/components/ui/button'
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
import { Switch } from '@/components/ui/switch'
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
import { SettingRow } from '@/components/common'
import { useDshStore } from '@/stores/dshStore'
import { useAiStore } from '@/stores/aiStore'
const store = useDshStore()
const aiStore = useAiStore()
const enabledProviders = computed(() => aiStore.providers.filter(p => p.config.enabled))
onMounted(async () => {
if (!store.initialized) await store.refresh()
await aiStore.init()
await store.loadAiPreview()
})
function onPortChange(e: Event) {
const raw = Number((e.target as HTMLInputElement).value)
if (!Number.isFinite(raw) || raw <= 0 || raw > 65535) {
store.refresh()
return
}
if (raw !== store.settings?.port) store.saveSettings({ port: Math.trunc(raw) })
}
function onTextChange(key: 'nodeMirror' | 'npmRegistry' | 'workspace' | 'installDir', e: Event) {
const value = (e.target as HTMLInputElement).value.trim()
store.saveSettings({ [key]: value })
}
// ===== 快捷键录入器(与 QuickPanelModule / ClipboardModule 同一模式) =====
const recording = ref(false)
const recorderRef = ref<HTMLDivElement | null>(null)
function displayShortcut(s: string): string {
if (!s) return ''
return s
.split('+')
.map(p => {
const t = p.trim()
if (!t) return ''
if (t.length === 1) return t.toUpperCase()
return t.charAt(0).toUpperCase() + t.slice(1)
})
.join(' + ')
}
function eventToShortcut(e: KeyboardEvent): string | null {
const mods: string[] = []
if (e.ctrlKey) mods.push('ctrl')
if (e.altKey) mods.push('alt')
if (e.shiftKey) mods.push('shift')
if (e.metaKey) mods.push('super')
let main = ''
const code = e.code || ''
if (/^Key[A-Z]$/.test(code)) main = code.slice(3).toLowerCase()
else if (/^Digit[0-9]$/.test(code)) main = code.slice(5)
else if (/^F([1-9]|1[0-2])$/.test(code)) main = code.toLowerCase()
else if (code === 'Space') main = 'space'
else if (code === 'PrintScreen') main = 'printscreen'
else if (code.startsWith('Numpad')) main = code.slice(6).toLowerCase()
else return null
const isFunctionKey = /^f([1-9]|1[0-2])$/.test(main) || main === 'printscreen'
if (mods.length === 0 && !isFunctionKey) return null
return [...mods, main].join('+')
}
function onRecordKey(e: KeyboardEvent) {
if (!recording.value) return
e.preventDefault()
e.stopPropagation()
if (e.key === 'Escape') {
recording.value = false
return
}
if (['Control', 'Alt', 'Shift', 'Meta'].includes(e.key)) return
const combo = eventToShortcut(e)
if (!combo) {
toast.warning('不支持的按键组合,请使用字母/数字/功能键 + 修饰键')
return
}
recording.value = false
// saveSettings 会顺带重新注册(注册失败时由 store 弹错误提示,如组合键被占用)
void store.saveSettings({ shortcut: combo }).then(() => {
if (store.settings?.shortcut === combo) {
toast.success(`快捷键已更新为 ${displayShortcut(combo)}`)
}
})
}
async function startRecord() {
recording.value = true
await nextTick()
recorderRef.value?.focus()
}
watch(recording, on => {
if (on) window.addEventListener('keydown', onRecordKey, true)
else window.removeEventListener('keydown', onRecordKey, true)
})
async function clearShortcut() {
await store.saveSettings({ shortcut: '' })
}
onUnmounted(() => {
window.removeEventListener('keydown', onRecordKey, true)
})
</script>
<template>
<div class="flex flex-col gap-4 pb-4">
<!-- 基础设置 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Zap class="size-4 text-primary" />
基础设置
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<div class="flex flex-col divide-y divide-divider">
<SettingRow label="随应用启动" description="应用启动且 dsh 已安装时自动拉起 Web 服务">
<Switch
:model-value="store.settings?.autoStart ?? false"
@update:model-value="v => store.saveSettings({ autoStart: v === true })"
/>
</SettingRow>
<SettingRow
label="打开独立窗口"
description="全局快捷键,在任意模块下都能唤出 dsh 界面;需至少一个修饰键 + 字母/数字/功能键"
>
<div class="flex items-center gap-2">
<div
ref="recorderRef"
class="hotkey-recorder"
:class="{ recording }"
tabindex="0"
@click="startRecord"
>
<template v-if="recording">按下快捷键…(Esc 取消)</template>
<template v-else-if="store.settings?.shortcut">
{{ displayShortcut(store.settings.shortcut) }}
</template>
<template v-else>未设置(点击录入)</template>
</div>
<Button
v-if="store.settings?.shortcut"
variant="ghost"
size="sm"
class="h-8 text-muted-foreground"
@click="clearShortcut"
>清除</Button>
</div>
</SettingRow>
</div>
</CardContent>
</Card>
<!-- 运行环境 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Cpu class="size-4 text-primary" />
运行环境
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
Node 的来源、镜像源与下载链路(dsh 要求 Node ^22.19 或 &gt;=24)
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow
label="Node 来源"
description="自动 = 系统 Node 满足要求就复用,否则回落托管版本"
control-width="wide"
>
<Select
:model-value="store.settings?.nodeSource ?? 'auto'"
@update:model-value="v => store.saveSettings({ nodeSource: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="auto">自动(系统优先)</SelectItem>
<SelectItem value="system">仅使用系统 Node</SelectItem>
<SelectItem value="managed">仅使用托管便携 Node</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow
label="Node 镜像源"
description="留空使用 nodejs.org;国内可填 https://npmmirror.com/mirrors/node"
control-width="wide"
>
<Input
:model-value="store.settings?.nodeMirror ?? ''"
placeholder="https://nodejs.org/dist"
@change="(e: Event) => onTextChange('nodeMirror', e)"
/>
</SettingRow>
<SettingRow
label="npm 源"
description="留空 = 跟随 npm 自身配置(环境变量 → 安装目录 .npmrc → 用户 ~/.npmrc),系统 Node 已设的镜像会被沿用;国内镜像可在安装引导页用下拉快速选择"
control-width="wide"
>
<Input
:model-value="store.settings?.npmRegistry ?? ''"
placeholder="留空 = 跟随 npm 配置"
@change="(e: Event) => onTextChange('npmRegistry', e)"
/>
</SettingRow>
<SettingRow label="下载走代理" description="使用代理模块(mihomo)的混合端口;内核未运行时自动直连">
<Switch
:model-value="store.settings?.useProxy ?? true"
@update:model-value="v => store.saveSettings({ useProxy: v === true })"
/>
</SettingRow>
</div>
</CardContent>
</Card>
<!-- 服务 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Server class="size-4 text-primary" />
服务
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
监听端口、安装位置与工作区(端口与工作区改动在下次启动服务时生效)
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow label="端口" description="dsh 的 --port 参数;被占用时启动会直接报错" control-width="wide">
<Input
type="number"
min="1"
max="65535"
:model-value="store.settings?.port ?? 3080"
@change="onPortChange"
/>
</SettingRow>
<SettingRow
label="dsh 安装目录"
description="npm 安装目标(node_modules 所在位置),必须是绝对路径;留空 = 模块目录。改到新目录后需重新安装,原目录不会自动清理"
control-width="wide"
>
<Input
:model-value="store.settings?.installDir ?? ''"
placeholder="留空 = 应用数据目录下的 dsh"
@change="(e: Event) => onTextChange('installDir', e)"
/>
</SettingRow>
<SettingRow label="工作区" description="dsh 进程的启动目录,也是默认 workspace;留空使用模块目录下的 workspace" control-width="wide">
<Input
:model-value="store.settings?.workspace ?? ''"
placeholder="留空 = 模块目录下的 workspace"
@change="(e: Event) => onTextChange('workspace', e)"
/>
</SettingRow>
</div>
</CardContent>
</Card>
<!-- AI 装载 -->
<Card class="!gap-2 !py-4">
<CardHeader class="!px-4">
<CardTitle class="flex items-center gap-2 text-base">
<Sparkles class="size-4 text-primary" />
AI 装载
</CardTitle>
</CardHeader>
<CardContent class="!px-4">
<p class="pb-2 text-xs text-muted-foreground">
把主设置「AI 服务」里的供应商映射进 dsh;密钥不落盘,改为启动时以环境变量注入
</p>
<div class="flex flex-col divide-y divide-divider">
<SettingRow
label="dsh 主目录"
description="托管 = 模块目录(卸载即清理);用户目录 = ~/.dsh(与命令行 dsh 共享会话)"
control-width="wide"
>
<Select
:model-value="store.settings?.dshHomeMode ?? 'managed'"
@update:model-value="v => store.saveSettings({ dshHomeMode: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem value="managed">模块独立目录</SelectItem>
<SelectItem value="user">用户目录(~/.dsh)</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="默认供应商" description="写入 agent-default-model,作为 dsh 的默认模型来源" control-width="wide">
<Select
:model-value="store.settings?.providerId ?? ''"
@update:model-value="v => store.saveSettings({ providerId: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue placeholder="选择供应商" /></SelectTrigger>
<SelectContent>
<SelectItem v-for="p in enabledProviders" :key="p.config.id" :value="p.config.id">
{{ p.config.name || p.config.id }}
</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="默认模型" description="来自所选供应商的模型标识" control-width="wide">
<span class="block truncate text-right font-mono text-xs text-fg-secondary">
{{ store.preview?.defaultModel ?? '—' }}
</span>
</SettingRow>
<SettingRow label="启动前自动同步" description="每次启动服务前合并写入 settings.yaml(写前备份 .bak)">
<Switch
:model-value="store.settings?.aiSync ?? true"
@update:model-value="v => store.saveSettings({ aiSync: v === true })"
/>
</SettingRow>
</div>
</CardContent>
</Card>
<div class="flex flex-wrap items-center gap-2">
<Button size="sm" variant="outline" @click="store.openDir()">
<FolderOpen class="size-3.5" />打开模块目录
</Button>
<Button size="sm" variant="ghost" @click="store.refresh()">
<RefreshCw class="size-3.5" />刷新状态
</Button>
<span class="flex items-center gap-1.5 text-xs text-muted-foreground">
<Keyboard class="size-3" />
settings.yaml:{{ store.preview?.settingsPath ?? '—' }}
</span>
</div>
</div>
</template>
+491
View File
@@ -0,0 +1,491 @@
<script setup lang="ts">
/**
* 安装引导步骤条:Node 运行环境 → dsh 本体 → AI 通道。
*
* 步骤条用项目已有的 `ui/stepper`(reka-ui 封装,此前无模块使用)。
* 进度条用 `ui/progress`,**必须传 `:model-value`**(reka-ui ProgressRoot 没有
* `:value`,传错不报错但指示条永远停在 0)。
*
* npm 安装阶段没有百分比(npm 不输出),此时 `percent === 0`,用不确定态动画条
* 表达「正在进行」,不伪造百分比。
*/
import { computed, onMounted, ref, watch } from 'vue'
import {
Check,
Download,
FolderOpen,
Loader2,
RefreshCw,
Play,
Sparkles,
Terminal,
X
} from '@lucide/vue'
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import {
Stepper,
StepperDescription,
StepperIndicator,
StepperItem,
StepperSeparator,
StepperTitle,
StepperTrigger
} from '@/components/ui/stepper'
import { Button } from '@/components/ui/button'
import { Progress } from '@/components/ui/progress'
import { Switch } from '@/components/ui/switch'
import { Badge } from '@/components/ui/badge'
import { Input } from '@/components/ui/input'
import { ScrollArea } from '@/components/ui/scroll-area'
import { Card, CardContent } from '@/components/ui/card'
import { SettingGroup, SettingRow } from '@/components/common'
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
import { createLogger } from '@/lib/logger'
import { useDshStore } from '@/stores/dshStore'
import { useAiStore } from '@/stores/aiStore'
const logger = createLogger('dsh')
const store = useDshStore()
const aiStore = useAiStore()
const steps = [
{ value: 'node', title: 'Node 运行环境', description: 'dsh 要求 ^22.19 或 >=24' },
{ value: 'dsh', title: 'dsh 本体', description: '本地安装,可锁版本与更新' },
{ value: 'ai', title: 'AI 通道', description: '复用设置里的供应商与密钥' }
]
/** 当前步骤跟随环境状态自动推进(已完成的步骤不再回退) */
const step = ref(0)
const maxStepReached = ref(0)
watch(
() => store.setupStep,
value => {
if (value > maxStepReached.value) {
maxStepReached.value = value
step.value = value
}
},
{ immediate: true }
)
const installProgressText = computed(() => store.progress?.message ?? '')
/** 不确定进度(npm 无百分比输出) */
const indeterminate = computed(() => !!store.progress && store.progress.percent === 0)
const progressPercent = computed(() => store.progress?.percent ?? 0)
/**
* 安装输出面板的显示开关。
*
* 日志只在内存里(Rust 缓冲 + 本页展示,不进应用日志),因此这里也做成
* 「临时」的:一次安装结束后仍留在页面上供排查,用户可手动隐藏;
* 发起新安装时重新展开。
*/
const logHidden = ref(false)
const hasInstallLog = computed(() => store.installLog.trim().length > 0)
const showInstallLog = computed(() => hasInstallLog.value && !logHidden.value)
watch(
() => store.installing,
value => {
if (value) logHidden.value = false
}
)
/**
* npm 源下拉选项(地址均为实测可用)。
*
* 「跟随 npm 配置」对应存储值空串 = 不传 `--registry`,让 npm 走自己的配置链
* (环境变量 > 安装目录 .npmrc > 用户 ~/.npmrc > 内置)——「系统 Node 以前配过的
* 镜像」正是靠这一项被沿用。
*
* 注意:reka-ui 的 SelectItem **不允许空字符串 value**(会 throw),
* 因此这里用哨兵值 `__npm__` 代表「跟随」,读写设置时再与空串互换。
*/
const FOLLOW_NPM = '__npm__'
const REGISTRY_PRESETS = [
{ label: '跟随 npm 配置(推荐,沿用系统 Node 已设的镜像)', value: FOLLOW_NPM },
{ label: 'npm 官方源(registry.npmjs.org)', value: 'https://registry.npmjs.org' },
{ label: 'npmmirror(阿里)', value: 'https://registry.npmmirror.com' },
{ label: '腾讯云', value: 'https://mirrors.cloud.tencent.com/npm' },
{ label: '华为云', value: 'https://mirrors.huaweicloud.com/repository/npm' }
]
/** 当前存的若是自定义地址,补一条选项,避免下拉显示空白 */
const registryOptions = computed(() => {
const current = store.settings?.npmRegistry ?? ''
if (!current || REGISTRY_PRESETS.some(p => p.value === current)) return REGISTRY_PRESETS
return [...REGISTRY_PRESETS, { label: `自定义:${current}`, value: current }]
})
const registrySelectValue = computed(() => store.settings?.npmRegistry || FOLLOW_NPM)
function onRegistryChange(v: unknown) {
const value = String(v)
store.saveSettings({ npmRegistry: value === FOLLOW_NPM ? '' : value })
}
/** 来源说明(让用户一眼看出到底走的哪个源) */
const registrySourceText = computed(() => {
const info = store.registryInfo
if (!info) return ''
if (info.source === 'setting') return '模块设置指定'
if (info.source === 'npm') return 'npm 配置链(含系统 Node 的 ~/.npmrc)'
return '默认官方源(未检测到 npm 配置)'
})
onMounted(async () => {
await aiStore.init()
await store.loadAiPreview()
})
async function handleInstallNode() {
await store.installNode()
}
/** 安装目录改动手工输入(Rust 侧校验绝对路径,非法会 toast) */
function onInstallDirChange(e: Event) {
const value = (e.target as HTMLInputElement).value.trim()
if (value === (store.settings?.installDir ?? '')) return
store.saveSettings({ installDir: value })
}
/** 目录选择器选安装目录(返回的一定是绝对路径) */
async function pickInstallDir() {
try {
const picked = await openDialog({ directory: true, multiple: false, title: '选择 dsh 安装目录' })
if (typeof picked === 'string') store.saveSettings({ installDir: picked })
} catch (e) {
logger.error('选择安装目录失败: ' + e)
}
}
</script>
<template>
<div class="flex flex-col gap-4">
<Stepper
:model-value="step"
class="w-full flex-col gap-3 sm:flex-row sm:items-center"
@update:model-value="v => (step = Number(v))"
>
<StepperItem
v-for="(item, index) in steps"
:key="item.value"
:step="index"
class="flex w-full items-center gap-2"
>
<StepperTrigger class="flex-row items-center gap-2.5 rounded-md p-1">
<StepperIndicator class="size-7 bg-muted text-xs">
<Check v-if="index < step" class="size-3.5" />
<span v-else>{{ index + 1 }}</span>
</StepperIndicator>
<div class="flex flex-col items-start text-left">
<StepperTitle class="text-[13px]">{{ item.title }}</StepperTitle>
<StepperDescription>{{ item.description }}</StepperDescription>
</div>
</StepperTrigger>
<StepperSeparator
v-if="index < steps.length - 1"
class="mx-1 h-px flex-1 shrink-0"
/>
</StepperItem>
</Stepper>
<!-- 步骤 1:Node -->
<Card v-if="step === 0" class="!py-0 !gap-0">
<CardContent class="flex flex-col gap-3 px-4 py-4">
<div class="flex items-start justify-between gap-4">
<div class="flex min-w-0 flex-col gap-1">
<span class="text-[13px] font-medium text-foreground">Node 运行环境</span>
<span class="text-xs text-muted-foreground">
当前策略:{{ store.settings?.nodeSource === 'managed' ? '始终使用托管便携 Node' : store.settings?.nodeSource === 'system' ? '仅使用系统 Node' : '优先复用系统 Node,缺失才下载' }}
</span>
</div>
<Badge v-if="store.nodeReady" variant="outline" class="shrink-0">已满足</Badge>
<Badge v-else variant="destructive" class="shrink-0">不满足</Badge>
</div>
<dl class="flex flex-col gap-1 text-xs">
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">来源</dt>
<dd class="text-foreground">
{{ store.node?.source === 'managed' ? '模块托管' : store.node?.source === 'system' ? '系统 PATH' : '未找到' }}
</dd>
</div>
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">版本</dt>
<dd class="font-mono text-foreground">{{ store.node?.version ?? '—' }}</dd>
</div>
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">要求</dt>
<dd class="font-mono text-foreground">{{ store.node?.required }}</dd>
</div>
<div v-if="store.node?.path" class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">路径</dt>
<dd class="min-w-0 break-all font-mono text-fg-secondary">{{ store.node.path }}</dd>
</div>
</dl>
<div v-if="store.installing" class="flex flex-col gap-2">
<div
v-if="indeterminate"
class="relative h-2 w-full overflow-hidden rounded-full bg-primary/20"
>
<div class="progress-indeterminate bg-primary absolute inset-y-0 w-1/3 rounded-full" />
</div>
<Progress v-else :model-value="progressPercent" />
<span class="text-xs text-muted-foreground">{{ installProgressText }}</span>
</div>
<div class="flex gap-2">
<Button v-if="!store.nodeReady" size="sm" :disabled="store.installing" @click="handleInstallNode">
<Loader2 v-if="store.installing" class="size-3.5 animate-spin" />
<Download v-else class="size-3.5" />下载便携 Node
</Button>
<Button v-else size="sm" disabled>
<Check class="size-3.5" />环境就绪
</Button>
<Button v-if="store.installing" size="sm" variant="outline" @click="store.cancelInstall()">
<X class="size-3.5" />取消
</Button>
<Button size="sm" variant="ghost" :disabled="store.installing" @click="store.detectNode()">
<RefreshCw class="size-3.5" />重新检测
</Button>
</div>
</CardContent>
</Card>
<!-- 步骤 2:dsh -->
<Card v-else-if="step === 1" class="!py-0 !gap-0">
<CardContent class="flex flex-col gap-3 px-4 py-4">
<div class="flex items-start justify-between gap-4">
<div class="flex min-w-0 flex-col gap-1">
<span class="text-[13px] font-medium text-foreground">dsh 本体</span>
<span class="text-xs text-muted-foreground">
用当前 Node 自带的 npm 安装到指定目录(默认应用数据目录),更新与卸载可回滚
</span>
</div>
<Badge v-if="store.installed" variant="outline" class="shrink-0">已安装</Badge>
<Badge v-else variant="destructive" class="shrink-0">未安装</Badge>
</div>
<dl class="flex flex-col gap-1 text-xs">
<div class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">版本</dt>
<dd class="font-mono text-foreground">{{ store.install?.version ?? '—' }}</dd>
</div>
<div v-if="store.updateInfo" class="flex gap-2">
<dt class="w-20 shrink-0 text-muted-foreground">最新版本</dt>
<dd class="flex items-center gap-2 font-mono text-foreground">
{{ store.updateInfo.latest }}
<span v-if="store.updateInfo.hasUpdate" class="text-[11px] text-warning">可更新</span>
<Check v-else class="size-3 text-success" />
</dd>
</div>
</dl>
<!-- 安装目录:可直接改 + 目录选择器(设置页同一项,两处联动) -->
<div class="flex flex-col gap-2 rounded-lg border border-border p-3">
<div class="flex flex-wrap items-center gap-2">
<span class="text-xs font-medium text-foreground">安装目录</span>
<span class="text-[11px] text-muted-foreground">
dsh 本体(node_modules)装到哪,必须是绝对路径;改到新目录后需重新安装
</span>
</div>
<div class="flex w-full gap-2 sm:max-w-96">
<Input
:model-value="store.settings?.installDir ?? ''"
placeholder="留空 = 应用数据目录下的 dsh"
@change="onInstallDirChange"
/>
<Button size="sm" variant="outline" class="shrink-0" @click="pickInstallDir">
<FolderOpen class="size-3.5" />浏览
</Button>
</div>
<span class="text-[11px] text-muted-foreground">
实际使用
<span class="font-mono text-fg-secondary">{{ store.install?.dir }}</span>
<template v-if="store.settings?.installDir">(已自定义)</template>
<template v-else>(模块目录,未自定义)</template>
</span>
</div>
<!-- 下载源:看清本次安装走哪个 npm 源,并可一键切到国内镜像 -->
<div class="flex flex-col gap-1.5 rounded-lg border border-border p-3">
<div class="flex flex-wrap items-center gap-2">
<span class="text-xs font-medium text-foreground">下载源</span>
<span class="text-[11px] text-muted-foreground">npm 依赖从哪个源拉取</span>
<Select
class="w-full sm:ml-auto sm:w-80"
:model-value="registrySelectValue"
@update:model-value="onRegistryChange"
>
<SelectTrigger class="w-full"><SelectValue /></SelectTrigger>
<SelectContent>
<SelectItem v-for="opt in registryOptions" :key="opt.value" :value="opt.value">
{{ opt.label }}
</SelectItem>
</SelectContent>
</Select>
</div>
<span class="text-[11px] text-muted-foreground">
本次将使用
<span class="font-mono text-fg-secondary">{{ store.registryInfo?.effective ?? '检测中...' }}</span>
<template v-if="registrySourceText">({{ registrySourceText }})</template>
</span>
<span
v-if="store.registryInfo?.npmRegistry && store.registryInfo.source === 'setting'"
class="text-[11px] text-muted-foreground"
>
系统 npm 当前配置:<span class="font-mono">{{ store.registryInfo.npmRegistry }}</span>
</span>
</div>
<div v-if="store.installing" class="flex flex-col gap-2">
<div
v-if="indeterminate"
class="relative h-2 w-full overflow-hidden rounded-full bg-primary/20"
>
<div class="progress-indeterminate bg-primary absolute inset-y-0 w-1/3 rounded-full" />
</div>
<Progress v-else :model-value="progressPercent" />
<span class="text-xs text-muted-foreground">{{ installProgressText }}</span>
</div>
<div class="flex flex-wrap gap-2">
<Button v-if="!store.installed" size="sm" :disabled="store.installing" @click="store.installDsh()">
<Loader2 v-if="store.installing" class="size-3.5 animate-spin" />
<Download v-else class="size-3.5" />安装 dsh
</Button>
<Button v-else size="sm" variant="outline" :disabled="store.installing" @click="store.updateDsh()">
<Loader2 v-if="store.installing" class="size-3.5 animate-spin" />
<Download v-else class="size-3.5" />更新到最新
</Button>
<Button size="sm" variant="ghost" :disabled="store.checkingUpdate || store.installing" @click="store.checkUpdate()">
<Loader2 v-if="store.checkingUpdate" class="size-3.5 animate-spin" />
<RefreshCw v-else class="size-3.5" />检查更新
</Button>
<Button v-if="store.installing" size="sm" variant="outline" @click="store.cancelInstall()">
<X class="size-3.5" />取消
</Button>
<Button v-if="store.installed && !store.installing" size="sm" variant="ghost" @click="store.uninstallDsh()">
卸载
</Button>
</div>
<!-- 安装输出:只在内存里,临时展示;不进应用日志 -->
<div v-if="showInstallLog" class="flex flex-col gap-2">
<div class="flex items-center gap-2">
<Terminal class="size-3.5 text-muted-foreground" />
<span class="text-xs font-medium text-foreground">安装输出</span>
<span class="text-[11px] text-muted-foreground">仅本页临时显示,不写入应用日志</span>
<Button class="ml-auto" size="xs" variant="ghost" @click="logHidden = true">
隐藏
</Button>
</div>
<ScrollArea class="h-56 rounded-lg border border-border bg-card">
<pre
class="px-3 py-2.5 whitespace-pre-wrap break-all font-mono text-[11px] leading-relaxed text-fg-secondary"
>{{ store.installLog }}</pre>
</ScrollArea>
</div>
</CardContent>
</Card>
<!-- 步骤 3:AI 通道 -->
<Card v-else class="!py-0 !gap-0">
<CardContent class="flex flex-col gap-3 px-4 py-4">
<div class="flex items-start justify-between gap-4">
<div class="flex min-w-0 flex-col gap-1">
<span class="text-[13px] font-medium text-foreground">AI 通道</span>
<span class="text-xs text-muted-foreground">
把主设置「AI 服务」里已启用的供应商写入 dsh 的 settings.yaml;
密钥不落盘,改为启动时以环境变量注入(来自系统凭据管理器)
</span>
</div>
<Badge v-if="store.preview?.providers.length" variant="outline" class="shrink-0">
{{ store.preview.providers.length }} 个供应商
</Badge>
<Badge v-else variant="destructive" class="shrink-0">无可用供应商</Badge>
</div>
<SettingGroup title="默认模型" description="选择 dsh 默认使用哪个供应商(在 dsh 内仍可切换)">
<SettingRow label="默认供应商" description="取自设置 → AI 服务中已启用的供应商" control-width="wide">
<Select
:model-value="store.settings?.providerId ?? ''"
@update:model-value="v => store.saveSettings({ providerId: String(v) })"
>
<SelectTrigger class="w-full"><SelectValue placeholder="选择供应商" /></SelectTrigger>
<SelectContent>
<SelectItem
v-for="p in aiStore.providers.filter(x => x.config.enabled)"
:key="p.config.id"
:value="p.config.id"
>
{{ p.config.name || p.config.id }}
</SelectItem>
</SelectContent>
</Select>
</SettingRow>
<SettingRow label="同步 settings.yaml" description="启动服务前自动同步一次;关闭后可手动同步">
<Switch
:model-value="store.settings?.aiSync ?? true"
@update:model-value="v => store.saveSettings({ aiSync: v === true })"
/>
</SettingRow>
</SettingGroup>
<div v-if="store.preview" class="flex flex-col gap-2">
<div class="flex flex-wrap gap-2">
<Badge
v-for="p in store.preview.providers"
:key="p.id"
:variant="p.hasKey ? 'outline' : 'destructive'"
>
{{ p.name || p.id }} · {{ p.hasKey ? '已配置密钥' : '缺密钥' }}
</Badge>
</div>
<ScrollArea class="h-56 rounded-lg border border-border bg-card">
<pre
class="px-3 py-2.5 font-mono text-[11px] leading-relaxed text-fg-secondary"
>{{ store.preview.yaml }}</pre>
</ScrollArea>
</div>
<div class="flex flex-wrap gap-2">
<Button size="sm" variant="outline" @click="store.syncAi()">
<Sparkles class="size-3.5" />同步 AI 配置
</Button>
<Button size="sm" variant="ghost" @click="store.loadAiPreview()">
<RefreshCw class="size-3.5" />刷新预览
</Button>
<Button size="sm" :disabled="!store.running" @click="store.restart()">
<Play class="size-3.5" />重启服务生效
</Button>
</div>
</CardContent>
</Card>
</div>
</template>
<style scoped>
/*
* 不确定进度条(npm 安装无百分比输出时的表达)。
* 项目没有「indeterminate Progress」组件,这里用一条循环平移的色块代替,
* 避免伪造百分比数字。
*/
.progress-indeterminate {
animation: dsh-indeterminate 1.2s ease-in-out infinite;
}
@keyframes dsh-indeterminate {
0% {
left: -33%;
}
100% {
left: 100%;
}
}
</style>
+72
View File
@@ -0,0 +1,72 @@
import type { ModuleConfig } from '@/types/module'
import type { SearchIndexItem } from '@/stores/searchIndex'
const searchItems: SearchIndexItem[] = [
{
title: 'DeepSeek Harness',
description: '安装、更新与启动 dsh,管理 Node 运行环境与 AI 通道',
keywords: ['dsh', 'deepseek', 'harness', 'agent', '智能体', '外壳', '安装'],
tab: 'setup'
},
{
title: '安装 dsh 环境',
description: '按步骤引导安装 Node 运行环境与 dsh 本体',
keywords: ['安装', 'install', 'node', '环境', '引导', 'stepper', '更新'],
tab: 'setup'
},
{
title: 'dsh 设置',
description: '端口、工作区、Node 来源、镜像源与自动启动',
keywords: ['设置', 'setting', '端口', 'port', '工作区', 'workspace', '镜像'],
tab: 'settings'
},
{
title: 'dsh AI 通道',
description: '把设置里的 AI 供应商(含 DeepSeek API Key)同步给 dsh',
keywords: ['ai', 'api key', 'deepseek', '供应商', 'provider', '模型', 'model'],
tab: 'settings'
},
{
title: 'dsh 运行日志',
description: '查看 dsh 服务的输出日志',
keywords: ['日志', 'log', '输出', '排查', 'debug'],
tab: 'logs'
}
]
export const moduleConfig: ModuleConfig = {
id: 'dsh',
name: 'DeepSeek Harness',
icon: 'dsh',
description: 'DeepSeek Harness(dsh)外壳:环境安装引导、版本更新与 Web 服务生命周期管理',
category: 'tool',
defaultEnabled: true,
loader: () => import('./DshModule.vue'),
searchItems,
lifecycle: {
// 模块启用:恢复全局快捷键(应用启动时由 main.ts 注册;这里覆盖「先禁用再启用」)
onEnable: async () => {
try {
const { useDshStore } = await import('@/stores/dshStore')
await useDshStore().registerShortcut()
} catch (e) {
console.error('[dsh] onEnable 注册快捷键失败:', e)
}
},
// 模块禁用:停服务 + 注销快捷键(服务停了快捷键也没意义,且组合键不该被占着)
onDisable: async () => {
// 动态导入避免 index.ts 直接依赖 store(会形成循环依赖,参见 terminal / music 的处理)
try {
const { useDshStore } = await import('@/stores/dshStore')
const store = useDshStore()
if (store.running) await store.stop()
await store.unregisterShortcut()
store.stopListeners()
} catch (e) {
console.error('[dsh] onDisable 停止服务失败:', e)
}
}
},
// 排在开发工具之后:音乐 / 代理 / 下载 / 终端 / 翻译 / 监控 / 截图 / 剪贴板 / 快捷面板 / 开发工具 / dsh
order: 110
}
+4 -2
View File
@@ -10,7 +10,8 @@ import {
Wrench,
Music,
Languages,
SquareTerminal
SquareTerminal,
Bot
} from '@lucide/vue'
/**
@@ -31,7 +32,8 @@ export const moduleIconMap: Record<string, Component> = {
devtools: Wrench,
music: Music,
translate: Languages,
terminal: SquareTerminal
terminal: SquareTerminal,
dsh: Bot
}
/** 获取模块图标组件,未找到时回退到 Settings 图标 */
+3 -1
View File
@@ -13,6 +13,7 @@ import { moduleConfig as settings } from './settings'
import { moduleConfig as music } from './music'
import { moduleConfig as translate } from './translate'
import { moduleConfig as terminal } from './terminal'
import { moduleConfig as dsh } from './dsh'
const allModules: ModuleConfig[] = [
proxy,
@@ -25,7 +26,8 @@ const allModules: ModuleConfig[] = [
settings,
music,
translate,
terminal
terminal,
dsh
]
// 启动时注册所有模块
@@ -63,6 +63,8 @@ const win = getCurrentWindow()
let objectUrl = ''
/** 常驻窗口:加载事件监听(store 通知加载编辑器图片槽中的新图) */
let loadUnlisten: UnlistenFn | null = null
/** 握手请求监听(见 store 的 ensureEditorReady):主窗口每次打开编辑器前 ping,本窗口应答 ready */
let pingUnlisten: UnlistenFn | null = null
/** 马赛克结果缓存:标注参数不变时跳过重复像素化(长图上拖动其他标注不再卡顿) */
let mosaicCache: { key: string; canvas: HTMLCanvasElement } | null = null
@@ -1108,6 +1110,12 @@ onMounted(async () => {
loadUnlisten = await listen(EVENTS.screenshotEditorLoad, () => {
void loadPendingImage()
})
// 握手应答:主窗口每次打开编辑器前 ping(store 的 ensureEditorReady)。本监听挂在
// 加载监听**之后** —— 只有加载监听已就绪,应答才代表「可以接收新图」。这样主窗口
// 重载后(编辑器窗口存活、不会再发首次 ready)也能重新确认就绪状态。
pingUnlisten = await listen(EVENTS.screenshotEditorPing, () => {
void emit(EVENTS.screenshotEditorReady).catch(() => {})
})
await emit(EVENTS.screenshotEditorReady)
})
@@ -1118,6 +1126,8 @@ onUnmounted(() => {
window.removeEventListener('storage', onStorageChange)
loadUnlisten?.()
loadUnlisten = null
pingUnlisten?.()
pingUnlisten = null
if (objectUrl) {
URL.revokeObjectURL(objectUrl)
objectUrl = ''
@@ -167,6 +167,8 @@ let magGridCanvas: HTMLCanvasElement | null = null
// 常驻窗口:'screenshot-begin' 事件监听(store 捕获并定位窗口后触发)
let beginUnlisten: UnlistenFn | null = null
/** 握手请求监听(见 store 的 ensureOverlayReady):主窗口每次截图前 ping,本窗口应答 ready */
let pingUnlisten: UnlistenFn | null = null
const beginUnlistenCleanups: Array<() => void> = []
/** 界面内滚动会话事件监听(scrollProgress / scrollComplete / scrollCancelled) */
let scrollProgressUnlisten: UnlistenFn | null = null
@@ -1904,6 +1906,12 @@ onMounted(async () => {
beginUnlisten = await listen<ScreenshotBeginPayload>(EVENTS.screenshotBegin, (e) => {
void beginCapture(e.payload)
})
// 握手应答:主窗口每次发起截图前 ping(store 的 ensureOverlayReady)。本监听挂在
// begin 监听**之后** —— 只有 begin 监听已就绪,应答才真正代表「可以接收截图」。
// 这样主窗口重载后(覆盖层窗口存活、不会再发首次 ready)也能重新确认就绪状态。
pingUnlisten = await listen(EVENTS.screenshotOverlayPing, () => {
void emit(EVENTS.screenshotOverlayReady).catch(() => {})
})
// 界面内滚动会话事件(仅滚动模式下有意义;会话由主窗口触发、覆盖层常驻监听)
scrollProgressUnlisten = await listen<{ width: number; height: number }>(EVENTS.scrollProgress, (e) => {
if (!scrollMode.value) return
@@ -2029,6 +2037,8 @@ onUnmounted(() => {
window.removeEventListener('storage', onStorageChange)
beginUnlisten?.()
beginUnlisten = null
pingUnlisten?.()
pingUnlisten = null
scrollProgressUnlisten?.()
scrollProgressUnlisten = null
scrollCompleteUnlisten?.()
+9
View File
@@ -27,6 +27,8 @@ const items = ref<{ filePath: string; width: number; height: number; posX?: numb
const cur = ref(0)
let showUnlisten: UnlistenFn | null = null
/** 握手请求监听(见 store 的 ensurePinReady):主窗口每次贴图前 ping,本窗口应答 ready */
let pingUnlisten: UnlistenFn | null = null
// ===== 贴图数据缓存(LRU,值为 Blob URL):命中时上一张/下一张切换零 IPC、零等待 =====
const imgCache = new Map<string, string>()
@@ -384,6 +386,11 @@ onMounted(async () => {
showUnlisten = await listen(EVENTS.screenshotPinShow, () => {
openPin()
})
// 握手应答:主窗口每次贴图前 ping(store 的 ensurePinReady)。挂在 show 监听**之后**
// —— 应答即代表 show 监听已就绪。主窗口重载后本窗口不会再发首次 ready,由应答补上。
pingUnlisten = await listen(EVENTS.screenshotPinPing, () => {
void emit(EVENTS.screenshotPinReady).catch(() => {})
})
await emit(EVENTS.screenshotPinReady)
})
@@ -391,6 +398,8 @@ onUnmounted(() => {
window.removeEventListener('keydown', onKeyDown)
window.removeEventListener('blur', onBlur)
showUnlisten?.()
pingUnlisten?.()
pingUnlisten = null
})
</script>
+1 -1
View File
@@ -190,7 +190,7 @@ async function closeWindow() {
</Tooltip>
</div>
<!-- 内容:与 tab 页完全同一个组件(standalone 模式自带四周留白) -->
<!-- 内容:与 tab 页完全同一个组件(standalone 模式占满容器、无圆角) -->
<div class="flex-1 min-h-0">
<div v-if="!ready" class="h-full flex items-center justify-center gap-2">
<Loader2 class="size-4 animate-spin text-muted-foreground" />
+1 -1
View File
@@ -14,7 +14,7 @@
*
* # 键位从设置里读
*
* 键位存在终端设置的快捷键表里(设置 → 快捷键 → 会话 → 新建独立窗口,默认 `Ctrl+3`),
* 键位存在终端设置的快捷键表里(设置 → 快捷键 → 会话 → 新建独立窗口,默认 `Alt+T`),
* 因此这里是「读设置 → 注册」而不是硬编码:改键后 watch 到变化即重新注册。
* 关掉那一行右侧的开关 = 不注册。
*
@@ -281,10 +281,10 @@ watch(
<template>
<!--
独立窗口模式自带四周留白(窗口控制栏之下没有模块级的 p-5);
独立窗口模式:窗口控制栏之下的区域由本组件占满(无边距、无圆角),
tab 模式由终端模块根节点的 p-5 提供边距。
-->
<div class="flex flex-col h-full overflow-hidden" :class="standalone ? 'p-3' : ''">
<div class="flex flex-col h-full overflow-hidden">
<PageToolbar
v-if="!standalone"
:icon="FolderTree"
@@ -301,7 +301,10 @@ watch(
分成两张卡片(`gap-3`)会让它读作「两个窗口并排」,而这里要做的是
「一个窗口的两半」—— 分界线可拖,与资源管理器的双栏一致。
-->
<Card class="flex-1 min-h-0 !py-0 !gap-0 overflow-hidden">
<Card
class="flex-1 min-h-0 !py-0 !gap-0 overflow-hidden"
:class="standalone ? 'rounded-none' : ''"
>
<div ref="splitRowRef" class="h-full min-h-0 flex">
<!-- 左栏:宽度用百分比(拖动的结果在窗口缩放后仍然成立) -->
<div class="min-w-0 flex flex-col" :style="{ width: `${store.filePaneSplit}%` }">
+184 -9
View File
@@ -24,7 +24,7 @@
* | 跟随 cd | 跟随「当前激活会话」(面板绑会话) | 跟随**本栏所选会话**的 cwd |
* | 新增目录校验 | 分别禁止 `/` 或 `\` | 两种分隔符都禁止(本地路径也认 `/`) |
*/
import { computed, ref, watch } from 'vue'
import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from 'vue'
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import {
ArrowLeft,
@@ -59,7 +59,7 @@ import {
DropdownMenuSeparator,
DropdownMenuTrigger
} from '@/components/ui/dropdown-menu'
import { fmtEntryTime, fmtFullTime, humanSize, joinLocal, joinRemote, parentOf } from '../fileUtils'
import { fmtFullTime, humanSize, joinLocal, joinRemote, parentOf } from '../fileUtils'
import type { FileSource, SessionInfo } from '@/types/terminal'
/**
@@ -472,6 +472,124 @@ function revealLocalPath(path: string) {
void store.revealLocalPath(path).catch(e => toast.error(`定位失败:${String(e)}`))
}
// ===== 右键菜单 =====
/**
* 行内右键菜单。
*
* 动作全部落在本栏:重命名 / 删除 / 新建 / 刷新都是本栏的局部操作,
* 只有「传送」需要父组件编排(本栏不知道对面是什么),因此仍然只是 `emit('transfer')`。
*
* 原生右键菜单被 `main.ts` 全局禁用了,所以这里是自绘菜单 —— 外观与终端右键菜单
*(`TerminalContextMenu`)同一套,不为文件列表另立一套视觉。
*/
const menuPos = ref<{ x: number; y: number } | null>(null)
/** 右键命中的行;`null` = 右键落在空白区域(只给本栏级动作) */
const menuEntry = ref<PaneEntry | null>(null)
const menuRef = ref<HTMLElement | null>(null)
function closeMenu() {
menuPos.value = null
menuEntry.value = null
}
/**
* 打开菜单并按视口边界收拢位置。
*
* 列表最后一行的右键位置几乎贴着窗口底边,不收拢的话菜单会有一半落在窗口外
*(原生菜单由系统负责这件事,自绘就得自己算)。菜单尺寸只能渲染后量出来,
* 所以收拢放在 `nextTick` 里。
*/
function openMenu(entry: PaneEntry | null, ev: MouseEvent) {
menuEntry.value = entry
menuPos.value = { x: ev.clientX, y: ev.clientY }
void nextTick(() => {
const el = menuRef.value
const pos = menuPos.value
if (!el || !pos) return
const rect = el.getBoundingClientRect()
menuPos.value = {
x: Math.max(4, Math.min(pos.x, window.innerWidth - rect.width - 4)),
y: Math.max(4, Math.min(pos.y, window.innerHeight - rect.height - 4))
}
})
}
/**
* 行上右键。
*
* 命中未选中的行时先把选择落到它身上(资源管理器的一致行为);
* 命中的行已在**多选**里则保留整组 —— 右键是「对当前选择执行动作」的入口,
* 后面的「传送」正需要整组。
*/
function onRowContextMenu(entry: PaneEntry, ev: MouseEvent) {
if (!isSelected(entry)) {
selected.value = [entry]
anchor = filtered.value.findIndex(e => e.path === entry.path)
}
openMenu(entry, ev)
}
/** 空白处右键:先取消选择,再给本栏级动作(新建目录 / 刷新) */
function onBlankContextMenu(ev: MouseEvent) {
selected.value = []
openMenu(null, ev)
}
function transferFromMenu() {
closeMenu()
emit('transfer')
}
function openFromMenu() {
const e = menuEntry.value
closeMenu()
if (e) openLocalPath(e.path)
}
function revealFromMenu() {
const e = menuEntry.value
closeMenu()
if (e) revealLocalPath(e.path)
}
function renameFromMenu() {
closeMenu()
startRename()
}
function removeFromMenu() {
closeMenu()
void removeSelected()
}
function newDirFromMenu() {
closeMenu()
showNewDir.value = true
}
function reloadFromMenu() {
closeMenu()
void load(cwd.value)
}
const onMenuKeydown = (e: KeyboardEvent) => {
if (e.key === 'Escape') closeMenu()
}
onMounted(() => {
// 点击任意处 / 按 ESC 关闭菜单(冒泡阶段:面板自身的 click 也要能关掉它)。
// 两栏各挂一份无妨:任一栏的点击都会把另一栏的菜单一起收掉 —— 一屏内
// 同时存在两个右键菜单本身就是不该出现的样子。
document.addEventListener('click', closeMenu)
document.addEventListener('keydown', onMenuKeydown)
})
onBeforeUnmount(() => {
document.removeEventListener('click', closeMenu)
document.removeEventListener('keydown', onMenuKeydown)
})
// ===== 对外接口(父组件编排传输时读这两样) =====
defineExpose({
@@ -665,11 +783,12 @@ defineExpose({
>
<span class="flex-1 min-w-0">名称</span>
<span class="w-[72px] shrink-0 text-right">大小</span>
<span class="w-[76px] shrink-0">修改时间</span>
<span class="w-[110px] shrink-0">修改时间</span>
<span v-if="isSsh" class="w-11 shrink-0 text-right">权限</span>
</div>
<ScrollArea class="flex-1 min-h-0">
<!-- 空白区域右键(本栏级动作):行的右键带 `.stop`,不会冒泡到这里 -->
<ScrollArea class="flex-1 min-h-0" @contextmenu="onBlankContextMenu">
<div v-if="loading" class="p-4 flex items-center justify-center gap-2">
<Loader2 class="size-3.5 animate-spin text-muted-foreground" />
<span class="text-xs text-muted-foreground">正在读取…</span>
@@ -691,6 +810,7 @@ defineExpose({
:class="isSelected(e) ? 'bg-row-selected' : 'hover:bg-row-hover'"
@click="clickEntry(e, $event)"
@dblclick="enter(e)"
@contextmenu.stop.prevent="onRowContextMenu(e, $event)"
>
<!-- 名称列:唯一可伸缩的一列(min-w-0 + truncate 是截断生效的充要条件) -->
<div class="flex-1 min-w-0 flex items-center gap-1.5">
@@ -742,11 +862,8 @@ defineExpose({
<span class="w-[72px] shrink-0 text-right text-muted-foreground tabular-nums whitespace-nowrap">
{{ e.isDir ? '—' : humanSize(e.size) }}
</span>
<span
class="w-[76px] shrink-0 text-muted-foreground tabular-nums whitespace-nowrap"
:title="fmtFullTime(e.modifiedAt)"
>
{{ fmtEntryTime(e.modifiedAt) }}
<span class="w-[110px] shrink-0 text-muted-foreground tabular-nums whitespace-nowrap">
{{ fmtFullTime(e.modifiedAt) }}
</span>
<span
v-if="isSsh"
@@ -775,5 +892,63 @@ defineExpose({
</Button>
</div>
</template>
<!-- ===== 右键菜单 =====
自绘菜单(`main.ts` 全局禁用了原生右键菜单),外观与终端右键菜单一致。
`fixed` + 视口坐标:不受列表滚动容器裁剪;位置已在 `openMenu` 里按视口收拢。
行上的菜单与空白处的菜单是两套条目 —— 前者作用于「选中的行」,
后者只给本栏级动作,因为右键位置本身就是用户对作用对象的声明。 -->
<div
v-if="menuPos"
ref="menuRef"
class="fixed z-50 min-w-[176px] py-1 rounded-md border border-border bg-popover shadow-lg text-xs"
:style="{ left: `${menuPos.x}px`, top: `${menuPos.y}px` }"
@click.stop
@contextmenu.stop.prevent
>
<template v-if="menuEntry">
<button
class="w-full px-3 py-1.5 text-left hover:bg-accent disabled:opacity-40 disabled:pointer-events-none"
:disabled="transferBlocked !== '' || filesSelected.length === 0"
:title="transferHint"
@click="transferFromMenu"
>
{{ transferLabel }}{{ filesSelected.length > 1 ? ` (${filesSelected.length})` : '' }}
</button>
<!-- 打开 / 定位只对本地行给出:远端路径在本机上没有这两个语义 -->
<template v-if="!isSsh">
<div class="my-1 h-px bg-border" />
<button class="w-full px-3 py-1.5 text-left hover:bg-accent" @click="openFromMenu">
用默认程序打开
</button>
<button class="w-full px-3 py-1.5 text-left hover:bg-accent" @click="revealFromMenu">
在资源管理器中显示
</button>
</template>
<div class="my-1 h-px bg-border" />
<button
class="w-full px-3 py-1.5 text-left hover:bg-accent disabled:opacity-40 disabled:pointer-events-none"
:disabled="selected.length !== 1"
@click="renameFromMenu"
>
重命名
</button>
<button
class="w-full px-3 py-1.5 text-left hover:bg-accent text-destructive"
@click="removeFromMenu"
>
删除
</button>
</template>
<template v-else>
<button class="w-full px-3 py-1.5 text-left hover:bg-accent" @click="newDirFromMenu">
新建目录
</button>
<button class="w-full px-3 py-1.5 text-left hover:bg-accent" @click="reloadFromMenu">
刷新
</button>
</template>
</div>
</div>
</template>
@@ -527,7 +527,13 @@ function moveHop(i: number, dir: -1 | 1) {
(monitor / downloader)都用 ScrollArea + max-h 的写法。
-->
<ScrollArea class="max-h-[60vh] pr-4">
<div v-if="editing" class="space-y-4">
<!--
`px-1.5` 不是装饰:ScrollArea 的 viewport 恒定 `overflow: hidden/scroll`,
输入框铺满视口时,`focus-visible:ring-3` 的焦点环(画在边框外侧 3px)
会被左右裁掉(聚焦后表现为「边被遮挡」)。内边距必须加在**滚动内容**这层,
加在 ScrollArea 根上只会把视口整体变窄,裁切线跟着输入框一起移动。
-->
<div v-if="editing" class="space-y-4 px-1.5">
<!-- 基本信息 -->
<div class="grid grid-cols-2 gap-3">
<div class="space-y-1.5">
@@ -543,9 +543,10 @@ function formatDate(rfc3339: string): string {
</DialogDescription>
</DialogHeader>
<!-- 表单较长,用 ScrollArea 滚动(见 HostManager 的编辑对话框同款说明) -->
<!-- 表单较长,用 ScrollArea 滚动(见 HostManager 的编辑对话框同款说明);
px-1.5 见同处说明:滚动内容不留内边距时输入框的聚焦环会被 viewport 裁掉 -->
<ScrollArea class="max-h-[60vh] pr-4">
<div class="space-y-3">
<div class="space-y-3 px-1.5">
<div class="space-y-1.5">
<Label class="text-xs">名称</Label>
<Input v-model="genForm.name" placeholder="例如:生产服务器" class="h-8 text-sm" />
@@ -628,9 +629,10 @@ function formatDate(rfc3339: string): string {
</DialogDescription>
</DialogHeader>
<!-- 含多行私钥文本域,容易超过视口高度,用 ScrollArea 滚动 -->
<!-- 含多行私钥文本域,容易超过视口高度,用 ScrollArea 滚动;
px-1.5 见 HostManager 编辑对话框的说明(滚动内容的聚焦环防裁切) -->
<ScrollArea class="max-h-[60vh] pr-4">
<div class="space-y-3">
<div class="space-y-3 px-1.5">
<div class="space-y-1.5">
<Label class="text-xs">名称</Label>
<Input v-model="importName" placeholder="例如:GitHub" class="h-8 text-sm" />
@@ -118,9 +118,20 @@ async function submit() {
</DialogDescription>
</DialogHeader>
<!-- 表单较长(七个字段 + 危险提示),用 ScrollArea 滚动(见 HostManager 同款说明) -->
<!--
表单较长(七个字段 + 危险提示),用 ScrollArea 滚动(见 HostManager 同款说明)。
`px-1.5` 不是装饰:reka 的 ScrollArea viewport 恒定是 `overflow: hidden/scroll`
(由 X/Y 滚动条是否启用决定,**不是**只在滚动时才裁),而 `focus-visible:ring-3`
的焦点环画在输入框边框**外侧** 3px。输入框铺满视口时,左右两侧的外环正好落在
裁切线上被切掉(表现为聚焦后「边被遮挡」)。给滚动内容留出内边距,外环落在
视口内部即可完整显示。
内边距必须加在**滚动内容**这一层:加在 ScrollArea 根上只会把视口整体变窄,
裁切线跟着输入框一起移动,环照样被切。
-->
<ScrollArea class="max-h-[60vh] pr-4">
<div v-if="draft" class="space-y-3">
<div v-if="draft" class="space-y-3 px-1.5">
<label class="block space-y-1">
<span class="text-[11px] text-muted-foreground">名称</span>
<Input v-model="draft.name" class="h-8 text-sm" placeholder="如:查找大文件" />
+6 -24
View File
@@ -67,7 +67,12 @@ export function humanSize(n: number): string {
return `${v < 10 ? v.toFixed(1) : Math.round(v)} ${units[i]}`
}
/** 完整时间戳 `YYYY-MM-DD HH:mm`(行的悬停提示用) */
/**
* 完整时间戳 `YYYY-MM-DD HH:mm`。
*
* 「修改时间」列直接显示它 —— 定宽列(`w-[110px]`)在 12px 字号下刚好放得下,
* 年月日与时刻都不再省略(此前本年内只显示 `MM-DD HH:mm`、更早的只显示日期)。
*/
export function fmtFullTime(ms?: number | null): string {
if (!ms) return ''
const d = new Date(ms)
@@ -75,29 +80,6 @@ export function fmtFullTime(ms?: number | null): string {
return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`
}
/**
* 列表里显示的紧凑时间。
*
* 本年内的条目省略年份(`05-19 10:01`),其余显示 `2024-05-19`。
*
* # 为什么不是「一律 `YYYY-MM-DD HH:mm`」
*
* 文件列表的「修改时间」列是**定宽**的,而完整时间戳在 12px 字号下要 100px 左右;
* 定宽列一旦装不下就会换行(这正是改版前那一版的表现:日期被折成三行)。
* 截断也不行 —— 时间的一半信息比年份缺失更糟。因此按「近期看时刻、远期看日期」
* 分档,一列 76px 两种形态都放得下;完整值仍在悬停提示里。
*/
export function fmtEntryTime(ms?: number | null): string {
if (!ms) return ''
const d = new Date(ms)
const pad = (x: number) => String(x).padStart(2, '0')
const md = `${pad(d.getMonth() + 1)}-${pad(d.getDate())}`
if (d.getFullYear() === new Date().getFullYear()) {
return `${md} ${pad(d.getHours())}:${pad(d.getMinutes())}`
}
return `${d.getFullYear()}-${md}`
}
/** 两栏连接的组合是否支持传输(本地↔本地没有传输语义,见 FileManager 的说明) */
export function transferKind(
from: FileSource | null,
+2 -2
View File
@@ -85,8 +85,8 @@ const searchItems: SearchIndexItem[] = [
},
{
title: '终端独立窗口',
description: '把会话拖出主窗口,独立窗口承载单个会话;Ctrl+3 可直接唤起新建列表',
keywords: ['独立窗口', '分离', 'detach', '新窗口', '多屏', 'ctrl+3'],
description: '把会话拖出主窗口,独立窗口承载单个会话;Alt+T 可直接唤起新建列表',
keywords: ['独立窗口', '分离', 'detach', '新窗口', '多屏', 'alt+t'],
tab: 'settings'
},
{
+1 -1
View File
@@ -88,7 +88,7 @@ const sourceDirty = computed(() => {
return editableText.value.trim() !== lastTranslated.value.trim()
})
// ===== 面板模式(Ctrl+2 打开):候选列表 + 键盘交互 =====
// ===== 面板模式(默认 Alt+F 打开):候选列表 + 键盘交互 =====
const candidates = ref<PanelCandidate[]>([])
const listOpen = ref(false)
const activeCandidate = ref(0)
@@ -657,7 +657,7 @@ function templateWarning(text: string): string {
<Input
v-model="shortcutDraft.panelShortcut"
class="h-8 w-40 text-[13px]"
placeholder="Ctrl+2"
placeholder="Alt+F"
/>
<span class="text-[11px] text-muted-foreground">全局生效;留空禁用</span>
</div>
+545
View File
@@ -0,0 +1,545 @@
import { defineStore } from 'pinia'
import { computed, ref } from 'vue'
import { invoke } from '@tauri-apps/api/core'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { openUrl as openExternalUrl } from '@tauri-apps/plugin-opener'
import { toast } from 'vue-sonner'
import { createLogger } from '@/lib/logger'
import { EVENTS, WINDOWS } from '@/lib/constants'
import type {
DshAiPreview,
DshEnvStatus,
DshInstallProgress,
DshInstallStatus,
DshNodeStatus,
DshNpmRegistryInfo,
DshServerStatus,
DshSettings,
DshUpdateInfo
} from '@/types/dsh'
const logger = createLogger('dsh')
/** 用户主动取消的统一文案(与 Rust 侧 `node.rs::NODE_CANCELLED` 对应) */
const CANCELLED = '已取消'
/**
* dsh 模块(DeepSeek Harness 外壳)状态。
*
* 调用方式说明:P0 阶段用原生 `invoke` 而不是 `@/lib/bindings` 的 `commands.*`——
* specta 绑定只在 debug 构建启动时重新生成,新增命令在首次 `tauri dev` 之前不存在于
* bindings.ts。把调用点全部收敛在此处,是为了将来替换成 `commands.dshXxx` 时
* 只改这一个文件(与 translateStore 同约定)。
*/
export const useDshStore = defineStore('dsh', () => {
const node = ref<DshNodeStatus | null>(null)
const install = ref<DshInstallStatus | null>(null)
const server = ref<DshServerStatus | null>(null)
const settings = ref<DshSettings | null>(null)
const progress = ref<DshInstallProgress | null>(null)
const updateInfo = ref<DshUpdateInfo | null>(null)
const preview = ref<DshAiPreview | null>(null)
const logs = ref('')
/**
* dsh 安装输出(npm 尾部)。
*
* 只存在 Rust 内存缓冲里、由 `dsh_install_log` 拉取:用户明确要求安装日志
* **不进应用日志**,只在「安装引导 → dsh 本体」页临时展示。
* 用轮询而不是事件,是为了避免"切走模块漏掉中间行"——每次都取完整缓冲。
*/
const installLog = ref('')
/** 本次安装实际使用的 npm 源(含来源说明;见 `loadRegistryInfo`) */
const registryInfo = ref<DshNpmRegistryInfo | null>(null)
/** 是否已完成首次加载(避免初始空值导致状态闪烁) */
const initialized = ref(false)
/** 安装/下载进行中 */
const installing = ref(false)
const starting = ref(false)
const stopping = ref(false)
const checkingUpdate = ref(false)
const loadingLogs = ref(false)
const nodeReady = computed(() => node.value?.satisfies ?? false)
const installed = computed(() => install.value?.installed ?? false)
const running = computed(() => server.value?.running ?? false)
const ready = computed(() => server.value?.ready ?? false)
/** 环境齐备(Node 合规 + dsh 已安装) */
const envReady = computed(() => nodeReady.value && installed.value)
/** 规范地址(不含令牌),用于界面展示 */
const displayUrl = computed(
() => server.value?.url ?? `http://127.0.0.1:${settings.value?.port ?? 3080}`
)
/**
* 能否打开界面:必须在 dsh 打印出带令牌的启动地址之后。
*
* dsh web 的浏览器鉴权是「进程级随机令牌 → 首次访问换 cookie」,直接打开
* 规范地址只会拿到 `dsh web authentication required`。我们传了 `--no-open`,
* 没有浏览器替它完成这次换取,所以只能靠抓取的那行输出。
*/
const canOpen = computed(() => !!server.value?.ready && !!server.value?.launchUrl)
/** 用于打开的地址(带令牌) */
const openUrl = computed(() => server.value?.launchUrl ?? displayUrl.value)
/** 安装引导当前步(0=Node,1=dsh,2=AI,3=完成) */
const setupStep = computed(() => {
if (!nodeReady.value) return 0
if (!installed.value) return 1
return 2
})
let unlisteners: UnlistenFn[] = []
/**
* 全局快捷键事件的监听器**单独持有**:它必须跨模块卸载存活
* (快捷键在任意模块下都要能开窗,而 `stopListeners` 会在模块卸载时清理)。
*/
let shortcutUnlisten: UnlistenFn | null = null
/** 安装期间的日志轮询定时器 */
let installLogTimer: number | null = null
const sleep = (ms: number) => new Promise(resolve => window.setTimeout(resolve, ms))
/** 拉取一次安装输出 */
async function loadInstallLog() {
try {
installLog.value = await invoke<string>('dsh_install_log')
} catch (e) {
logger.error('读取安装输出失败: ' + e)
}
}
function startInstallLogPolling() {
if (installLogTimer !== null) return
installLogTimer = window.setInterval(() => void loadInstallLog(), 600)
}
function stopInstallLogPolling() {
if (installLogTimer !== null) {
window.clearInterval(installLogTimer)
installLogTimer = null
}
}
/** 读取本次安装实际使用的 npm 源 */
async function loadRegistryInfo() {
try {
registryInfo.value = await invoke<DshNpmRegistryInfo>('dsh_npm_registry_info')
} catch (e) {
logger.error('读取 npm 源信息失败: ' + e)
}
}
/** 统一错误处理:取消静默,其余 toast */
function handleError(e: unknown, fallback: string) {
const msg = e instanceof Error ? e.message : String(e)
if (msg.includes(CANCELLED)) return
logger.error(`${fallback}: ${msg}`)
toast.error(msg || fallback)
}
/** 读取环境总览(Node / dsh / 服务 / 设置) */
async function refresh() {
try {
const env = await invoke<DshEnvStatus>('dsh_env_status')
node.value = env.node
install.value = env.dsh
server.value = env.server
settings.value = env.settings
initialized.value = true
} catch (e) {
logger.error('读取 dsh 环境状态失败: ' + e)
}
}
/** 重新探测 Node */
async function detectNode() {
try {
node.value = await invoke<DshNodeStatus>('dsh_node_detect')
} catch (e) {
handleError(e, '探测 Node 失败')
}
}
/** 下载并安装便携 Node(version 为空 = 自动选版本) */
async function installNode(version?: string) {
installing.value = true
try {
node.value = await invoke<DshNodeStatus>('dsh_node_install', { version: version ?? null })
} catch (e) {
handleError(e, '安装 Node 失败')
} finally {
installing.value = false
progress.value = null
}
}
/** 安装或更新 dsh(version 为空 = latest) */
async function installDsh(version?: string) {
installing.value = true
installLog.value = ''
startInstallLogPolling()
try {
install.value = await invoke<DshInstallStatus>('dsh_install', { version: version ?? null })
updateInfo.value = null
} catch (e) {
handleError(e, '安装 dsh 失败')
} finally {
installing.value = false
progress.value = null
stopInstallLogPolling()
// 收尾再取一次,确保拿到最后几行(含错误摘要)
await loadInstallLog()
await refresh()
}
}
/** 更新到 latest(服务会先停止) */
async function updateDsh() {
installing.value = true
installLog.value = ''
startInstallLogPolling()
try {
install.value = await invoke<DshInstallStatus>('dsh_update')
updateInfo.value = null
} catch (e) {
handleError(e, '更新 dsh 失败')
} finally {
installing.value = false
progress.value = null
stopInstallLogPolling()
await loadInstallLog()
await refresh()
}
}
/** 取消进行中的下载/安装 */
async function cancelInstall() {
try {
await invoke('dsh_cancel_install')
} catch (e) {
logger.error('取消失败: ' + e)
}
}
/** 卸载 dsh(停止服务 + 删除包目录) */
async function uninstallDsh() {
try {
await invoke('dsh_uninstall')
} catch (e) {
handleError(e, '卸载 dsh 失败')
} finally {
await refresh()
}
}
/** 查询 npm 上的可用版本 */
async function checkUpdate() {
checkingUpdate.value = true
try {
updateInfo.value = await invoke<DshUpdateInfo>('dsh_check_update')
} catch (e) {
handleError(e, '检查更新失败')
} finally {
checkingUpdate.value = false
}
return updateInfo.value
}
/** 保存设置(即时生效) */
async function saveSettings(patch: Partial<DshSettings>) {
if (!settings.value) return
try {
settings.value = await invoke<DshSettings>('dsh_save_settings', {
settings: { ...settings.value, ...patch }
})
// 安装目录改动会同时影响「已安装状态 / 实际安装位置 / 实际使用的源」,
// 只 reload 设置会让界面继续显示旧目录下的安装状态
if ('installDir' in patch) await refresh()
if ('npmRegistry' in patch || 'installDir' in patch) await loadRegistryInfo()
// 快捷键改动立即重新注册(注册内部先注销旧的,幂等)
if ('shortcut' in patch) await registerShortcut()
} catch (e) {
handleError(e, '保存设置失败')
}
}
async function start() {
starting.value = true
try {
server.value = await invoke<DshServerStatus>('dsh_start')
} catch (e) {
handleError(e, '启动 dsh 失败')
// 端口占用 / 环境缺失等由 Rust 记入 server.error,刷新后状态卡会显示原因
await refresh()
} finally {
starting.value = false
}
}
async function stop() {
stopping.value = true
try {
server.value = await invoke<DshServerStatus>('dsh_stop')
} catch (e) {
handleError(e, '停止 dsh 失败')
} finally {
stopping.value = false
}
}
async function restart() {
starting.value = true
try {
server.value = await invoke<DshServerStatus>('dsh_restart')
} catch (e) {
handleError(e, '重启 dsh 失败')
await refresh()
} finally {
starting.value = false
}
}
/** 预览将写入 settings.yaml 的内容 */
async function loadAiPreview() {
try {
preview.value = await invoke<DshAiPreview>('dsh_ai_preview')
} catch (e) {
handleError(e, '生成 AI 配置预览失败')
}
return preview.value
}
/** 执行 AI 配置同步 */
async function syncAi() {
try {
preview.value = await invoke<DshAiPreview>('dsh_ai_sync')
toast.success('AI 供应商已同步到 dsh')
} catch (e) {
handleError(e, '同步 AI 配置失败')
}
return preview.value
}
async function loadLogs(lines = 300) {
loadingLogs.value = true
try {
logs.value = await invoke<string>('dsh_log_tail', { lines })
} catch (e) {
logger.error('读取日志失败: ' + e)
} finally {
loadingLogs.value = false
}
}
async function clearLogs() {
try {
await invoke('dsh_log_clear')
logs.value = ''
} catch (e) {
logger.error('清空日志失败: ' + e)
}
}
async function openDir() {
try {
await invoke('dsh_open_dir')
} catch (e) {
handleError(e, '打开目录失败')
}
}
// ===== 打开 dsh 界面(独立窗口 / 系统浏览器) =====
/**
* 打开 dsh Web UI 的独立窗口(单例)。
*
* 地址必须用**带令牌**的 `openUrl`:dsh 靠「首次访问带令牌的地址」种下会话
* cookie,直接开规范地址只会拿到 401。
* 窗口放在 store 而非组件里,是因为全局快捷键要跨模块开窗
* (与 screenshotStore 建覆盖层窗口同一取舍)。
*/
async function openWebWindow() {
const { WebviewWindow } = await import('@tauri-apps/api/webviewWindow')
const label = WINDOWS.dshWeb
try {
const existing = await WebviewWindow.getByLabel(label)
if (existing) {
await existing.setFocus()
return
}
// 远端页面拿不到 Tauri IPC(未登记 capability),因此保留系统装饰以便拖动与关闭
new WebviewWindow(label, {
url: openUrl.value,
title: 'DeepSeek Harness',
width: 1280,
height: 860,
minWidth: 900,
minHeight: 600,
decorations: true,
resizable: true,
visible: true,
focus: true
}).once('tauri://error', e => {
toast.error(`打开独立窗口失败:${String(e.payload ?? '')}`)
})
} catch (e) {
toast.error(`打开独立窗口失败:${e instanceof Error ? e.message : String(e)}`)
}
}
/** 用系统默认浏览器打开 dsh Web UI(同样带令牌) */
async function openInBrowser() {
try {
await openExternalUrl(openUrl.value)
} catch (e) {
toast.error(`打开浏览器失败:${e instanceof Error ? e.message : String(e)}`)
}
}
/**
* 全局快捷键触发:服务已就绪直接开窗,否则给一次短暂等待。
*
* `canOpen` 要求「已监听 + 已拿到令牌」——dsh 打印那行输出可能比开始监听晚几秒,
* 所以这里轮询等一会儿再放弃,而不是立刻报未就绪。
*/
async function handleShortcutOpen() {
if (!server.value) await refresh()
if (!canOpen.value) {
if (!running.value) {
toast.warning('dsh 服务未启动:请先在 dsh 模块的「状态」页启动服务')
return
}
for (let i = 0; i < 40 && !canOpen.value; i++) await sleep(250)
if (!canOpen.value) {
toast.warning('dsh 尚未就绪(未拿到访问令牌),请查看 dsh 模块的日志')
return
}
}
await openWebWindow()
}
// ===== 全局快捷键 =====
/** 按当前设置注册快捷键(失败只提示,不抛) */
async function registerShortcut() {
const shortcut = settings.value?.shortcut ?? ''
try {
await invoke('dsh_register_shortcut', { shortcut })
} catch (e) {
toast.error(e instanceof Error ? e.message : String(e))
}
}
async function unregisterShortcut() {
try {
await invoke('dsh_unregister_shortcut')
} catch (e) {
logger.error('注销快捷键失败: ' + e)
}
}
/**
* 应用启动时调用(main.ts 应用级初始化)。
*
* 与模块挂载无关:快捷键必须在任何模块下都能用,所以监听器与注册都不放进
* `stopListeners`/`init` 的生命周期里。
*/
async function initGlobalShortcut() {
await refresh()
if (!shortcutUnlisten) {
shortcutUnlisten = await listen(EVENTS.dshOpenWindow, () => {
void handleShortcutOpen()
})
}
await registerShortcut()
}
/** 注册事件监听(幂等) */
async function startListeners() {
if (unlisteners.length > 0) return
unlisteners.push(
await listen<DshInstallProgress>(EVENTS.dshInstallProgress, e => {
progress.value = e.payload
})
)
unlisteners.push(
await listen<DshServerStatus>(EVENTS.dshServerState, e => {
server.value = e.payload
})
)
}
function stopListeners() {
stopInstallLogPolling()
for (const un of unlisteners) un()
unlisteners = []
}
/** 模块激活时调用 */
async function init() {
await startListeners()
await refresh()
// 安装输出只在内存缓冲里:重新进入模块时补一次,安装中则恢复轮询
await loadInstallLog()
// npm 源解析要跑子进程,放在最后且不 await 阻塞首屏
void loadRegistryInfo()
if (installing.value) startInstallLogPolling()
}
return {
// state
node,
install,
server,
settings,
progress,
updateInfo,
preview,
logs,
installLog,
registryInfo,
initialized,
installing,
starting,
stopping,
checkingUpdate,
loadingLogs,
// getters
nodeReady,
installed,
running,
ready,
envReady,
displayUrl,
canOpen,
openUrl,
setupStep,
// actions
refresh,
detectNode,
installNode,
installDsh,
updateDsh,
cancelInstall,
uninstallDsh,
checkUpdate,
saveSettings,
start,
stop,
restart,
loadAiPreview,
syncAi,
loadInstallLog,
loadRegistryInfo,
loadLogs,
clearLogs,
openDir,
openWebWindow,
openInBrowser,
registerShortcut,
unregisterShortcut,
initGlobalShortcut,
init,
stopListeners
}
})
+98 -29
View File
@@ -6,10 +6,18 @@ import { availableMonitors } from '@tauri-apps/api/window'
import { emit, listen, type UnlistenFn } from '@tauri-apps/api/event'
import { toast } from 'vue-sonner'
import { EVENTS, STORAGE_KEYS, WINDOWS } from '@/lib/constants'
import { createLogger } from '@/lib/logger'
// Rust 端通过 tauri-specta 生成的命令绑定(bindings.ts)
import { commands } from '@/lib/bindings'
import type { WindowInfo } from '@/modules/screenshot/types'
const logger = createLogger('截图')
/** 各常驻子窗口就绪握手的等待上限:超时仍继续(与旧行为一致,只是不再每次都白等) */
const OVERLAY_READY_TIMEOUT_MS = 3000
const EDITOR_READY_TIMEOUT_MS = 5000
const PIN_READY_TIMEOUT_MS = 3000
export interface RecentCapture {
id: string
/** 缩略图 data URL(JPEG,~256px 宽,常驻内存的只有它,完整图已落盘缓存) */
@@ -39,18 +47,27 @@ export interface ScreenshotSettings {
pinShortcut: string
/** 截图延时(秒),0 表示立即截图 */
delay: number
/**
* 默认快捷键的一次性迁移标记(随设置落盘,见 loadSettings)。
* 用它而**不是** SETTINGS_VERSION:后者会整体重置设置,为改两个快捷键
* 丢掉保存目录/延迟不值得。
*/
shortcutDefaultsVersion?: number
}
const SETTINGS_KEY = 'screenshot-settings'
/** 设置版本:结构变更(默认值/字段增删)时递增,清除旧数据以应用新默认值 */
const SETTINGS_VERSION = 2
/** 快捷键默认值迁移版本(v2:截图 ctrl+1→F3、贴图 alt+1→F4) */
const SHORTCUT_DEFAULTS_VERSION = 2
const DEFAULT_SETTINGS: ScreenshotSettings = {
autoSave: false,
saveDir: '',
historyLimit: 48,
shortcut: 'ctrl+1',
pinShortcut: 'alt+1',
shortcut: 'F3',
pinShortcut: 'F4',
delay: 0,
shortcutDefaultsVersion: SHORTCUT_DEFAULTS_VERSION,
}
export const useScreenshotStore = defineStore('screenshot', () => {
@@ -66,7 +83,6 @@ export const useScreenshotStore = defineStore('screenshot', () => {
const OVERLAY_LABEL = WINDOWS.screenshotOverlay
let overlayWin: WebviewWindow | null = null
let overlayReadyResolve: (() => void) | null = null
let overlayReadyPromise: Promise<void> | null = null
let readyListenerInit = false
/** 上次已应用的覆盖层布局矩形(虚拟屏未变化时跳过 setPosition/setSize,省 2 次 IPC 往返) */
let lastOverlayRectKey = ''
@@ -79,7 +95,6 @@ export const useScreenshotStore = defineStore('screenshot', () => {
let pinReadyUnlisten: UnlistenFn | null = null
let pinReadyListenerInit = false
let pinReadyResolve: (() => void) | null = null
let pinReadyPromise: Promise<void> | null = null
/** 贴图全局快捷键事件监听 */
let pinShortcutUnlisten: UnlistenFn | null = null
@@ -99,6 +114,19 @@ export const useScreenshotStore = defineStore('screenshot', () => {
saveSettings()
} else {
settings.value = { ...DEFAULT_SETTINGS, ...parsed }
// 默认快捷键一次性迁移:仍等于旧默认值 = 用户没改过,换成新默认值;
// 改过(或已清空禁用)的原样保留。标记落盘后不会再改写,用户之后
// 就算主动绑回 ctrl+1 / alt+1 也不会被覆盖。
if ((parsed.shortcutDefaultsVersion ?? 1) < SHORTCUT_DEFAULTS_VERSION) {
if (settings.value.shortcut.toLowerCase() === 'ctrl+1') {
settings.value.shortcut = DEFAULT_SETTINGS.shortcut
}
if (settings.value.pinShortcut.toLowerCase() === 'alt+1') {
settings.value.pinShortcut = DEFAULT_SETTINGS.pinShortcut
}
settings.value.shortcutDefaultsVersion = SHORTCUT_DEFAULTS_VERSION
saveSettings()
}
}
}
} catch (e) {
@@ -181,7 +209,7 @@ export const useScreenshotStore = defineStore('screenshot', () => {
await overlayWin?.setSize(new PhysicalSize(rect.width, rect.height))
lastOverlayRectKey = rectKey
}
await waitOverlayReady()
await ensureOverlayReady()
// 携带捕获时刻光标 + 窗口列表:覆盖层显示前即可完成初始高亮,无"遮罩→高亮"闪烁
await emit(EVENTS.screenshotBegin, {
cursorX: start.cursorX,
@@ -197,18 +225,37 @@ export const useScreenshotStore = defineStore('screenshot', () => {
}
}
function resetOverlayReady() {
overlayReadyPromise = new Promise<void>((resolve) => {
/** 重置就绪信号,并返回这一轮的 promise(调用方直接持有,避免读到被后续 reset 覆盖的引用) */
function resetOverlayReady(): Promise<void> {
return new Promise<void>((resolve) => {
overlayReadyResolve = resolve
})
}
/** 等待覆盖层就绪(首次创建时等 onMounted 完成,之后立即返回) */
async function waitOverlayReady() {
await Promise.race([
overlayReadyPromise,
new Promise<void>((r) => setTimeout(r, 3000)),
/**
* 等待覆盖层就绪(每次截图前握手)。
*
* # 为什么不能只等「首次 ready 事件」
*
* 覆盖层的 ready 只在它自己的 onMounted 里发一次,而主窗口的 JS 上下文会**独立**
* 重载(dev 下 Vite 整页刷新、改了前端代码后的 reload),此时覆盖层窗口是**存活**的
* (它不会被销毁),重载后的主窗口却重新注册了一个永远等不到「首次」ready 的监听:
* `Promise.race` 每次都落到 3s 超时上白等 —— 表现为「按快捷键后要等几秒才出现」,
* 且没有任何报错可查。
*
* 因此改为每次截图前主动握手:重置就绪信号 → ping 覆盖层 → 等它应答 ready。
* 覆盖层尚未加载完时 ping 会丢,但它 onMounted 末尾的首次 ready 会兑现同一个信号
*(两条路径调用同一个 resolve),所以「首轮创建」这一情形也不会被漏掉。
*/
async function ensureOverlayReady() {
const ready = resetOverlayReady()
void emit(EVENTS.screenshotOverlayPing).catch(() => {})
const answered = await Promise.race([
ready.then(() => true),
new Promise<boolean>((r) => setTimeout(() => r(false), OVERLAY_READY_TIMEOUT_MS)),
])
// 超时说明 begin 监听可能尚未注册(覆盖层正在加载/已异常),本轮 begin 事件可能丢失
if (!answered) logger.warn(`覆盖层未在 ${OVERLAY_READY_TIMEOUT_MS}ms 内应答就绪,本轮截图可能丢失`)
}
/** 创建常驻覆盖层窗口(隐藏、透明、置顶、无任务栏;启动时创建,复用直到应用退出) */
@@ -259,19 +306,29 @@ export const useScreenshotStore = defineStore('screenshot', () => {
let editorReadyUnlisten: UnlistenFn | null = null
let editorReadyListenerInit = false
let editorReadyResolve: (() => void) | null = null
let editorReadyPromise: Promise<void> | null = null
function resetEditorReady() {
editorReadyPromise = new Promise<void>((resolve) => {
/** 重置就绪信号,并返回这一轮的 promise(调用方直接持有,避免读到被后续 reset 覆盖的引用) */
function resetEditorReady(): Promise<void> {
return new Promise<void>((resolve) => {
editorReadyResolve = resolve
})
}
async function waitEditorReady() {
await Promise.race([
editorReadyPromise,
new Promise<void>((r) => setTimeout(r, 5000)),
/**
* 等待编辑器就绪(每次打开前握手)。
*
* 与 `ensureOverlayReady` 同一取舍:编辑器窗口是**常驻复用**的,ready 只在它的
* onMounted 里发一次;主窗口 JS 上下文重载后(dev 下常见)新注册的监听永远等不到
* 那次 ready,于是每次「打开编辑器」都白等 5s。改为每次主动 ping + 等应答。
*/
async function ensureEditorReady() {
const ready = resetEditorReady()
void emit(EVENTS.screenshotEditorPing).catch(() => {})
const answered = await Promise.race([
ready.then(() => true),
new Promise<boolean>((r) => setTimeout(() => r(false), EDITOR_READY_TIMEOUT_MS)),
])
if (!answered) logger.warn(`编辑器未在 ${EDITOR_READY_TIMEOUT_MS}ms 内应答就绪,本轮加载可能丢失`)
}
async function ensureEditorListener() {
@@ -316,7 +373,7 @@ export const useScreenshotStore = defineStore('screenshot', () => {
async function openEditor() {
await ensureEditorListener()
await ensureEditorWindow()
await waitEditorReady()
await ensureEditorReady()
await emit(EVENTS.screenshotEditorLoad)
}
@@ -536,7 +593,7 @@ export const useScreenshotStore = defineStore('screenshot', () => {
})
}
/** 应用启动时按已保存的快捷键注册全局热键(支持自定义,默认 Ctrl+Alt+A) */
/** 应用启动时按已保存的快捷键注册全局热键(支持自定义,默认截图 F3 / 贴图 F4) */
async function initShortcutRegistration() {
try {
await commands.screenshotRegisterShortcut(settings.value.shortcut)
@@ -559,18 +616,30 @@ export const useScreenshotStore = defineStore('screenshot', () => {
}
// ===== 贴图窗口 =====
function resetPinReady() {
pinReadyPromise = new Promise<void>((resolve) => {
/**
* 重置就绪信号,并返回这一轮的 promise(调用方直接持有,避免读到被后续 reset 覆盖的引用)
*/
function resetPinReady(): Promise<void> {
return new Promise<void>((resolve) => {
pinReadyResolve = resolve
})
}
/** 等待贴图窗口就绪(首次创建时等 onMounted 完成,之后立即返回) */
async function waitPinReady() {
await Promise.race([
pinReadyPromise,
new Promise<void>((r) => setTimeout(r, 3000)),
/**
* 等待贴图窗口就绪(每次贴图前握手)。
*
* 与 `ensureOverlayReady` 同一取舍。此前只有「创建窗口」那条路径会等待,复用已有
* 窗口时直接 emit `screenshotPinShow` —— 主窗口重载后贴图窗口可能仍在加载,
* 事件就静默丢了(按了没反应);统一握手后两条路径都先确认接收方就绪。
*/
async function ensurePinReady() {
const ready = resetPinReady()
void emit(EVENTS.screenshotPinPing).catch(() => {})
const answered = await Promise.race([
ready.then(() => true),
new Promise<boolean>((r) => setTimeout(() => r(false), PIN_READY_TIMEOUT_MS)),
])
if (!answered) logger.warn(`贴图窗口未在 ${PIN_READY_TIMEOUT_MS}ms 内应答就绪,本轮贴图可能丢失`)
}
/** 注册贴图窗口就绪监听(首次贴图前调用) */
@@ -612,7 +681,6 @@ export const useScreenshotStore = defineStore('screenshot', () => {
focus: false,
visible: false,
})
await waitPinReady()
}
/**
@@ -640,6 +708,7 @@ export const useScreenshotStore = defineStore('screenshot', () => {
const i = Math.max(0, Math.min(index ?? 0, recent.value.length - 1))
localStorage.setItem(PIN_INDEX_KEY, String(i))
await ensurePinWindow()
await ensurePinReady()
await emit(EVENTS.screenshotPinShow)
}
+4
View File
@@ -1,3 +1,7 @@
@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
/* ---break---
*/
/* 把 Tailwind 的自动内容检测根**收窄到 src/**,不要从项目根开始扫。
*
* 原因:Tailwind v4 默认以项目根为扫描起点,只读**根目录**的 .gitignore。本仓库的
+138
View File
@@ -0,0 +1,138 @@
/**
* dsh 模块(DeepSeek Harness 外壳)的前端类型。
*
* 与 Rust 侧 `src-tauri/src/dsh/types.rs` 一一对应(camelCase)。
*
* 注意:这里手写类型是**过渡态**——specta 绑定只在 debug 构建启动时重新生成
* (`lib.rs::export_bindings`),新增命令在首次 `bun run tauri dev` 之前不存在于
* `src/lib/bindings.ts`。调用点全部收敛在 `@/stores/dshStore`,将来换成
* `commands.dshXxx` 时只改那一个文件。
*/
/** 模块设置(与 Rust `DshSettings` 对应) */
export interface DshSettings {
version: number
/** auto(系统优先,缺失回落托管)| system | managed */
nodeSource: string
/** 指定下载的 Node 版本(空 = 自动取满足要求的最新版) */
managedNodeVersion: string
/** Node 分发包镜像前缀(空 = 官方 nodejs.org) */
nodeMirror: string
/** npm registry(空 = 官方源) */
npmRegistry: string
/** 下载 Node / npm 安装是否走代理模块 */
useProxy: boolean
port: number
autoStart: boolean
/** 全局快捷键:打开 dsh Web 独立窗口(空 = 未启用),默认 Alt+D */
shortcut: string
/** managed(模块目录)| user(~/.dsh) */
dshHomeMode: string
/** 工作区目录(空 = 模块目录下的 workspace) */
workspace: string
/**
* dsh 本体的安装目录(npm `--prefix` 目标,即 node_modules 所在位置)。
* 空 = 模块目录。只有 dsh 本体跟随此设置;便携 Node、$DSH_HOME、日志与
* 模块设置仍在应用数据目录。
*/
installDir: string
/** 映射为 dsh 默认模型的 Thing AI 供应商 id */
providerId: string
aiSync: boolean
}
/** Node 运行环境状态 */
export interface DshNodeStatus {
/** system | managed | none */
source: string
path: string | null
version: string | null
satisfies: boolean
required: string
}
/** dsh 本体安装状态 */
export interface DshInstallStatus {
installed: boolean
version: string | null
entry: string | null
dir: string
}
/** 服务进程状态 */
export interface DshServerStatus {
running: boolean
ready: boolean
pid: number | null
port: number
/** 规范地址(不含令牌,用于展示) */
url: string
/**
* 带令牌的启动地址(**用于打开界面**)。
*
* dsh web 的鉴权是「进程级随机令牌 → 首次访问换 cookie」:直接访问 `url`
* 只会拿到 401。令牌每次启动都不同,只能从 dsh 输出里抓取,因此进程刚起来时
* 这里可能为 null(等它打印那一行)。
*/
launchUrl: string | null
startedAt: number | null
error: string | null
}
/** 环境总览 */
export interface DshEnvStatus {
node: DshNodeStatus
dsh: DshInstallStatus
server: DshServerStatus
settings: DshSettings
}
/** 安装/下载进度事件载荷 */
export interface DshInstallProgress {
/** download | extracting | installing | done | error */
stage: string
/** 0 表示「不确定进度」(npm 无百分比输出时前端显示动画条) */
percent: number
downloadedBytes: number
totalBytes: number | null
message: string
}
/** 版本更新信息 */
export interface DshUpdateInfo {
current: string | null
latest: string
hasUpdate: boolean
versions: string[]
}
/** npm 源信息:本次安装实际用哪个源、来自哪里 */
export interface DshNpmRegistryInfo {
/** 本次安装/查询实际会使用的源(已去掉末尾 `/`) */
effective: string
/** setting(模块设置指定)| npm(npm 自身配置链)| fallback(默认官方源) */
source: string
/** npm 自身解析出的源(含系统 Node 的 ~/.npmrc),未检测到时为 null */
npmRegistry: string | null
/** 模块设置里显式填写的值(空 = 未指定) */
setting: string
}
/** AI 供应商映射项(预览,不含明文密钥) */
export interface DshAiProvider {
id: string
name: string
envName: string
baseUrl: string
model: string
hasKey: boolean
}
/** settings.yaml 同步预览 */
export interface DshAiPreview {
yaml: string
providers: DshAiProvider[]
defaultProvider: string | null
defaultModel: string | null
settingsPath: string
}
+1 -1
View File
@@ -99,7 +99,7 @@ export const DEFAULT_TRANSLATE_AI_PARAMS: Omit<TranslateAiParams, 'providerId'>
export interface SelectionSettings {
enabled: boolean
/** 打开翻译面板的全局快捷键(默认 Ctrl+2) */
/** 打开翻译面板的全局快捷键(默认 Alt+F) */
panelShortcut: string
mode: string
restoreClipboard: boolean