@logictan/dsh-config-manager 0.1.60

package/lib/core/analyzer.js

@@ -0,0 +1,934 @@
+/**
+ * 三段式核心（对齐设计 §5.1/§13.5）：
+ *   analyzeImport()      → ImportAnalysis（纯计算，零写入）
+ *   createImportPlan()   → ImportPlan（汇总 PlanItem + 冲突决策 + 路径映射；纯计算）
+ *   executeImportPlan()  → ImportResult（快照 → 分阶段 apply → 校验 → 结果/回滚）
+ *
+ * Dry Run 保证：analyzeImport / createImportPlan 除读取 ZIP 字节外不做任何系统修改，
+ * ZIP 以内存方式解析（不进磁盘），杜绝不可信输入在分析阶段落盘。
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { sha256Hex } from '../utils/hashing.js';
+import { parseJsonSafe } from '../utils/json.js';
+import { SECTION_FILE_PREFIXES, SECTION_IDS, SECTION_JSON_PATHS, isFileSection, validateSectionData, } from '../schema/config.js';
+import { CHECKSUMS_FILE, MANIFEST_FILE, parseManifest, validateManifest } from '../schema/manifest.js';
+import { CURRENT_SCHEMA_VERSION, canImport, describeVersion, isSupported, isTooNew, needsMigration, } from '../schema/versions.js';
+import { migrateToCurrent } from '../migrations/index.js';
+import { isAbsolutePath, applyPrefixMappings } from '../utils/paths.js';
+import { parseZip } from '../utils/zip.js';
+import { loadTombstones, isTombstoned } from '../schema/tombstones.js';
+import { DEFAULT_SENSITIVE_RELS, restoreVaultFiles } from '../security/vault.js';
+import { createSnapshot, resolveFileTarget, resolveFileTargetRel } from './backup.js';
+import { rollback } from './rollback.js';
+import { computeCompatibility } from './validator.js';
+import { msgOf } from './messages.js';
+import { ImportNotConfirmedError, ImportUserSkippedError, } from './types.js';
+/** 执行阶段顺序（设计 §5.4：副作用大的 patch/安装最后） */
+const APPLY_ORDER = [
+    'settings', 'ui', 'providers', 'prompts', 'skills', 'agentPresets',
+    'agentInstructions', 'workspaces', 'pluginFiles', 'mcp', 'plugins', 'credentialsStatus',
+    // P1-1 修复：self 分区（插件自身配置 sync/market/ui-prefs）此前不在 APPLY_ORDER，
+    // 导致 plan 含 self 项但执行循环跳过、导入时被静默丢弃。加入执行顺序末尾（低风险配置文件）。
+    'self',
+];
+/** ZIP 内可执行文件扩展名黑名单（§19.6：只警告，本插件不执行任何脚本） */
+const EXECUTABLE_EXTENSIONS = new Set(['.exe', '.bat', '.cmd', '.sh', '.ps1', '.dll', '.so', '.dylib', '.bin', '.jar']);
+/** 已知外部依赖（MCP command 检测用，§15） */
+const KNOWN_DEPENDENCIES = new Set([
+    'npx', 'node', 'npm', 'pnpm', 'yarn', 'bun', 'python', 'python3', 'pip', 'pip3',
+    'uv', 'git', 'docker', 'rg', 'bash', 'zsh', 'code', 'cargo', 'go',
+]);
+export class Analyzer {
+    ctx;
+    adapters;
+    snapshotStore;
+    limits;
+    dependencyChecker;
+    parseZipFn;
+    msg;
+    /** 会话内 bundle 缓存（zipPath → 解析结果），避免重复解压 */
+    bundleCache = new Map();
+    constructor(opts) {
+        this.ctx = opts.ctx;
+        this.adapters = opts.adapters;
+        this.snapshotStore = opts.snapshotStore;
+        this.limits = opts.limits;
+        this.dependencyChecker = opts.dependencyChecker;
+        this.parseZipFn = opts.parseZipOverride ?? parseZip;
+        this.msg = opts.msg ?? msgOf(opts.ctx);
+    }
+    /* ---------------- 第 1-6 步：ZIP 读入 → 安全解析 → manifest → 完整性 → schema ---------------- */
+    async loadBundle(zipPath) {
+        const cached = this.bundleCache.get(zipPath);
+        if (cached)
+            return cached;
+        // 1. 选 ZIP（存在性）
+        let raw;
+        try {
+            raw = await fs.readFile(zipPath);
+        }
+        catch (err) {
+            throw new Error(this.msg('import.readFailed', { zip: zipPath, reason: err instanceof Error ? err.message : String(err) }));
+        }
+        // 2. 校验 ZIP（安全解析：条目名/数量/体积上限）
+        const archive = this.parseZipFn(raw, this.limits);
+        // 3. manifest
+        if (!archive.has(MANIFEST_FILE))
+            throw new Error(this.msg('import.noManifest'));
+        let manifest;
+        try {
+            manifest = parseManifest(archive.readEntryText(MANIFEST_FILE));
+        }
+        catch (err) {
+            throw new Error(this.msg('import.manifestParseFailed', { reason: err instanceof Error ? err.message : String(err) }));
+        }
+        // 4. 完整性（integrity/checksums.json 逐一 SHA-256）
+        const zipWarnings = [];
+        let checksums = { ok: true, mismatches: [], missing: [] };
+        // 4a. H2：校验表**缺失**或**为空**时，全部条目都处于「未登记 ⇒ 未被校验」状态。
+        //     此前整段完整性逻辑（含下面的反向检查）都嵌在 `if (archive.has(CHECKSUMS_FILE))` 内，
+        //     于是「剥掉 checksums.json」或「把它置为 {}」= 一个条目都不校验，却 valid=true / 零告警。
+        //     两种形态对用户是同一件事（没有任何条目被校验），故共用同一条告警，不制造近重复文案。
+        const table = archive.has(CHECKSUMS_FILE)
+            ? parseJsonSafe(archive.readEntryText(CHECKSUMS_FILE))
+            : null;
+        if (table === null || Object.keys(table).length === 0) {
+            zipWarnings.push(this.msg('import.checksumsMissing'));
+        }
+        if (table !== null && Object.keys(table).length > 0) {
+            const entries = new Map();
+            for (const name of archive.names()) {
+                if (name === MANIFEST_FILE || name === CHECKSUMS_FILE)
+                    continue;
+                try {
+                    entries.set(name, archive.readEntry(name));
+                }
+                catch {
+                    entries.delete(name); // 损坏条目在完整性阶段即失败
+                    checksums.ok = false;
+                    checksums.mismatches.push(name);
+                }
+            }
+            const result = await verifyAgainstTable(entries, table);
+            checksums = result;
+            if (!checksums.ok) {
+                throw new Error(this.msg('import.integrityFailed', {
+                    entries: [...checksums.mismatches, ...checksums.missing].map((m) => `"${m}"`).join(', '),
+                }));
+            }
+            // 4b. G-04：反向完整性——ZIP 内**不在**校验表里的条目（未登记 ⇒ 未被校验）。
+            //     verifyAgainstTable 只遍历表里的键，所以 ZIP 里多出的条目此前既不校验也不告知；
+            //     这里把它变成显式 warning（不阻断：未知 ZIP 条目不参与校验是格式 v1 的既定语义）。
+            //     排除 manifest.json / checksums.json 自身与目录条目（以 "/" 结尾）。
+            const tableKeys = new Set(Object.keys(table));
+            const extraEntries = archive.names().filter((name) => name !== MANIFEST_FILE && name !== CHECKSUMS_FILE
+                && !name.endsWith('/') && !tableKeys.has(name));
+            if (extraEntries.length > 0) {
+                zipWarnings.push(this.msg('import.extraEntries', {
+                    entries: extraEntries.map((e) => `"${e}"`).join(', '),
+                }));
+            }
+        }
+        // 5. schema 版本判定（集中）：过新（isTooNew）或过旧（低于 MIN_SUPPORTED）→ 一律硬失败（行为不变）
+        if (isTooNew(manifest.schemaVersion) || !isSupported(manifest.schemaVersion)) {
+            throw new Error(this.msg('import.schemaUnsupported', { version: describeVersion(manifest.schemaVersion) }));
+        }
+        // 5b. G-06：把「可迁移的旧 schema」真正沿迁移链升级——此前 `migrateToCurrent` 在 src/ 内零引用，
+        //     迁移链有定义、有单测、却从未执行。迁移结果 doc 成为后续 manifest，并重新校验其合法性。
+        //     注：当前 MIN_SUPPORTED = CURRENT = 1 ⇒ needsMigration 恒假 ⇒ 此处零迁移（旧 v1 行为不变）；
+        //     一旦 CURRENT > MIN，旧备份会在这里被真实迁移，而不是「判定可迁移却按新格式直接用」。
+        const migrationWarnings = [];
+        if (needsMigration(manifest.schemaVersion)) {
+            const migrated = runSchemaMigration(manifest, manifest.schemaVersion, CURRENT_SCHEMA_VERSION, this.msg);
+            manifest = migrated.manifest;
+            migrationWarnings.push(...migrated.warnings);
+        }
+        // 6. 扫描：可执行文件条目 → 警告（不执行）
+        for (const name of archive.names()) {
+            const ext = name.slice(name.lastIndexOf('.')).toLowerCase();
+            if (EXECUTABLE_EXTENSIONS.has(ext)) {
+                zipWarnings.push(this.msg('import.executableWarning', { name }));
+            }
+        }
+        const bundle = { archive, manifest, checksums, zipWarnings, migrationWarnings };
+        this.bundleCache.set(zipPath, bundle);
+        return bundle;
+    }
+    /* ---------------- 第 7 步：分区内容扫描/提取 ---------------- */
+    extractSections(bundle) {
+        const { archive, manifest } = bundle;
+        const sections = new Map();
+        const unsupportedSections = [];
+        const unsupportedVersions = [];
+        const warnings = [];
+        const knownIds = new Set(SECTION_IDS);
+        for (const [sectionId, enabled] of Object.entries(manifest.sections)) {
+            if (!enabled)
+                continue;
+            // G-01/G-02/G-03：manifest.sections 的键可能来自更新的 DSH（本版本不认识的分区）。
+            // 未知分区单独收集 → 由本函数产出独立告警；**绝不**再落进 missingSections
+            // （此前会被误报成「备份声明了但缺少的分区: X」——而文件其实就在 ZIP 里）。
+            if (!knownIds.has(sectionId)) {
+                unsupportedSections.push(sectionId);
+                continue;
+            }
+            const id = sectionId;
+            if (isFileSection(id)) {
+                const prefix = SECTION_FILE_PREFIXES[id];
+                const files = [];
+                for (const name of archive.names()) {
+                    if (!name.startsWith(prefix) || name === prefix)
+                        continue;
+                    const rel = name.slice(prefix.length);
+                    if (rel === '' || rel.endsWith('/'))
+                        continue;
+                    const data = archive.readEntry(name);
+                    files.push({ relativePath: rel, data, contentHash: sha256Hex(data) });
+                }
+                sections.set(id, { version: 1, files });
+                continue;
+            }
+            const jsonPath = SECTION_JSON_PATHS[id];
+            if (jsonPath === undefined)
+                continue; // secrets 分区无 JSON 文件
+            if (!archive.has(jsonPath))
+                continue; // 声明包含但文件缺失 → 由调用方记 missingSections
+            let data;
+            try {
+                data = archive.readEntryJson(jsonPath);
+            }
+            catch (err) {
+                throw new Error(this.msg('import.sectionParseFailed', { section: id, reason: err instanceof Error ? err.message : String(err) }));
+            }
+            // G-05：分区数据 version 高于本版本支持的 1 → 跳过该分区（warning，不阻断整个 bundle）。
+            // 判定前置在此（不改 schema/config.ts 的校验语义）：只有「数字且 > 1」才跳过；
+            // version < 1、非数字或缺失仍交由 validateSectionData 记硬错误（数据损坏语义不变）。
+            const rawVersion = (data !== null && typeof data === 'object')
+                ? data['version']
+                : undefined;
+            if (typeof rawVersion === 'number' && rawVersion > 1) {
+                unsupportedVersions.push({ section: id, version: rawVersion });
+                warnings.push(this.msg('import.unsupportedSectionVersion', { section: id, version: String(rawVersion) }));
+                continue;
+            }
+            const issues = validateSectionData(id, data);
+            const errors = issues.filter((i) => i.severity === 'error');
+            if (errors.length > 0) {
+                throw new Error(this.msg('import.sectionInvalid', { section: id, issues: errors.map((e) => e.message).join('; ') }));
+            }
+            sections.set(id, data);
+        }
+        // 未知分区汇总告警（放在版本告警之后：一条消息列出全部被跳过的未知分区）
+        if (unsupportedSections.length > 0) {
+            warnings.push(this.msg('import.unsupportedSections', { sections: unsupportedSections.join(', ') }));
+        }
+        return { sections, unsupportedSections, unsupportedVersions, warnings };
+    }
+    async analyzeBundle(bundle) {
+        const extraction = this.extractSections(bundle);
+        const { sections } = extraction;
+        const { manifest } = bundle;
+        const importCtx = {
+            manifest,
+            targetPlatform: this.ctx.platform,
+            target: this.ctx,
+            sections,
+            pathMappings: [],
+            resolutions: {},
+            secretInputs: {},
+            log: this.ctx.log,
+            msg: this.msg,
+        };
+        const adapterItems = [];
+        const adapterIssues = [];
+        for (const adapter of this.adapters) {
+            const data = sections.get(adapter.id);
+            if (data === undefined)
+                continue;
+            try {
+                const v = await adapter.validate(data, this.msg);
+                for (const issue of v.issues) {
+                    if (issue.severity === 'error')
+                        adapterIssues.push(this.msg('import.adapterValidationIssue', { adapter: adapter.id, message: issue.message }));
+                }
+                if (!v.valid)
+                    continue;
+                const items = await adapter.analyzeImport(data, importCtx);
+                adapterItems.push(...items);
+            }
+            catch (err) {
+                adapterIssues.push(this.msg('import.adapterAnalyzeFailed', { adapter: adapter.id, reason: err instanceof Error ? err.message : String(err) }));
+            }
+        }
+        return {
+            ...bundle,
+            sections,
+            unsupportedSections: extraction.unsupportedSections,
+            unsupportedVersions: extraction.unsupportedVersions,
+            sectionWarnings: extraction.warnings,
+            adapterItems,
+            adapterIssues,
+        };
+    }
+    /* ---------------- 第 8 步：analyzeImport ---------------- */
+    async analyzeImport(zipPath) {
+        const bundle = await this.loadBundle(zipPath);
+        const { manifest, zipWarnings } = bundle;
+        const analyzed = await this.analyzeBundle(bundle);
+        const errors = [...analyzed.adapterIssues];
+        const warnings = [...zipWarnings, ...bundle.migrationWarnings, ...analyzed.sectionWarnings];
+        if (!canImport(manifest.schemaVersion)) {
+            errors.push(this.msg('import.versionUnsupported', { version: describeVersion(manifest.schemaVersion) }));
+        }
+        // 兼容性（第 6 步）
+        const sectionsInZip = [...analyzed.sections.keys()];
+        // G-01/G-02/G-03/G-05：被「跳过」的分区（本版本不认识的未知分区 / 数据版本过高）**不是缺失**，
+        // 必须从 missingSections 剔除；missingSections 只统计「已知分区但 ZIP 内文件缺失」。
+        const unsupportedSections = analyzed.unsupportedSections;
+        const skippedSections = new Set([
+            ...unsupportedSections,
+            ...analyzed.unsupportedVersions.map((u) => u.section),
+        ]);
+        const missingSections = Object.entries(manifest.sections)
+            .filter(([id, on]) => on && !skippedSections.has(id) && !analyzed.sections.has(id))
+            .map(([id]) => id);
+        if (missingSections.length > 0) {
+            warnings.push(this.msg('import.missingSections', { sections: missingSections.join(', ') }));
+        }
+        const compatibility = computeCompatibility({
+            sourceDsh: manifest.source.dshVersion,
+            targetDsh: this.ctx.dshVersion,
+            sourcePlatform: manifest.source.platform,
+            targetPlatform: this.ctx.platform,
+            schemaVersion: manifest.schemaVersion,
+            missingSections,
+        });
+        // 路径问题（第 12 步检测；核心只做形态判定，最终映射由 UI 确认）
+        const pathIssues = detectPathIssues(manifest.source.platform, this.ctx.platform, analyzed.sections);
+        // 依赖检测（§15：缺失不阻塞，标记 Requires Attention）
+        const dependencyIssues = [];
+        if (this.dependencyChecker) {
+            const mcp = analyzed.sections.get('mcp');
+            for (const server of mcp?.servers ?? []) {
+                const cmd = (server.command ?? '').trim();
+                if (cmd === '')
+                    continue;
+                const base = cmd.split(/[\\/ ]/).pop() ?? cmd;
+                if (!KNOWN_DEPENDENCIES.has(base))
+                    continue;
+                try {
+                    const ok = await this.dependencyChecker(base);
+                    if (!ok)
+                        dependencyIssues.push({ item: server.serverName ?? base, dependency: base });
+                }
+                catch {
+                    // 检查器异常视为未知，不误报
+                }
+            }
+        }
+        // 秘密计数：普通备份中已配置（有值）但未导出的凭据数
+        const creds = analyzed.sections.get('credentialsStatus');
+        const secretCount = (creds?.credentials ?? []).filter((c) => c.configured === true && c.hasValue !== true).length;
+        // 插件摘要
+        const plugins = analyzed.sections.get('plugins');
+        const toInstall = analyzed.adapterItems.filter((i) => i.kind === 'Install').length;
+        const pluginSummary = {
+            installed: Math.max((plugins?.plugins?.length ?? 0) - toInstall, 0),
+            toInstall,
+        };
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+            compatibility,
+            sectionsInZip,
+            unsupportedSections,
+            unsupportedVersions: analyzed.unsupportedVersions,
+            pluginSummary,
+            pathIssues,
+            secretCount,
+            dependencyIssues,
+            encrypted: manifest.security.encrypted,
+        };
+    }
+    /* ---------------- 第 9 步：createImportPlan（Dry Run 复用） ---------------- */
+    async createImportPlan(zipPath, decisions) {
+        const bundle = await this.loadBundle(zipPath);
+        const analyzed = await this.analyzeBundle(bundle);
+        const { manifest } = bundle;
+        // 先把用户路径映射应用到各分区数据（PathMapper 先行：applyItem 拿到的已是映射后数据）
+        applyMappingsToSections(analyzed.sections, decisions.pathMappings);
+        const importCtx = {
+            manifest,
+            targetPlatform: this.ctx.platform,
+            target: this.ctx,
+            sections: analyzed.sections,
+            pathMappings: decisions.pathMappings,
+            resolutions: decisions.resolutions,
+            secretInputs: {},
+            log: this.ctx.log,
+            msg: this.msg,
+        };
+        const items = analyzed.adapterItems.map((item) => applyItemResolution(item, decisions, this.msg));
+        const planMappings = mergePathMappings(items, decisions.pathMappings);
+        // F4 删除墓碑过滤：读取本地删除墓碑（<dataDir>/tombstones.json；缺失/损坏 → 空列表安全降级），
+        // 剔除命中墓碑的计划项（插件 / 技能 / 文件类条目 + 分区级墓碑整分区跳过）。
+        // 过滤是纯函数（applyTombstoneFilter），此处只负责加载数据并调用。
+        const tombstones = await loadTombstones(this.ctx.fs, path.join(this.ctx.homeDir, 'dsh-config-manager'));
+        const { items: planItems, skipped: skippedTombstoned } = applyTombstoneFilter(items, tombstones);
+        // MissingSecret：兜底——credentialsStatus 分区里已配置的凭据若没有对应计划项，补占位
+        ensureMissingSecrets(planItems, analyzed.sections, this.msg);
+        const missingSecrets = planItems
+            .filter((i) => i.kind === 'MissingSecret')
+            .map((i) => ({ ref: i.id.replace(/^secret:/, ''), required: true }));
+        const needsRestart = planItems.some((i) => i.kind === 'Install' || (i.adapter === 'mcp' && i.kind !== 'Skip' && i.kind !== 'Warning'));
+        const estimatedActions = {};
+        for (const item of planItems) {
+            if (item.kind === 'Skip' || item.kind === 'Warning')
+                continue;
+            estimatedActions[item.adapter] = (estimatedActions[item.adapter] ?? 0) + 1;
+        }
+        return {
+            items: planItems,
+            globalStrategy: decisions.strategy,
+            pathMappings: planMappings,
+            missingSecrets,
+            needsRestart,
+            estimatedActions,
+            skippedTombstoned,
+        };
+    }
+    /* ---------------- 第 11-14 步：executeImportPlan（快照 → 执行 → 校验 → 结果/回滚） ---------------- */
+    async executeImportPlan(zipPath, plan, opts = {}) {
+        const bundle = await this.loadBundle(zipPath);
+        const analyzed = await this.analyzeBundle(bundle);
+        applyMappingsToSections(analyzed.sections, plan.pathMappings);
+        // 10. 用户确认（安全阀：不确认绝不动数据）
+        if (opts.confirm !== true) {
+            throw new ImportNotConfirmedError(this.msg);
+        }
+        // 10b. 加密不变量：加密备份必须已成功解密（decryptedCredentials 由宿主用备份密码
+        // 解开 security/secrets.enc 后注入）。未解密（undefined）一律拒绝执行——
+        // 不允许把加密凭据静默降级为「缺凭据照常导入」，否则加密备份与普通备份无区别。
+        if (bundle.manifest.security.encrypted && opts.decryptedCredentials === undefined) {
+            throw new Error(this.msg('import.encryptedPasswordRequired'));
+        }
+        const importCtx = {
+            manifest: bundle.manifest,
+            targetPlatform: this.ctx.platform,
+            target: this.ctx,
+            sections: analyzed.sections,
+            pathMappings: plan.pathMappings,
+            resolutions: {},
+            secretInputs: opts.secretInputs ?? {},
+            decryptedCredentials: opts.decryptedCredentials,
+            log: this.ctx.log,
+            msg: this.msg,
+            onLog: opts.onLog,
+        };
+        // 11. 快照（强制：导入前必须先备份将被修改的目标）。
+        //     Phase 4：宿主注入 snapshotBinding 时，把 op-bound 元数据写入快照，并立即绑定 journal
+        //     （SNAPSHOT_CREATED），保证「快照 durable+verified 且 journal 已知」先于首个 mutation。
+        const snapshot = await createSnapshot({
+            ctx: this.ctx,
+            plan,
+            sourceZip: zipPath,
+            store: this.snapshotStore,
+            adapters: this.adapters,
+            operationId: opts.snapshotBinding?.operationId,
+            operationType: opts.snapshotBinding?.operationType,
+            environmentFingerprint: opts.snapshotBinding?.environmentFingerprint,
+            ownerInstanceId: opts.snapshotBinding?.ownerInstanceId,
+        });
+        if (opts.snapshotBinding !== undefined) {
+            await opts.snapshotBinding.bindSnapshot(snapshot.id);
+            // 首个 destructive side effect 前：SNAPSHOT_CREATED→APPLYING（在首个 applyOne 之前调 markApplying）
+            await opts.snapshotBinding.markApplying();
+        }
+        // P2-B（Phase 8）：逐计划项 WAL 预登记。将产生真实 side effect 的项在 apply 之前
+        // 记为 planned（文件类带 beforeFp），使 crash 中途可按「仍 planned ⇒ 未应用」保守判定；
+        // 非文件项 external=true（不可证明 → reconcile 恒 needs-attention，安全边界不放宽）。
+        const sb = opts.snapshotBinding;
+        const beforeFpByItem = new Map();
+        if (sb?.recordStep !== undefined) {
+            for (const item of plan.items) {
+                if (!this.shouldJournalStep(item))
+                    continue;
+                let rel = null;
+                let beforeFp = null;
+                if (Analyzer.fileRelFor(item, importCtx.target.profile) !== null) {
+                    rel = Analyzer.fileRelFor(item, importCtx.target.profile);
+                    beforeFp = await this.fileFp(importCtx, rel);
+                }
+                beforeFpByItem.set(item.id, beforeFp);
+                await sb.recordStep({
+                    id: item.id,
+                    adapter: item.adapter,
+                    kind: item.kind,
+                    ref: rel !== null ? resolveFileTarget(importCtx.target, item.adapter, item.target?.ref ?? '') : '',
+                    external: rel === null,
+                    status: 'planned',
+                    beforeFp,
+                    afterFp: null,
+                });
+            }
+        }
+        const executed = [];
+        const warnings = [...bundle.zipWarnings, ...bundle.migrationWarnings, ...analyzed.sectionWarnings];
+        let needsRestart = plan.needsRestart;
+        let anyFailed = false;
+        // 12. 分阶段执行
+        const byAdapter = new Map();
+        for (const item of plan.items) {
+            const list = byAdapter.get(item.adapter) ?? [];
+            list.push(item);
+            byAdapter.set(item.adapter, list);
+        }
+        const totalItems = APPLY_ORDER.reduce((sum, id) => sum + (byAdapter.get(id)?.length ?? 0), 0);
+        let itemIndex = 0;
+        for (const adapterId of APPLY_ORDER) {
+            const adapter = this.adapters.find((a) => a.id === adapterId);
+            if (!adapter)
+                continue;
+            for (const item of byAdapter.get(adapterId) ?? []) {
+                // 每项一个 AbortController：宿主可 abort「当前项」（用户跳过当前插件）→
+                // 该项子进程被杀、标记为 user-skipped；不影响后续项执行。
+                const controller = new AbortController();
+                importCtx.signal = controller.signal;
+                // m1 埋点：每开始一个计划项上报（UI 显示「正在执行项 X」/ 判定跳过按钮）
+                const startIndex = itemIndex + 1;
+                try {
+                    opts.onItemStart?.({ adapter: item.adapter, index: startIndex, total: totalItems, detail: item.id });
+                }
+                catch {
+                    // 埋点回调失败不影响导入执行
+                }
+                const outcome = await this.applyOne(adapter, item, importCtx);
+                importCtx.signal = undefined;
+                // m1 埋点：每完成一个计划项上报（真实进度；onItem 抛错不得中断导入）
+                itemIndex += 1;
+                try {
+                    opts.onItem?.({
+                        adapter: item.adapter,
+                        index: itemIndex,
+                        total: totalItems,
+                        status: outcome.executed.status,
+                        detail: item.id,
+                    });
+                }
+                catch {
+                    // 埋点回调失败不影响导入执行（进度是尽力而为）
+                }
+                executed.push(outcome.executed);
+                // P2-B（Phase 8）：逐项更新 journal step。文件类成功 → done + afterFp（reconcile 可判
+                // recovered）；失败/warning/跳过 → 无不可靠 afterFp（attention/skipped → 保守 needs-attention）。
+                if (sb?.recordStep !== undefined && beforeFpByItem.has(item.id)) {
+                    const rel = Analyzer.fileRelFor(item, importCtx.target.profile);
+                    let afterFp = null;
+                    if (rel !== null && outcome.executed.status === 'ok') {
+                        afterFp = await this.fileFp(importCtx, rel);
+                    }
+                    await sb.recordStep({
+                        id: item.id,
+                        adapter: item.adapter,
+                        kind: item.kind,
+                        ref: rel !== null ? resolveFileTarget(importCtx.target, item.adapter, item.target?.ref ?? '') : '',
+                        external: rel === null,
+                        // issue #35：'warning'（如插件安装失败但非致命 §34.17）此前被记为 'skipped'，
+                        // 与「用户主动跳过」在持久层不可区分 —— 事后审计会得出「用户跳过了这些插件」的错误结论。
+                        // 失败/警告都是**不可证明已应用** → 一律 attention；'skipped' 只留给真正的跳过。
+                        status: outcome.executed.status === 'ok'
+                            ? 'done'
+                            : outcome.executed.status === 'skipped'
+                                ? 'skipped'
+                                : 'attention',
+                        beforeFp: beforeFpByItem.get(item.id) ?? null,
+                        afterFp,
+                        message: outcome.executed.message ?? null,
+                    });
+                }
+                // 仅硬失败计入 anyFailed（warning 属非致命：目标不可达等，不触发回滚，§34.17）
+                if (outcome.executed.status === 'failed')
+                    anyFailed = true;
+                if (outcome.needsRestart)
+                    needsRestart = true;
+                if (outcome.warning)
+                    warnings.push(outcome.warning);
+                if (opts.rollbackOnError && outcome.executed.status === 'failed')
+                    break;
+            }
+            if (opts.rollbackOnError && anyFailed)
+                break;
+        }
+        // 失败整体回滚（rollbackOnError）：逆序补偿 + 诚实报告
+        if (opts.rollbackOnError && anyFailed) {
+            const rollbackReport = await rollback({
+                ctx: this.ctx,
+                snapshot,
+                store: this.snapshotStore,
+                adapters: this.adapters,
+            });
+            // M1：回滚完成 → 快照标记 rolled-back（元数据写失败只告警，不影响回滚结论）
+            await this.markSnapshotStatus(snapshot.id, 'rolled-back');
+            this.ctx.log.warn(`导入失败，已回滚（${rollbackReport.full ? '完整' : '部分'}）`, {
+                failed: executed.filter((e) => e.status === 'failed').map((e) => e.itemId),
+            });
+            return {
+                ok: false,
+                executed,
+                needsRestart: false,
+                missingSecrets: [],
+                warnings,
+                rollback: rollbackReport,
+                snapshotId: snapshot.id,
+                skippedTombstoned: plan.skippedTombstoned ?? [],
+            };
+        }
+        // 13. 校验（执行后：对最终数据再 validate；失败仅告警，不掩盖已完成项）
+        for (const adapter of this.adapters) {
+            const data = analyzed.sections.get(adapter.id);
+            if (data === undefined)
+                continue;
+            try {
+                const v = await adapter.validate(data, this.msg);
+                for (const issue of v.issues) {
+                    if (issue.severity === 'error')
+                        warnings.push(this.msg('import.postValidationIssue', { adapter: adapter.id, message: issue.message }));
+                }
+            }
+            catch (err) {
+                warnings.push(this.msg('import.postValidationFailed', { adapter: adapter.id, reason: err instanceof Error ? err.message : String(err) }));
+            }
+        }
+        // 14. 结果
+        const missingSecrets = plan.missingSecrets
+            .filter((s) => !importCtx.decryptedCredentials?.has(s.ref) && !importCtx.secretInputs[s.ref])
+            .map((s) => s.ref);
+        // M1：导入成功 → 快照标记 done（元数据写失败只告警，不改变导入结论）
+        await this.markSnapshotStatus(snapshot.id, 'done');
+        // F1 vault 回填：导出时敏感文件（.credentials.yaml 等）明文未进备份（includeSecrets=false
+        // 时镜像到 <dataDir>/vault），导入成功后从本机 vault 回填 $DSH_HOME；vault 缺失
+        // （跨机恢复 / 从未镜像过）记入警告提示用户重填。尽力而为：失败仅警告，不影响导入结论。
+        try {
+            const vaultDataDir = path.join(this.ctx.homeDir, 'dsh-config-manager');
+            const vault = await restoreVaultFiles(this.ctx.fs, vaultDataDir, this.ctx.homeDir, DEFAULT_SENSITIVE_RELS);
+            for (const rel of vault.restored)
+                warnings.push(this.msg('import.vaultRestored', { rel }));
+            for (const rel of vault.missing)
+                warnings.push(this.msg('import.vaultMissing', { rel }));
+            for (const s of vault.skipped) {
+                // targetExists = 目标已有更新的凭据，属预期跳过，不打扰用户
+                if (s.reason !== 'targetExists')
+                    warnings.push(this.msg('import.vaultBackfillFailed', { rel: s.rel, reason: s.reason }));
+            }
+        }
+        catch (err) {
+            warnings.push(this.msg('import.vaultBackfillFailed', { rel: DEFAULT_SENSITIVE_RELS.join(', '), reason: err instanceof Error ? err.message : String(err) }));
+        }
+        return {
+            ok: true, // 单项失败已如实记录在 executed；无未捕获异常即完成
+            executed,
+            needsRestart,
+            missingSecrets,
+            warnings,
+            rollback: null,
+            snapshotId: snapshot.id,
+            skippedTombstoned: plan.skippedTombstoned ?? [],
+        };
+    }
+    /** 快照状态标记（M1）：成功→done / 失败回滚→rolled-back。元数据写失败只告警不抛错。 */
+    async markSnapshotStatus(id, status) {
+        try {
+            await this.snapshotStore.updateStatus(id, status);
+        }
+        catch (err) {
+            this.ctx.log.warn(`快照 ${id} 状态标记 ${status} 失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /* -------------------------------------------------- P2-B 逐计划项指纹（Phase 8） */
+    /**
+     * 该计划项是否会产生真实 side effect（需 journal step 追踪）。
+     * 排除无副作用的「信息/跳过/错误」项与未采用其导入内容的 Conflict ——
+     * 这些不写目标，记录只会保守化 reconcile 而无收益。
+     */
+    shouldJournalStep(item) {
+        if (item.kind === 'Skip' || item.kind === 'Warning' || item.kind === 'MissingDependency' || item.kind === 'Error')
+            return false;
+        if (item.kind === 'Conflict' && item.conflict?.resolution !== 'useImported')
+            return false;
+        return true;
+    }
+    /** 文件类且可指纹 → 返回 home-relative 目标路径（posix）；否则 null（不可指纹外部项）。
+     *  profile 必须传入：plugins 分区的 pnpm-workspace.yaml / patch 文件位于
+     *  `profiles/<profile>/` 下，缺了它算出的相对路径不存在 → 指纹恒 null（issue #35）。 */
+    static fileRelFor(item, profile) {
+        if (!isFileSection(item.adapter))
+            return null;
+        const ref = item.target?.ref;
+        if (ref === undefined || ref === '')
+            return null;
+        return resolveFileTargetRel(item.adapter, ref, profile);
+    }
+    /** 读目标文件算 sha256（home-relative；经 HostContext.fs 使测试 mock 可注入）。失败返回 null。 */
+    async fileFp(ctx, rel) {
+        try {
+            const data = await ctx.target.fs.readFile(rel);
+            return sha256Hex(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async applyOne(adapter, item, ctx) {
+        // 执行日志（导入面板展示）：仅非敏感文本（项 id / 命令），绝不写密钥/密码/补录值
+        const onLog = ctx.onLog;
+        if (item.kind === 'Skip' ||
+            item.kind === 'Warning' ||
+            item.kind === 'MissingDependency' ||
+            (item.kind === 'Conflict' && item.conflict?.resolution !== 'useImported')) {
+            // Warning / MissingDependency 是信息项（依赖缺失、需人工注意），不调用 applyItem。
+            onLog?.(`– ${item.id}`);
+            return { executed: { itemId: item.id, status: 'skipped' }, needsRestart: false };
+        }
+        if (item.kind === 'Error') {
+            onLog?.(`✗ ${item.id}`);
+            return { executed: { itemId: item.id, status: 'failed', message: item.detail ?? item.description }, needsRestart: false };
+        }
+        if (item.kind === 'MissingSecret') {
+            const ref = item.id.replace(/^secret:/, '');
+            const value = ctx.decryptedCredentials?.get(ref) ?? ctx.secretInputs[ref];
+            if (value === undefined || value === '') {
+                onLog?.(`– ${item.id}`);
+                return { executed: { itemId: item.id, status: 'skipped', message: this.msg('import.secretNotProvided') }, needsRestart: false };
+            }
+            // 补录值只经 adapter.applyItem 写入（m5 实现），引擎不直接触碰凭据
+        }
+        onLog?.(`▶ ${item.id}`);
+        try {
+            const result = await adapter.applyItem(item, ctx);
+            const status = result.ok ? 'ok' : (result.warning === true ? 'warning' : 'failed');
+            onLog?.(`${status === 'ok' ? '✓' : status === 'warning' ? '⚠' : '✗'} ${item.id}`);
+            return {
+                executed: { itemId: item.id, status, message: result.message },
+                needsRestart: result.needsRestart === true,
+                warning: result.warning === true ? `${item.id}: ${result.message ?? item.description}` : undefined,
+            };
+        }
+        catch (err) {
+            // 用户跳过（宿主 install 中止子进程）：记为 skipped + skippedByUser，非失败，不触发回滚
+            if (err instanceof ImportUserSkippedError) {
+                onLog?.(`⏭ ${item.id}`);
+                return {
+                    executed: {
+                        itemId: item.id,
+                        status: 'skipped',
+                        skippedByUser: true,
+                        message: this.msg('import.userSkipped'),
+                    },
+                    needsRestart: false,
+                };
+            }
+            this.ctx.log.error(`应用计划项失败 ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
+            onLog?.(`✗ ${item.id}`);
+            return {
+                executed: { itemId: item.id, status: 'failed', message: err instanceof Error ? err.message : String(err) },
+                needsRestart: false,
+            };
+        }
+    }
+}
+/* ---------------- 纯函数辅助 ---------------- */
+/**
+ * G-06：执行 schema 迁移链并把迁移结果重新校验为合法 manifest。
+ *
+ * `migrateToCurrent` 此前在 `src/` 内零引用（迁移链有定义、有单测、从不执行）；
+ * `loadBundle` 只用 isSupported 做判定就直接把旧文档当新格式使用。本函数是迁移链的
+ * **真实接线点**：沿链迁移 → 重新校验结果是合法 manifest（不合法则抛明确错误，
+ * 绝不把半迁移文档当合法 manifest 继续）→ 每个已应用步骤翻译成用户可见告警。
+ *
+ * 显式传入 from/target 使「链式迁移真的被执行」可被直接单测：当前
+ * `MIN_SUPPORTED_SCHEMA_VERSION = CURRENT_SCHEMA_VERSION = 1`，`needsMigration` 恒假，
+ * 因此该分支在真实导入中结构上不可达（loadBundle 仍按 needsMigration 调用本函数）。
+ */
+export function runSchemaMigration(doc, fromVersion, targetVersion, msg) {
+    const result = migrateToCurrent(doc, fromVersion, targetVersion);
+    const issues = validateManifest(result.doc).filter((i) => i.severity === 'error');
+    if (issues.length > 0) {
+        throw new Error(msg('import.migrateInvalidManifest', { issues: issues.map((i) => i.message).join('; ') }));
+    }
+    return {
+        manifest: result.doc,
+        warnings: result.applied.map((step) => msg('import.migrated', { from: String(step.from), to: String(step.to) })),
+    };
+}
+async function verifyAgainstTable(entries, table) {
+    const mismatches = [];
+    const missing = [];
+    for (const [relPath, expected] of Object.entries(table)) {
+        const data = entries.get(relPath);
+        if (data === undefined) {
+            missing.push(relPath);
+            continue;
+        }
+        if (sha256Hex(data) !== expected)
+            mismatches.push(relPath);
+    }
+    return { ok: mismatches.length === 0 && missing.length === 0, mismatches, missing };
+}
+/** 应用用户冲突决策 + 全局策略（纯函数，返回新数组） */
+function applyItemResolution(item, decisions, msg) {
+    if (item.kind !== 'Conflict')
+        return item;
+    const resolution = decisions.resolutions[item.id];
+    if (resolution === 'keepCurrent') {
+        return { ...item, kind: 'Skip', severity: 'info', detail: `${item.detail ?? ''}${msg('import.conflictKeepCurrent')}` };
+    }
+    if (resolution === 'useImported') {
+        return { ...item, kind: 'Update', severity: 'info', conflict: { itemId: item.id, resolution } };
+    }
+    // review / 未决策：按全局策略兜底
+    if (decisions.strategy === 'skipExisting') {
+        return { ...item, kind: 'Skip', severity: 'info', detail: `${item.detail ?? ''}${msg('import.conflictSkipExisting')}` };
+    }
+    if (decisions.strategy === 'replace') {
+        return { ...item, kind: 'Update', severity: 'info', detail: `${item.detail ?? ''}${msg('import.conflictReplace')}` };
+    }
+    return item; // merge + 未决策 → 保持 Conflict，由报告列明
+}
+/** 路径映射合并：只保留「已解析」（newPrefix 非空）的映射用于执行期数据改写；
+ * 未解决项（newPrefix 空）保留在 plan.items 里供 UI 提示，但不参与数据映射。 */
+function mergePathMappings(items, userMappings) {
+    const merged = new Map();
+    for (const m of userMappings) {
+        if (m.newPrefix !== '')
+            merged.set(m.oldPrefix, m);
+    }
+    return [...merged.values()];
+}
+/** 把映射应用到分区数据（PathMapper 先行：只替换匹配前缀的字符串叶值） */
+function applyMappingsToSections(sections, mappings) {
+    if (mappings.length === 0)
+        return;
+    for (const [sectionId, data] of sections) {
+        const appliesTo = sectionId === 'workspaces' ? ['workspaces']
+            : sectionId === 'mcp' ? ['mcp']
+                : sectionId === 'skills' ? ['skills']
+                    : sectionId === 'pluginFiles' ? ['pluginConfig']
+                        : [];
+        const relevant = mappings.filter((m) => m.appliesTo.some((a) => appliesTo.includes(a)) || m.appliesTo.length === 0);
+        if (relevant.length === 0)
+            continue;
+        sections.set(sectionId, applyPrefixMappings(data, relevant));
+    }
+}
+/** 路径形态判定：跨平台盘符/UNIX 冲突 → platformMismatch；其余绝对路径 → missing（需映射） */
+function detectPathIssues(sourcePlatform, targetPlatform, sections) {
+    const issues = [];
+    const workspaces = sections.get('workspaces');
+    for (const w of workspaces?.workspaces ?? []) {
+        const p = w.path;
+        if (p && isAbsolutePath(p))
+            issues.push(judgePath(p, sourcePlatform, targetPlatform));
+    }
+    const mcp = sections.get('mcp');
+    for (const s of mcp?.servers ?? []) {
+        for (const p of [s.cwd, s.command]) {
+            if (p && isAbsolutePath(p))
+                issues.push(judgePath(p, sourcePlatform, targetPlatform));
+        }
+    }
+    // 去重
+    const seen = new Set();
+    return issues.filter((i) => {
+        const key = `${i.kind}:${i.value}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function judgePath(p, sourcePlatform, targetPlatform) {
+    const isWinStyle = /^[a-zA-Z]:[\\/]/.test(p);
+    const isUnixStyle = p.startsWith('/');
+    if (sourcePlatform !== targetPlatform && ((isWinStyle && targetPlatform !== 'win32') || (isUnixStyle && targetPlatform === 'win32'))) {
+        return { kind: 'platformMismatch', value: p };
+    }
+    return { kind: 'missing', value: p };
+}
+/** MissingSecret 兜底：credentialsStatus 分区已配置凭据若无对应计划项，补占位 */
+function ensureMissingSecrets(items, sections, msg) {
+    const creds = sections.get('credentialsStatus');
+    if (!creds?.credentials)
+        return;
+    const existing = new Set(items.filter((i) => i.kind === 'MissingSecret').map((i) => i.id));
+    for (const c of creds.credentials) {
+        if (!c.ref || c.configured !== true)
+            continue;
+        const id = `secret:${c.ref}`;
+        if (existing.has(id))
+            continue;
+        items.push({
+            id,
+            kind: 'MissingSecret',
+            adapter: 'credentialsStatus',
+            description: msg('import.secretMissingDesc', { ref: c.ref }),
+            severity: 'warning',
+            target: { adapter: 'credentialsStatus', ref: c.ref },
+        });
+        existing.add(id);
+    }
+}
+/* ---------------- F4 删除墓碑过滤（纯函数，可独立测试） ---------------- */
+/**
+ * 按删除墓碑过滤计划项（F4）：
+ *  - 条目级：插件（Install/Update/Conflict）、技能（skills 文件）、文件类条目（agentPresets 等）命中墓碑 → 剔除；
+ *  - 分区级：墓碑 kind='section' 且 id=分区 id → 整分区跳过（仅记一条 skipped）。
+ * 返回过滤后的 items 与被跳过清单（纯函数：不读文件、不改入参）。
+ */
+function applyTombstoneFilter(items, tombstones) {
+    if (tombstones.length === 0)
+        return { items, skipped: [] };
+    const tombstonedSections = new Set(tombstones.filter((t) => t.kind === 'section').map((t) => t.id));
+    const skipped = [];
+    const out = [];
+    const reportedSections = new Set();
+    for (const item of items) {
+        // 分区级墓碑优先：整个分区不出现（含 Skip 等非写入项，UI 提示「该分区已删除」）
+        if (tombstonedSections.has(item.adapter)) {
+            if (!reportedSections.has(item.adapter)) {
+                skipped.push({ kind: 'section', id: item.adapter, adapter: item.adapter });
+                reportedSections.add(item.adapter);
+            }
+            continue;
+        }
+        const key = tombstoneKeyForItem(item);
+        if (key !== null && isTombstoned(key.kind, key.id, tombstones)) {
+            skipped.push({ kind: key.kind, id: key.id, adapter: item.adapter });
+            continue;
+        }
+        out.push(item);
+    }
+    return { items: out, skipped };
+}
+/** PlanItem → 墓碑键（{kind,id}）映射；非「将写入」的条目（Skip 等）与配置类项返回 null 不过滤 */
+function tombstoneKeyForItem(item) {
+    // 插件本体（plugin:<pkg>）：Install / Update / Conflict 均视为「将写入该插件」→ 命中墓碑剔除；
+    // patch: 行与 plugins:pnpm-workspace 是配置类项，不按插件墓碑过滤（分区级墓碑可覆盖）。
+    if (item.adapter === 'plugins' && item.id.startsWith('plugin:')) {
+        if (item.kind !== 'Install' && item.kind !== 'Update' && item.kind !== 'Conflict')
+            return null;
+        return { kind: 'plugin', id: item.id.slice('plugin:'.length) };
+    }
+    // 文件类分区条目（id = <分区>:<相对路径>）：skills → skill 墓碑；其余文件类（agentPresets/
+    // agentInstructions/pluginFiles/sessions/self）→ 通用 file 墓碑（id 为相对路径）。
+    if (item.kind === 'Create' || item.kind === 'Update' || item.kind === 'Conflict') {
+        const prefix = `${item.adapter}:`;
+        if (item.adapter === 'skills')
+            return { kind: 'skill', id: item.id.slice(prefix.length) };
+        if (isFileSection(item.adapter))
+            return { kind: 'file', id: item.id.slice(prefix.length) };
+    }
+    return null;
+}
+//# sourceMappingURL=analyzer.js.map