DeepSeek Harness Tauri 桌面版 | Only 8mb installer, zero environment setup, preset plugins, Windows / macOS / Linux.
//! 补丁层语法错误的隔离:让安全模式在用户补丁层损坏时仍然可用。
//!
//! `$DSH_HOME/cordis.patch.yml`(机器级 home 层)与
//! `$DSH_HOME/profiles/<id>/cordis.patch.yml`(档案层)都是用户可手写的 YAML
//! 补丁层。上游 dsh 的契约是「文件存在却不能被应用时必须大声失败,绝不静默跳过」
//! (`@deepseek-ai/dsh-app-boot` 的 `loadOptionalPatches` 明确写着这一点),桌面端
//! 的内置插件自愈([`super::internal::repair_loader_state`])同样在解析阶段直接失败。
//! 于是一处手写笔误——典型是 `!!js` 表达式里带 `: `/`?` 却没加引号——会让应用
//! **永久不可用**:每次启动都停在同一处,而唯一的兜底入口「安全模式」也走同一份
//! home 层(home 层作用于所有档案,安全档案不例外),连兜底一起失效(issue #525)。
//!
//! 因此这里提供「隔离」这一**显式**恢复动作:把解析不了的补丁文件改名为
//! `<原文件名>.broken-<UTC 时间戳>`(绝不删除,内容原样保留),决定权交回用户
//! ——修好语法后改回原名即可恢复。只有用户点「安全模式」或错误页的「隔离损坏的
//! 补丁文件」时才执行,绝不自动发生;普通档案的启动路径仍然按上游契约大声失败,
//! 由前端给出「哪个文件、哪一行、怎么改」的针对性提示。
use std::path::{Path, PathBuf};
use tauri::AppHandle;
use super::patch_entries::{
scan_unresolved_entries_in, unresolved_entries_message, PATCH_ENTRY_UNRESOLVED,
};
use super::profile_dir;
use crate::config;
/// dsh 的补丁层文件名:档案层与 home 层同名,靠目录区分。
const PATCH_FILENAME: &str = "cordis.patch.yml";
/// 一个已被隔离(改名保存)的补丁层。
#[derive(Debug, Clone, serde::Serialize)]
pub struct QuarantinedPatchLayer {
/// 原始补丁文件路径。
pub original: String,
/// 备份路径(`<原名>.broken-<UTC 时间戳>`)。
pub backup: String,
/// 解析错误(serde_yaml 文本,含行列号)。
pub error: String,
}
/// 一个无法移动的损坏补丁层(隔离失败):调用方只记录,不阻断。
#[derive(Debug, Clone, serde::Serialize)]
pub struct PatchQuarantineFailure {
/// 补丁文件路径。
pub path: String,
/// 改名失败原因。
pub error: String,
}
/// 一次隔离动作的结果:成功移走的层 + 未能移走的层。
#[derive(Debug, Default, Clone, serde::Serialize)]
pub struct PatchQuarantineReport {
/// 已隔离(改名保存)的补丁层,前端据此提示备份路径。
pub quarantined: Vec<QuarantinedPatchLayer>,
/// 隔离失败的补丁层,只进日志与提示,不影响其它层。
pub failures: Vec<PatchQuarantineFailure>,
}
impl PatchQuarantineReport {
/// 是否有损坏层仍未移走。
///
/// 非空时调用方**绝不能**重启或切档案:不可解析的文件还在原地,上游契约要求
/// 启动再次大声失败,于是又回到同一个失败循环(issue #525 的形态)。此时应把
/// 失败原因交给用户,由用户手动改名或修复权限后重试。
pub fn has_failures(&self) -> bool {
!self.failures.is_empty()
}
}
/// 补丁层路径:档案层在前、home 层在后(与 dsh 的层叠顺序一致)。
///
/// 与 [`super::internal::repair_loader_state`] 共用同一份清单,避免两处对
/// 「哪些补丁层需要自愈」的认知漂移。
pub(crate) fn patch_layer_paths(profile_dir: &Path, dsh_home: &Path) -> [PathBuf; 2] {
[
profile_dir.join(PATCH_FILENAME),
dsh_home.join(PATCH_FILENAME),
]
}
pub(crate) fn preflight_at(
profile: &Path,
data_home: &Path,
install_anchor: Option<&Path>,
) -> Result<(), String> {
let entries = scan_unresolved_entries_in(profile, data_home, install_anchor);
if entries.is_empty() {
return Ok(());
}
let names = entries
.iter()
.map(|entry| format!("{}:{} {}", entry.layer, entry.line, entry.name))
.collect::<Vec<_>>()
.join(", ");
log::error!("{PATCH_ENTRY_UNRESOLVED}: {names}");
Err(unresolved_entries_message(&entries))
}
pub(super) const PATCH_ENCODING_FAILED: &str = "INTERNAL_PLUGIN_PATCH_ENCODING_FAILED";
fn parse_error(path: &Path) -> Option<String> {
let raw = match std::fs::read_to_string(path) {
Ok(raw) => raw,
Err(error) if error.kind() == std::io::ErrorKind::InvalidData => {
return Some(format!("{PATCH_ENCODING_FAILED}: {error}"));
}
Err(_) => return None,
};
serde_yaml::from_str::<serde_yaml::Value>(&raw)
.err()
.map(|error| error.to_string())
}
/// 备份路径 `<原名>.<suffix>-<stamp>`;已存在时追加 `-2`、`-3`…,绝不覆盖已有备份。
///
/// `suffix` 由调用方给定:语法错误用 `broken`(隔离,改名保存),悬空条目用
/// `bak`(清理,改写前留底),两者在同一个档案目录里必须一眼可分。
pub(super) fn backup_path(path: &Path, suffix: &str, stamp: &str) -> PathBuf {
let name = path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_default();
let mut candidate = path.with_file_name(format!("{name}.{suffix}-{stamp}"));
let mut extra = 2;
while candidate.exists() {
candidate = path.with_file_name(format!("{name}.{suffix}-{stamp}-{extra}"));
extra += 1;
}
candidate
}
/// 隔离给定补丁层里所有解析失败的文件。
///
/// 每层独立处理:某一层改名失败不阻断其它层(与启动期其它自愈同一策略——清理不
/// 彻底只是恢复效果打折,把已能恢复的层留在原地则让应用彻底不可用)。
fn quarantine_layers(paths: &[PathBuf], stamp: &str) -> PatchQuarantineReport {
let mut report = PatchQuarantineReport::default();
for path in paths {
let Some(error) = parse_error(path) else {
continue;
};
let backup = backup_path(path, "broken", stamp);
match std::fs::rename(path, &backup) {
Ok(()) => {
log::warn!(
"PATCH_LAYER_QUARANTINED: {} -> {} ({error})",
path.display(),
backup.display()
);
report.quarantined.push(QuarantinedPatchLayer {
original: path.display().to_string(),
backup: backup.display().to_string(),
error,
});
}
Err(rename_error) => {
let message = rename_error.to_string();
log::warn!(
"PATCH_LAYER_QUARANTINE_FAILED: {}: {message}",
path.display()
);
report.failures.push(PatchQuarantineFailure {
path: path.display().to_string(),
error: message,
});
}
}
}
report
}
/// 生成 UTC 时间戳(`yyyymmddhhmmss`),与档案备份、插件快照的命名一致。
pub(super) fn now_stamp() -> String {
use time::OffsetDateTime;
let now = OffsetDateTime::now_utc();
let date = now.date();
let time = now.time();
format!(
"{:04}{:02}{:02}{:02}{:02}{:02}",
date.year(),
date.month() as u8,
date.day(),
time.hour(),
time.minute(),
time.second()
)
}
/// 隔离指定档案层与 home 层里解析失败的补丁文件。
///
/// 只改名、不删除、不改内容:用户可以修好语法后把备份改回原名。
pub(crate) fn quarantine_patch_layers_in(
profile_dir: &Path,
dsh_home: &Path,
) -> PatchQuarantineReport {
quarantine_layers(&patch_layer_paths(profile_dir, dsh_home), &now_stamp())
}
/// 隔离「当前档案层 + home 层」里解析失败的补丁文件。
///
/// 由错误页的「隔离损坏的补丁文件并重启」入口调用:用户想留在自己的档案里恢复。
pub(crate) fn quarantine_active_patch_layers(app_handle: &AppHandle) -> PatchQuarantineReport {
quarantine_patch_layers_in(
&profile_dir(app_handle),
&config::get_dsh_data_path(app_handle),
)
}
/// 把隔离失败的层拼成给用户的错误串(含路径与原因)。
///
/// 前缀 `PATCH_LAYER_QUARANTINE_FAILED` 与日志一致,便于从日志面板回查。
pub(crate) fn quarantine_failure_message(report: &PatchQuarantineReport) -> String {
let detail = report
.failures
.iter()
.map(|failure| format!("{}: {}", failure.path, failure.error))
.collect::<Vec<_>>()
.join("; ");
format!("PATCH_LAYER_QUARANTINE_FAILED: {detail}")
}
#[cfg(test)]
mod tests {
use super::*;
/// 构造独立的临时目录,供补丁层用例使用。
fn tmp_dir(name: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!(
"dsh-patch-guard-{name}-{}-{}",
std::process::id(),
now_stamp()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
/// issue #525 的真实形态:`!!js` 表达式带 `: ` 却没加引号。
const BROKEN_UNQUOTED_JS: &str = r#"- id: session-telemetry-otel
config:
YUNXIAO_ACCESS_TOKEN: !!js process.env.TOKEN ? process.env.TOKEN : (function () { return '' })()
"#;
const VALID_LAYER: &str = "- id: dsh-base\n disabled: false\n";
#[test]
fn preflight_at_rereads_both_layers_and_uses_the_real_install_anchor_resolution() {
let temp = tempfile::tempdir().unwrap();
let home = temp.path().join("home");
let profile = home.join("profiles/probe");
std::fs::create_dir_all(&profile).unwrap();
let manifest = profile.join("package.json");
std::fs::write(
&manifest,
r#"{"dependencies":{"dsh-preflight-probe":"1.0.0"}}"#,
)
.unwrap();
let layer = "- insert:\n - id: probe\n name: dsh-preflight-probe\n";
let paths = patch_layer_paths(&profile, &home);
for path in &paths {
std::fs::write(path, layer).unwrap();
}
let error = preflight_at(&profile, &home, None).unwrap_err();
let payload: serde_json::Value = serde_json::from_str(
error
.strip_prefix("PATCH_LAYER_ENTRY_UNRESOLVED: ")
.unwrap(),
)
.unwrap();
let entries = payload["entries"].as_array().unwrap();
assert_eq!(entries.len(), 2);
for (entry, path) in entries.iter().zip(&paths) {
assert_eq!(entry["layer"], path.display().to_string());
assert_eq!(entry["line"], 3);
assert_eq!(entry["name"], "dsh-preflight-probe");
assert_eq!(entry["declared"], true);
assert_eq!(std::fs::read_to_string(path).unwrap(), layer);
}
let anchor = temp.path().join("core/lib/bin.js");
let installed = temp.path().join("core/node_modules/dsh-preflight-probe");
std::fs::create_dir_all(&installed).unwrap();
let package = installed.join("package.json");
std::fs::write(&package, "{}\n").unwrap();
assert_eq!(preflight_at(&profile, &home, Some(&anchor)), Ok(()));
std::fs::remove_file(package).unwrap();
assert!(preflight_at(&profile, &home, Some(&anchor))
.unwrap_err()
.starts_with("PATCH_LAYER_ENTRY_UNRESOLVED: "));
}
#[test]
fn parse_error_reports_unquoted_js_expression() {
let dir = tmp_dir("parse-error");
let path = dir.join(PATCH_FILENAME);
std::fs::write(&path, BROKEN_UNQUOTED_JS).unwrap();
// 这一形态必须被判为语法错误,否则 #525 的补丁层不会被隔离。
assert!(parse_error(&path).is_some());
std::fs::write(&path, VALID_LAYER).unwrap();
assert!(parse_error(&path).is_none());
// 不存在的文件不是语法错误(由上游与可写性预检负责)。
assert!(parse_error(&dir.join("missing.yml")).is_none());
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn quarantine_preserves_non_utf8_bytes_in_both_layers() {
for bytes in [
b"\xff\xfe-\0 \0i\0d\0:\0 \0x\0\n\0".as_slice(),
b"- id: plugin\n name: \xc4\xe3\xba\xc3\n".as_slice(),
b"# truncated \xe4\xb8".as_slice(),
] {
let temp = tempfile::tempdir().unwrap();
let home = temp.path();
let profile = home.join("profiles/tauri");
std::fs::create_dir_all(&profile).unwrap();
let paths = patch_layer_paths(&profile, home);
for path in &paths {
std::fs::write(path, bytes).unwrap();
let error = parse_error(path).expect("encoding damage must be quarantinable");
assert!(error.contains("UTF-8"), "{error}");
assert_eq!(std::fs::read(path).unwrap(), bytes);
}
let report = quarantine_patch_layers_in(&profile, home);
assert!(!report.has_failures(), "{report:?}");
assert_eq!(report.quarantined.len(), 2);
for (record, path) in report.quarantined.iter().zip(&paths) {
assert_eq!(record.original, path.display().to_string());
assert!(!path.exists());
assert_eq!(std::fs::read(&record.backup).unwrap(), bytes);
}
let repeated = quarantine_patch_layers_in(&profile, home);
assert!(repeated.quarantined.is_empty());
assert!(!repeated.has_failures());
}
}
#[test]
fn quarantine_does_not_mistake_io_errors_for_encoding_damage() {
let temp = tempfile::tempdir().unwrap();
let path = temp.path().join(PATCH_FILENAME);
std::fs::create_dir(&path).unwrap();
assert!(parse_error(&path).is_none());
let report = quarantine_layers(std::slice::from_ref(&path), "20261017000000");
assert!(report.quarantined.is_empty());
assert!(report.failures.is_empty());
assert!(path.is_dir());
}
#[test]
fn quarantine_moves_only_unparsable_layers() {
let profile = tmp_dir("quarantine-profile");
let home = tmp_dir("quarantine-home");
let profile_patch = profile.join(PATCH_FILENAME);
let home_patch = home.join(PATCH_FILENAME);
std::fs::write(&profile_patch, VALID_LAYER).unwrap();
std::fs::write(&home_patch, BROKEN_UNQUOTED_JS).unwrap();
let report = quarantine_patch_layers_in(&profile, &home);
assert!(report.failures.is_empty(), "{:?}", report.failures);
assert_eq!(report.quarantined.len(), 1);
let record = &report.quarantined[0];
assert_eq!(record.original, home_patch.display().to_string());
// 原文件被移走、备份保留原始内容(绝不删除)。
assert!(!home_patch.exists());
assert_eq!(
std::fs::read_to_string(&record.backup).unwrap(),
BROKEN_UNQUOTED_JS
);
// 合法的档案层原样保留,且不产生备份。
assert_eq!(
std::fs::read_to_string(&profile_patch).unwrap(),
VALID_LAYER
);
assert_eq!(std::fs::read_dir(&profile).unwrap().count(), 1);
let _ = std::fs::remove_dir_all(&profile);
let _ = std::fs::remove_dir_all(&home);
}
#[test]
fn quarantine_is_idempotent() {
let profile = tmp_dir("idempotent-profile");
let home = tmp_dir("idempotent-home");
std::fs::write(home.join(PATCH_FILENAME), BROKEN_UNQUOTED_JS).unwrap();
assert_eq!(
quarantine_patch_layers_in(&profile, &home)
.quarantined
.len(),
1
);
// 第二次调用:文件已不在,不再产生任何动作(可反复点「安全模式」)。
let second = quarantine_patch_layers_in(&profile, &home);
assert!(second.quarantined.is_empty());
assert!(second.failures.is_empty());
let _ = std::fs::remove_dir_all(&profile);
let _ = std::fs::remove_dir_all(&home);
}
#[test]
fn backup_path_never_overwrites_existing_backup() {
let dir = tmp_dir("backup-collision");
let patch = dir.join(PATCH_FILENAME);
std::fs::write(&patch, BROKEN_UNQUOTED_JS).unwrap();
let first = dir.join(format!("{PATCH_FILENAME}.broken-20260914123456"));
std::fs::write(&first, "keep me\n").unwrap();
let report = quarantine_layers(std::slice::from_ref(&patch), "20260914123456");
assert_eq!(report.quarantined.len(), 1);
let record = &report.quarantined[0];
assert!(record.backup.ends_with("-2"), "{}", record.backup);
// 既有备份内容不被覆盖。
assert_eq!(std::fs::read_to_string(&first).unwrap(), "keep me\n");
assert_eq!(
std::fs::read_to_string(&record.backup).unwrap(),
BROKEN_UNQUOTED_JS
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn quarantine_ignores_valid_and_missing_layers() {
let profile = tmp_dir("valid-profile");
let home = tmp_dir("valid-home");
std::fs::write(profile.join(PATCH_FILENAME), VALID_LAYER).unwrap();
std::fs::write(home.join(PATCH_FILENAME), "[]\n").unwrap();
let report = quarantine_patch_layers_in(&profile, &home);
assert!(report.quarantined.is_empty());
assert!(report.failures.is_empty());
assert_eq!(
std::fs::read_to_string(profile.join(PATCH_FILENAME)).unwrap(),
VALID_LAYER
);
let _ = std::fs::remove_dir_all(&profile);
let _ = std::fs::remove_dir_all(&home);
}
#[test]
fn patch_layer_paths_are_profile_then_home() {
let paths = patch_layer_paths(Path::new("/profiles/safe"), Path::new("/dsh-home"));
assert_eq!(paths[0], Path::new("/profiles/safe").join(PATCH_FILENAME));
assert_eq!(paths[1], Path::new("/dsh-home").join(PATCH_FILENAME));
}
/// 隔离失败时报告必须标记出来,让调用方拒绝重启/切档案(否则回到同一个失败循环)。
///
/// 无法稳定制造改名失败(`backup_path` 会避让已存在的备份,权限/占用又依赖环境),
/// 这里直接构造失败报告,锁定「报告 → has_failures / 错误串」的契约本身。
#[test]
fn report_flags_failures_and_renders_message() {
let broken = PathBuf::from("/profiles/safe/cordis.patch.yml");
let report = PatchQuarantineReport {
quarantined: Vec::new(),
failures: vec![PatchQuarantineFailure {
path: broken.display().to_string(),
error: "Access is denied. (os error 5)".to_string(),
}],
};
assert!(report.has_failures());
let message = quarantine_failure_message(&report);
assert!(
message.starts_with("PATCH_LAYER_QUARANTINE_FAILED: "),
"{message}"
);
assert!(message.contains(&broken.display().to_string()), "{message}");
assert!(message.contains("os error 5"), "{message}");
}
/// 全部隔离成功时 `has_failures` 必须为假,成功路径才能继续重启。
#[test]
fn successful_quarantine_has_no_failures() {
let profile = tmp_dir("success-profile");
let home = tmp_dir("success-home");
std::fs::write(home.join(PATCH_FILENAME), BROKEN_UNQUOTED_JS).unwrap();
let report = quarantine_patch_layers_in(&profile, &home);
assert!(!report.has_failures());
assert_eq!(report.quarantined.len(), 1);
let _ = std::fs::remove_dir_all(&profile);
let _ = std::fs::remove_dir_all(&home);
}
}