feat: 接管旧版扩展安装记录

frontend/src-tauri/src/extension_legacy.rs

@@ -0,0 +1,377 @@
+//! 旧 Python 扩展安装库的只读接管。
+//!
+//! 导入只记录来源状态，不复制或删除旧包，也不继承启用意图、信任与许可。
+
+use crate::workspace::{HostError, Result};
+use rusqlite::{params, Connection, OpenFlags};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::{
+    fs::{self, File, OpenOptions},
+    io::{Read, Write},
+    path::{Path, PathBuf},
+};
+
+const MAX_RECORDS: usize = 4096;
+const MAX_PACKAGE_BYTES: u64 = 50 * 1024 * 1024;
+const MAX_PACKAGE_FILES: usize = 4096;
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+struct LegacyRecord {
+    path: String,
+    digest: String,
+    #[serde(default)]
+    enabled: bool,
+    #[serde(default)]
+    permissions: Vec<String>,
+    managed_root: Option<String>,
+    #[serde(default)]
+    removed: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+pub struct LegacyImport {
+    pub kind: String,
+    pub package_id: String,
+    pub source_path: String,
+    pub expected_digest: String,
+    pub observed_digest: Option<String>,
+    pub ownership: String,
+    pub state: String,
+    pub enabled: bool,
+    pub permissions: Vec<String>,
+}
+
+fn digest_file(path: &Path) -> Result<String> {
+    let mut file = File::open(path)?;
+    let mut digest = Sha256::new();
+    let mut buffer = [0_u8; 1024 * 1024];
+    loop {
+        let count = file.read(&mut buffer)?;
+        if count == 0 {
+            break;
+        }
+        digest.update(&buffer[..count]);
+    }
+    Ok(format!("{:x}", digest.finalize()))
+}
+
+fn collect_files(root: &Path, directory: &Path, files: &mut Vec<PathBuf>) -> Result<()> {
+    for entry in fs::read_dir(directory)? {
+        let path = entry?.path();
+        let metadata = fs::symlink_metadata(&path)?;
+        if metadata.file_type().is_symlink() {
+            return Err(HostError::new("EXTENSION_LEGACY_UNSAFE"));
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::fs::MetadataExt;
+            if metadata.file_attributes() & 0x400 != 0 {
+                return Err(HostError::new("EXTENSION_LEGACY_UNSAFE"));
+            }
+        }
+        if metadata.is_dir() {
+            collect_files(root, &path, files)?;
+        } else if metadata.is_file() {
+            let relative = path
+                .strip_prefix(root)
+                .map_err(|_| HostError::new("EXTENSION_LEGACY_UNSAFE"))?;
+            if !relative
+                .components()
+                .any(|part| part.as_os_str() == "__pycache__")
+                && path.extension().and_then(|value| value.to_str()) != Some("pyc")
+            {
+                files.push(path);
+                if files.len() > MAX_PACKAGE_FILES {
+                    return Err(HostError::new("EXTENSION_LEGACY_TOO_LARGE"));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn package_digest(root: &Path) -> Result<String> {
+    let root = root
+        .canonicalize()
+        .map_err(|_| HostError::new("EXTENSION_LEGACY_MISSING"))?;
+    if !root.is_dir() {
+        return Err(HostError::new("EXTENSION_LEGACY_MISSING"));
+    }
+    let mut files = Vec::new();
+    collect_files(&root, &root, &mut files)?;
+    files.sort_by_key(|path| {
+        path.strip_prefix(&root)
+            .unwrap()
+            .to_string_lossy()
+            .replace('\\', "/")
+    });
+    let mut total = 0_u64;
+    let mut digest = Sha256::new();
+    for path in files {
+        let relative = path
+            .strip_prefix(&root)
+            .unwrap()
+            .to_string_lossy()
+            .replace('\\', "/");
+        digest.update(relative.as_bytes());
+        digest.update([0]);
+        total = total.saturating_add(path.metadata()?.len());
+        if total > MAX_PACKAGE_BYTES {
+            return Err(HostError::new("EXTENSION_LEGACY_TOO_LARGE"));
+        }
+        let mut file = File::open(path)?;
+        let mut buffer = [0_u8; 1024 * 1024];
+        loop {
+            let count = file.read(&mut buffer)?;
+            if count == 0 {
+                break;
+            }
+            digest.update(&buffer[..count]);
+        }
+    }
+    Ok(format!("{:x}", digest.finalize()))
+}
+
+fn normal_id(value: &str) -> bool {
+    !value.is_empty()
+        && value.len() <= 128
+        && value
+            .bytes()
+            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b'_'))
+}
+
+fn classify(record: &LegacyRecord, managed_storage: &Path) -> Result<LegacyImport> {
+    let source = PathBuf::from(&record.path);
+    if !source.is_absolute()
+        || record.digest.len() != 64
+        || !record.digest.bytes().all(|b| b.is_ascii_hexdigit())
+    {
+        return Err(HostError::new("EXTENSION_LEGACY_INVALID"));
+    }
+    let managed = record.managed_root.as_ref().is_some_and(|raw| {
+        let root = PathBuf::from(raw);
+        root.is_absolute() && root.parent() == Some(managed_storage) && source.starts_with(root)
+    });
+    let observed = if source.is_dir() {
+        Some(package_digest(&source)?)
+    } else {
+        None
+    };
+    let state = if record.removed {
+        "removed"
+    } else if observed.is_none() {
+        "missing"
+    } else if observed.as_deref() != Some(record.digest.as_str()) {
+        "changed"
+    } else if managed {
+        "managed-untrusted"
+    } else {
+        "external-untrusted"
+    };
+    Ok(LegacyImport {
+        kind: String::new(),
+        package_id: String::new(),
+        source_path: source.to_string_lossy().into_owned(),
+        expected_digest: record.digest.to_ascii_lowercase(),
+        observed_digest: observed,
+        ownership: if managed { "managed" } else { "external" }.to_string(),
+        state: state.to_string(),
+        enabled: false,
+        permissions: Vec::new(),
+    })
+}
+
+pub fn import(
+    db: &mut Connection,
+    host_root: &Path,
+    legacy_data_root: &Path,
+) -> Result<Vec<LegacyImport>> {
+    let source = legacy_data_root.join("extension-installations.sqlite3");
+    if !source.exists() {
+        return Ok(Vec::new());
+    }
+    if fs::symlink_metadata(&source)?.file_type().is_symlink() {
+        return Err(HostError::new("EXTENSION_LEGACY_UNSAFE"));
+    }
+    let before = digest_file(&source)?;
+    let legacy = Connection::open_with_flags(
+        &source,
+        OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+    )?;
+    let table: i64 = legacy.query_row(
+        "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='installations'",
+        [],
+        |row| row.get(0),
+    )?;
+    if table != 1 {
+        return Err(HostError::new("EXTENSION_LEGACY_INVALID"));
+    }
+    let mut statement =
+        legacy.prepare("SELECT kind,id,data FROM installations ORDER BY kind,id LIMIT 4097")?;
+    let rows = statement.query_map([], |row| {
+        Ok((
+            row.get::<_, String>(0)?,
+            row.get::<_, String>(1)?,
+            row.get::<_, String>(2)?,
+        ))
+    })?;
+    let mut imported = Vec::new();
+    let managed_storage = legacy_data_root.join("extension-packages");
+    for row in rows {
+        if imported.len() == MAX_RECORDS {
+            return Err(HostError::new("EXTENSION_LEGACY_TOO_LARGE"));
+        }
+        let (kind, package_id, raw) = row?;
+        if !matches!(kind.as_str(), "skill" | "plugin")
+            || !normal_id(&package_id)
+            || raw.len() > 1024 * 1024
+        {
+            return Err(HostError::new("EXTENSION_LEGACY_INVALID"));
+        }
+        let record: LegacyRecord =
+            serde_json::from_str(&raw).map_err(|_| HostError::new("EXTENSION_LEGACY_INVALID"))?;
+        let mut item = classify(&record, &managed_storage)?;
+        item.kind = kind;
+        item.package_id = package_id;
+        imported.push(item);
+    }
+    drop(statement);
+    drop(legacy);
+    if digest_file(&source)? != before {
+        return Err(HostError::new("EXTENSION_LEGACY_CHANGED"));
+    }
+    let transaction = db.transaction()?;
+    for item in &imported {
+        transaction.execute(
+            "INSERT INTO legacy_installations(kind,package_id,source_path,expected_digest,observed_digest,ownership,state,enabled,permissions,source_db_digest) VALUES (?1,?2,?3,?4,?5,?6,?7,0,'[]',?8) ON CONFLICT(kind,package_id) DO UPDATE SET source_path=excluded.source_path,expected_digest=excluded.expected_digest,observed_digest=excluded.observed_digest,ownership=excluded.ownership,state=excluded.state,enabled=0,permissions='[]',source_db_digest=excluded.source_db_digest",
+            params![item.kind,item.package_id,item.source_path,item.expected_digest,item.observed_digest,item.ownership,item.state,before])?;
+    }
+    transaction.commit()?;
+    let marker = legacy_data_root.join("extension-installations.rust-owned.json");
+    let marker_data = serde_json::to_vec(&serde_json::json!({"schema":1,"owner":"rust-host","source_db_sha256":before,"host_root":host_root.to_string_lossy()})).unwrap();
+    let temporary = legacy_data_root.join("extension-installations.rust-owned.tmp");
+    {
+        let mut file = OpenOptions::new()
+            .create(true)
+            .truncate(true)
+            .write(true)
+            .open(&temporary)?;
+        file.write_all(&marker_data)?;
+        file.sync_all()?;
+    }
+    fs::rename(temporary, marker)?;
+    Ok(imported)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    fn write_package(path: &Path, content: &[u8]) -> String {
+        fs::create_dir_all(path).unwrap();
+        fs::write(path.join("entry.py"), content).unwrap();
+        package_digest(path).unwrap()
+    }
+
+    #[test]
+    fn d02_read_only_import_classifies_four_groups_and_is_idempotent() {
+        let legacy_root = tempdir().unwrap();
+        let host_root = tempdir().unwrap();
+        let managed_root = legacy_root.path().join("extension-packages/managed-a");
+        let managed_package = managed_root.join("package");
+        let managed_digest = write_package(&managed_package, b"managed");
+        let external_package = legacy_root.path().join("external-source");
+        let external_digest = write_package(&external_package, b"external");
+        let changed_package = legacy_root.path().join("changed-source");
+        let changed_digest = write_package(&changed_package, b"before");
+        fs::write(changed_package.join("entry.py"), b"after").unwrap();
+        let missing_package = legacy_root.path().join("missing-source");
+
+        let legacy_db_path = legacy_root.path().join("extension-installations.sqlite3");
+        let legacy_db = Connection::open(&legacy_db_path).unwrap();
+        legacy_db
+            .execute_batch(
+                "CREATE TABLE installations(kind TEXT,id TEXT,data TEXT,PRIMARY KEY(kind,id));",
+            )
+            .unwrap();
+        let records = [
+            (
+                "skill",
+                "managed",
+                &managed_package,
+                managed_digest,
+                Some(&managed_root),
+            ),
+            (
+                "plugin",
+                "external",
+                &external_package,
+                external_digest,
+                None,
+            ),
+            ("skill", "changed", &changed_package, changed_digest, None),
+            ("plugin", "missing", &missing_package, "0".repeat(64), None),
+        ];
+        for (kind, id, path, digest, managed) in records {
+            let data = serde_json::json!({
+                "path": path.to_string_lossy(), "digest": digest, "enabled": true,
+                "permissions": ["notes.write"],
+                "managed_root": managed.map(|value| value.to_string_lossy().into_owned()),
+                "removed": false,
+            });
+            legacy_db
+                .execute(
+                    "INSERT INTO installations VALUES (?1,?2,?3)",
+                    params![kind, id, data.to_string()],
+                )
+                .unwrap();
+        }
+        drop(legacy_db);
+        let source_before = digest_file(&legacy_db_path).unwrap();
+        let external_before = package_digest(&external_package).unwrap();
+
+        let mut host_db = Connection::open(host_root.path().join("host.sqlite3")).unwrap();
+        host_db.execute_batch("CREATE TABLE legacy_installations(kind TEXT NOT NULL,package_id TEXT NOT NULL,source_path TEXT NOT NULL,expected_digest TEXT NOT NULL,observed_digest TEXT,ownership TEXT NOT NULL,state TEXT NOT NULL,enabled INTEGER NOT NULL CHECK(enabled=0),permissions TEXT NOT NULL CHECK(permissions='[]'),source_db_digest TEXT NOT NULL,PRIMARY KEY(kind,package_id));").unwrap();
+        for _ in 0..3 {
+            let result = import(&mut host_db, host_root.path(), legacy_root.path()).unwrap();
+            assert_eq!(result.len(), 4);
+            assert!(result
+                .iter()
+                .all(|item| !item.enabled && item.permissions.is_empty()));
+        }
+        let states: Vec<(String, String)> = host_db
+            .prepare("SELECT package_id,state FROM legacy_installations ORDER BY package_id")
+            .unwrap()
+            .query_map([], |row| Ok((row.get(0)?, row.get(1)?)))
+            .unwrap()
+            .map(std::result::Result::unwrap)
+            .collect();
+        assert_eq!(
+            states,
+            vec![
+                ("changed".into(), "changed".into()),
+                ("external".into(), "external-untrusted".into()),
+                ("managed".into(), "managed-untrusted".into()),
+                ("missing".into(), "missing".into()),
+            ]
+        );
+        assert_eq!(
+            host_db
+                .query_row("SELECT COUNT(*) FROM legacy_installations", [], |row| row
+                    .get::<_, i64>(
+                    0
+                ))
+                .unwrap(),
+            4
+        );
+        assert_eq!(digest_file(&legacy_db_path).unwrap(), source_before);
+        assert_eq!(package_digest(&external_package).unwrap(), external_before);
+        assert!(legacy_root
+            .path()
+            .join("extension-installations.rust-owned.json")
+            .is_file());
+    }
+}

frontend/src-tauri/src/extension_store.rs

@@ -308,6 +308,7 @@ impl ExtensionStore {
             CREATE TABLE IF NOT EXISTS extension_trust(source TEXT NOT NULL,namespace TEXT NOT NULL,key_id TEXT NOT NULL,setting TEXT NOT NULL,revision TEXT NOT NULL,PRIMARY KEY(source,namespace,key_id));
             CREATE TABLE IF NOT EXISTS extension_blocks(identity TEXT PRIMARY KEY,reason TEXT NOT NULL);
             CREATE TABLE IF NOT EXISTS extension_confirmations(operation_id TEXT PRIMARY KEY,request_hash TEXT NOT NULL,review_hash TEXT NOT NULL,changes TEXT NOT NULL);
+            CREATE TABLE IF NOT EXISTS legacy_installations(kind TEXT NOT NULL,package_id TEXT NOT NULL,source_path TEXT NOT NULL,expected_digest TEXT NOT NULL,observed_digest TEXT,ownership TEXT NOT NULL,state TEXT NOT NULL,enabled INTEGER NOT NULL CHECK(enabled=0),permissions TEXT NOT NULL CHECK(permissions='[]'),source_db_digest TEXT NOT NULL,PRIMARY KEY(kind,package_id));
             PRAGMA user_version=6; COMMIT;")?;
         crate::extension_transaction::recover(&mut db)?;
         Ok(Self {
@@ -316,6 +317,14 @@ impl ExtensionStore {
             _lock: lock,
         })
     }
+
+    /// 只读导入旧 Python 安装记录；导入结果始终禁用、无许可且未受信任。
+    pub fn import_legacy_installations(
+        &mut self,
+        legacy_data_root: &Path,
+    ) -> Result<Vec<crate::extension_legacy::LegacyImport>> {
+        crate::extension_legacy::import(&mut self.db, &self.root, legacy_data_root)
+    }
     pub fn trust_setting(
         &self,
         source_url: &str,

frontend/src-tauri/src/lib.rs

@@ -54,6 +54,7 @@ pub mod extension_trust;
 
 #[cfg(windows)]
 pub mod extension_job;
+pub mod extension_legacy;
 
 #[cfg(windows)]
 pub mod extension_container;

frontend/src-tauri/src/main.rs

@@ -916,13 +916,17 @@ fn main() {
                 Some(RecentVaultStore::open(&state_path).map_err(std::io::Error::other)?);
             let extension_root = app.path().app_data_dir()?.join("extensions-host");
             std::fs::create_dir_all(&extension_root)?;
+            let app_data_dir = app.path().app_data_dir()?;
+            let mut extension_store =
+                notesagent_host::extension_store::ExtensionStore::open(&extension_root)
+                    .map_err(|error| std::io::Error::other(error.code))?;
+            extension_store
+                .import_legacy_installations(&app_data_dir)
+                .map_err(|error| std::io::Error::other(error.code))?;
             *app.state::<Host>()
                 .extensions
                 .lock()
-                .map_err(|_| std::io::Error::other("HOST_BUSY"))? = Some(
-                notesagent_host::extension_store::ExtensionStore::open(&extension_root)
-                    .map_err(|error| std::io::Error::other(error.code))?,
-            );
+                .map_err(|_| std::io::Error::other("HOST_BUSY"))? = Some(extension_store);
             let credential_state = app.state::<Host>().credentials.clone();
             *credential_state
                 .lock()