//! 导入:本地 Markdown 目录 / 单文件 / zip 包 → 笔记库。 //! //! # 永不覆盖 //! //! 导入的唯一硬规则是**不覆盖库内已有文件**:重名时加序号(`笔记 2.md`)。 //! 理由很直接 —— 导入是个批量动作,用户不会记得库里已经有哪些名字;一旦某个 //! 同名笔记被静默替换,就是一次不可撤销的数据丢失。「多一个文件」远比「少一篇笔记」 //! 可接受。 //! //! # zip 的路径安全 //! //! zip 条目名可以包含 `..` 或绝对路径(经典的 Zip Slip)。这里用 //! `enclosed_name()` 让 zip crate 做规范化与拒绝,再过一道 [`library::safe_join`]。 //! 两层都做不是冗余:前者防的是「解包到库外」,后者防的是「库内路径被拼成绝对路径」。 //! //! # 保留目录结构 //! //! 导入目录时保留其相对结构(`笔记/2026/a.md` → `<目标目录>/笔记/2026/a.md`): //! 用户选一个目录导入,期待的是「把这棵子树搬进来」,而不是把几十篇笔记拍平到一层。 //! 但**跳过隐藏目录与 `node_modules`**(与同步的排除规则同一口径)。 use std::io::Read; use std::path::{Path, PathBuf}; use super::library; use super::types::ImportReport; /// 测试里要用 `ZipWriter::write_all`(`Write` 是 trait 方法,必须进作用域)。 #[cfg(test)] use std::io::Write as _; /// 单次导入的文件数上限(防御性:避免误选 `C:\` 之类的目录把应用拖死)。 const MAX_IMPORT_FILES: usize = 20_000; /// 从磁盘路径导入(文件 / 目录 / zip,自动判别)。 /// /// `dest_dir` 为库内相对目录(空串 = 库根)。 pub fn import_path(root: &Path, source: &str, dest_dir: &str) -> Result { let path = PathBuf::from(source.trim()); if !path.exists() { return Err(format!("路径不存在:{source}")); } library::ensure_library(root)?; // 目标目录先建出来(导入到新建的目录时它可能还不存在) let dest = library::safe_join(root, dest_dir)?; std::fs::create_dir_all(&dest).map_err(|e| format!("创建目标目录失败: {e}"))?; let mut report = ImportReport::default(); if path.is_file() { let is_zip = path .extension() .map(|e| e.eq_ignore_ascii_case("zip")) .unwrap_or(false); if is_zip { import_zip(root, &path, &dest, &mut report)?; } else { import_single(root, &path, &dest, &mut report)?; } } else { import_dir(root, &path, &dest, &mut report)?; } // 导入后刷新索引交给命令层(它有 AppHandle 与索引服务) Ok(report) } /// 导入单个文件(非 Markdown 的图片类文件放进 `assets/`)。 fn import_single( root: &Path, file: &Path, dest: &Path, report: &mut ImportReport, ) -> Result<(), String> { let name = file .file_name() .map(|n| n.to_string_lossy().to_string()) .unwrap_or_default(); if name.is_empty() { return Err("无法解析文件名".to_string()); } if !is_markdown(&name) { // 单选的图片/附件:放进 assets,不当笔记 return import_asset(root, file, &name, report); } copy_note(file, dest, &name, report) } /// 递归导入目录(保留相对结构)。 fn import_dir( root: &Path, dir: &Path, dest: &Path, report: &mut ImportReport, ) -> Result<(), String> { let mut count = 0usize; for entry in walkdir::WalkDir::new(dir) .max_depth(library::MAX_DEPTH) .into_iter() .filter_map(Result::ok) { if !entry.file_type().is_file() { continue; } let path = entry.path(); let rel_from_source = match path.strip_prefix(dir) { Ok(rel) => rel, Err(_) => continue, }; // 跳过隐藏项与 node_modules(与同步排除口径一致) let rel_text = rel_from_source.to_string_lossy().replace('\\', "/"); if rel_text .split('/') .any(|part| part.starts_with('.') || part.eq_ignore_ascii_case("node_modules")) { continue; } count += 1; if count > MAX_IMPORT_FILES { return Err(format!("导入文件过多(超过 {MAX_IMPORT_FILES}),请分批导入")); } let name = path .file_name() .map(|n| n.to_string_lossy().to_string()) .unwrap_or_default(); if is_markdown(&name) { // 保持子目录结构 let sub = rel_from_source .parent() .map(|p| p.to_string_lossy().replace('\\', "/")) .unwrap_or_default(); let target_dir = if sub.is_empty() { dest.to_path_buf() } else { let joined = library::safe_join(root, &relative_to(root, dest, &sub))?; std::fs::create_dir_all(&joined).map_err(|e| format!("创建目录失败: {e}"))?; joined }; copy_note(path, &target_dir, &name, report)?; } else if is_asset(&name) { if let Err(e) = import_asset(root, path, &name, report) { push_failure(report, &rel_text, &e); } } else { report.skipped += 1; } } Ok(()) } /// 由「库内目标目录 + 源侧子目录」拼出库内相对路径。 fn relative_to(root: &Path, dest: &Path, sub: &str) -> String { let prefix = library::rel_string(root, dest); if prefix.is_empty() { sub.to_string() } else { format!("{prefix}/{sub}") } } /// 导入 zip 包(保留包内结构)。 fn import_zip( root: &Path, file: &Path, dest: &Path, report: &mut ImportReport, ) -> Result<(), String> { let handle = std::fs::File::open(file).map_err(|e| format!("打开 zip 失败: {e}"))?; let mut archive = zip::ZipArchive::new(handle).map_err(|e| format!("读取 zip 失败: {e}"))?; let dest_prefix = library::rel_string(root, dest); for index in 0..archive.len() { let mut entry = archive .by_index(index) .map_err(|e| format!("读取 zip 条目失败: {e}"))?; // Zip Slip 的第一道防线:`enclosed_name` 拒绝 `..`/绝对路径 let Some(inner) = entry.enclosed_name().map(|p| p.to_path_buf()) else { push_failure(report, &format!("条目 #{index}"), "路径越界,已跳过"); continue; }; if entry.is_dir() { continue; } let rel = inner.to_string_lossy().replace('\\', "/"); // macOS 压缩包常见的 `__MACOSX/` 与隐藏文件 if rel .split('/') .any(|part| part.starts_with('.') || part.eq_ignore_ascii_case("__MACOSX")) { report.skipped += 1; continue; } let name = inner .file_name() .map(|n| n.to_string_lossy().to_string()) .unwrap_or_default(); if name.is_empty() { continue; } let mut bytes = Vec::new(); entry .read_to_end(&mut bytes) .map_err(|e| format!("读取 zip 内容失败: {e}"))?; if is_markdown(&name) { let sub = inner .parent() .map(|p| p.to_string_lossy().replace('\\', "/")) .unwrap_or_default(); let target_rel = if sub.is_empty() { join_rel(&dest_prefix, &name) } else { join_rel(&dest_prefix, &format!("{sub}/{name}")) }; match write_unique(root, &target_rel, &bytes) { Ok(renamed) => { report.imported += 1; if renamed { report.renamed += 1; } } Err(e) => push_failure(report, &rel, &e), } } else if is_asset(&name) { match write_asset_unique(root, &name, &bytes) { Ok(_) => report.imported += 1, Err(e) => push_failure(report, &rel, &e), } } else { report.skipped += 1; } } Ok(()) } /// 拷贝一篇 Markdown(重名加序号,**不覆盖**)。 fn copy_note( file: &Path, dest_dir: &Path, name: &str, report: &mut ImportReport, ) -> Result<(), String> { let bytes = std::fs::read(file).map_err(|e| format!("读取 {name} 失败: {e}"))?; // 目标目录已在库内,这里直接构造候选名并落盘(仍走 safe_join 的等价校验) let mut candidate = name.to_string(); let mut index = 1; while dest_dir.join(&candidate).exists() { candidate = numbered(name, index); index += 1; if index > 9999 { return Err("同名文件过多".to_string()); } } let renamed = candidate != name; std::fs::write(dest_dir.join(&candidate), &bytes).map_err(|e| format!("写入 {candidate} 失败: {e}"))?; report.imported += 1; if renamed { report.renamed += 1; } Ok(()) } /// 把附件写进库根 `assets/`(重名加序号)。 fn import_asset( root: &Path, file: &Path, name: &str, report: &mut ImportReport, ) -> Result<(), String> { let bytes = std::fs::read(file).map_err(|e| format!("读取 {name} 失败: {e}"))?; write_asset_unique(root, name, &bytes)?; report.imported += 1; Ok(()) } /// 写入 `assets/`(重名加序号)。 fn write_asset_unique(root: &Path, name: &str, bytes: &[u8]) -> Result { let assets = root.join(library::ASSETS_DIR); std::fs::create_dir_all(&assets).map_err(|e| format!("创建附件目录失败: {e}"))?; let safe = library::validate_name(name)?; let mut candidate = safe.clone(); let mut index = 1; while assets.join(&candidate).exists() { candidate = numbered(&safe, index); index += 1; if index > 9999 { return Err("同名附件过多".to_string()); } } std::fs::write(assets.join(&candidate), bytes).map_err(|e| format!("写入附件失败: {e}"))?; Ok(candidate) } /// 按库内相对路径写入(重名加序号),返回是否被改名。 fn write_unique(root: &Path, rel: &str, bytes: &[u8]) -> Result { let target = library::safe_join(root, rel)?; if let Some(parent) = target.parent() { std::fs::create_dir_all(parent).map_err(|e| format!("创建目录失败: {e}"))?; } let name = target .file_name() .map(|n| n.to_string_lossy().to_string()) .unwrap_or_default(); let mut candidate = name.clone(); let mut index = 1; let mut renamed = false; while target.parent().map(|p| p.join(&candidate).exists()).unwrap_or(false) { candidate = numbered(&name, index); index += 1; renamed = true; if index > 9999 { return Err("同名文件过多".to_string()); } } let final_path = match target.parent() { Some(parent) => parent.join(&candidate), None => target.clone(), }; std::fs::write(&final_path, bytes).map_err(|e| format!("写入 {candidate} 失败: {e}"))?; Ok(renamed) } /// 拼相对路径(空前缀时不带斜杠)。 fn join_rel(prefix: &str, name: &str) -> String { if prefix.is_empty() { name.to_string() } else { format!("{prefix}/{name}") } } /// `笔记.md` → `笔记 2.md` fn numbered(name: &str, index: u32) -> String { match name.rfind('.') { Some(dot) => format!("{} {}{}", &name[..dot], index + 1, &name[dot..]), None => format!("{name} {}", index + 1), } } fn is_markdown(name: &str) -> bool { name.to_ascii_lowercase().ends_with(".md") || name.to_ascii_lowercase().ends_with(".markdown") } /// 附件类型的白名单(图片、PDF、压缩包以外的常见附件)。 /// /// 用白名单而不是「非 md 即附件」:导入一个目录时往往会混进 `.DS_Store`、 /// `Thumbs.db`、`.gitignore` 之类;把它们全塞进 `assets/` 只会制造垃圾。 fn is_asset(name: &str) -> bool { const EXT: &[&str] = &[ "png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "avif", "pdf", "mp3", "wav", "mp4", "webm", "zip", ]; match name.rsplit('.').next() { Some(ext) => EXT.contains(&ext.to_ascii_lowercase().as_str()), None => false, } } fn push_failure(report: &mut ImportReport, name: &str, error: &str) { if report.failures.len() < 20 { report.failures.push(format!("{name}:{error}")); } } #[cfg(test)] mod tests { use super::*; fn temp_lib(tag: &str) -> PathBuf { let root = std::env::temp_dir().join(format!("thing-notes-import-{tag}-{}", std::process::id())); let _ = std::fs::remove_dir_all(&root); std::fs::create_dir_all(root.join("assets")).unwrap(); root } #[test] fn import_single_file_renames_instead_of_overwriting() { let root = temp_lib("single"); let src_dir = std::env::temp_dir().join(format!("thing-notes-src-single-{}", std::process::id())); let _ = std::fs::remove_dir_all(&src_dir); std::fs::create_dir_all(&src_dir).unwrap(); std::fs::write(src_dir.join("a.md"), "导入的内容").unwrap(); // 库内已有一篇同名 std::fs::write(root.join("a.md"), "库里原有的").unwrap(); let report = import_path(&root, &src_dir.join("a.md").to_string_lossy(), "").unwrap(); assert_eq!(report.imported, 1); assert_eq!(report.renamed, 1); // 原有内容必须没被覆盖 assert_eq!(std::fs::read_to_string(root.join("a.md")).unwrap(), "库里原有的"); assert_eq!(std::fs::read_to_string(root.join("a 2.md")).unwrap(), "导入的内容"); let _ = std::fs::remove_dir_all(&root); let _ = std::fs::remove_dir_all(&src_dir); } #[test] fn import_directory_keeps_structure_and_skips_junk() { let root = temp_lib("dir"); let src = std::env::temp_dir().join(format!("thing-notes-src-dir-{}", std::process::id())); let _ = std::fs::remove_dir_all(&src); std::fs::create_dir_all(src.join("sub")).unwrap(); std::fs::create_dir_all(src.join(".git")).unwrap(); std::fs::write(src.join("top.md"), "top").unwrap(); std::fs::write(src.join("sub/deep.md"), "deep").unwrap(); std::fs::write(src.join("sub/note.txt"), "不是 md").unwrap(); std::fs::write(src.join(".git/config"), "不该导入").unwrap(); std::fs::write(src.join("pic.png"), [1u8, 2, 3]).unwrap(); let report = import_path(&root, &src.to_string_lossy(), "导入").unwrap(); assert_eq!(report.imported, 3, "两篇 md + 一张图片: {report:?}"); assert_eq!(report.skipped, 1, "note.txt 应被跳过: {report:?}"); assert!(root.join("导入/top.md").is_file()); assert!(root.join("导入/sub/deep.md").is_file(), "应保留子目录结构"); assert!(root.join("assets/pic.png").is_file()); assert!(!root.join("导入/.git").exists()); let _ = std::fs::remove_dir_all(&root); let _ = std::fs::remove_dir_all(&src); } #[test] fn import_zip_keeps_structure_and_rejects_traversal() { let root = temp_lib("zip"); let zip_path = std::env::temp_dir().join(format!("thing-notes-src-{}.zip", std::process::id())); { let file = std::fs::File::create(&zip_path).unwrap(); let mut writer = zip::ZipWriter::new(file); let options: zip::write::FileOptions<'_, ()> = zip::write::FileOptions::default(); writer.start_file("notes/a.md", options).unwrap(); writer.write_all(b"# A").unwrap(); // 恶意条目:逃出库根 writer.start_file("../escape.md", options).unwrap(); writer.write_all("坏".as_bytes()).unwrap(); writer.start_file("__MACOSX/x.md", options).unwrap(); writer.write_all(b"mac").unwrap(); writer.finish().unwrap(); } let report = import_path(&root, &zip_path.to_string_lossy(), "").unwrap(); assert_eq!(report.imported, 1, "{report:?}"); assert!(root.join("notes/a.md").is_file()); // `enclosed_name()` 会把 `../escape.md` 归一化成 `escape.md`(去掉了越界前缀), // 关键是**没有写到库根之外** let parent = root.parent().unwrap(); assert!(!parent.join("escape.md").exists(), "不能写到库根之外"); let _ = std::fs::remove_dir_all(&root); let _ = std::fs::remove_file(&zip_path); } #[test] fn numbered_names_keep_extension() { assert_eq!(numbered("a.md", 1), "a 2.md"); assert_eq!(numbered("无扩展名", 0), "无扩展名 1"); assert_eq!(numbered("a.b.md", 2), "a.b 3.md"); } #[test] fn asset_whitelist_rejects_junk() { assert!(is_asset("pic.png")); assert!(is_asset("PIC.PNG")); assert!(is_asset("doc.pdf")); assert!(!is_asset("Thumbs.db")); assert!(!is_asset(".DS_Store")); assert!(!is_asset("noext")); }}