dsh-config-manager 0.1.77 → 0.1.79

package/lib/adapters/credentials.d.ts

@@ -9,7 +9,7 @@
  */
 import type { CredentialsSection } from '../schema/types.ts';
 import type { MsgFunc } from '../core/messages.ts';
-import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
+import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, ExportUnit, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
 import { type NamespaceProvider } from './settings.ts';
 export type CredentialRefsProvider = (ctx: HostContext) => Promise<string[]>;
 /** 缺省 ref 收集：遍历 settings namespace，收集 llm apiKeyEnv / providers[].apiKeyEnv，
@@ -30,7 +30,11 @@ export declare class CredentialsAdapter implements ConfigAdapter<CredentialsSect
     readonly portability: import("../schema/section-registry.ts").SectionPortability;
     private readonly refs;
     constructor(options?: CredentialsAdapterOptions);
-    export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<CredentialsSection>>;
+    export(ctx: HostContext, options: ExportOptions): Promise<ExportSection<CredentialsSection>>;
+    /** 单元 id：`credentialsStatus:<凭据 ref>` */
+    private unitId;
+    /** 条目级单元清单（零 I/O）；label = 凭据 ref，detail = 本机是否有值（不含任何敏感值） */
+    listUnits(section: ExportSection<CredentialsSection>): ExportUnit[];
     analyzeImport(_data: CredentialsSection, _ctx: ImportContext): Promise<PlanItem[]>;
     applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;
     validate(data: CredentialsSection, msg?: MsgFunc): Promise<ValidationResult>;

package/lib/adapters/credentials.js

@@ -2,6 +2,7 @@ import { msgOf, zhMsg } from '../core/messages.js';
 import { namespaceFromMap, readNamespaceMap, resolveNamespaces } from './settings.js';
 import { sectionMeta } from '../schema/section-registry.js';
 import { validateJsonSection } from './json-section.js';
+import { entryByteSize, filterByUnits } from './units.js';
 /** 缺省 ref 收集：遍历 settings namespace，收集 llm apiKeyEnv / providers[].apiKeyEnv，
  * 以及 secrets 标记中「引用类字段」（apiKeyEnv/tokenEnv…）的字段值。
  * 注意 secrets[].path[0] 是 settings 文档内的字段路径（如 ['apiKey']），本身不是凭据 ref（设计 §4.2），
@@ -60,7 +61,7 @@ export class CredentialsAdapter {
     constructor(options = {}) {
         this.refs = options.refs ?? defaultCredentialRefs(options.namespaces ?? []);
     }
-    async export(ctx, _options) {
+    async export(ctx, options) {
         const credentials = [];
         const warnings = [];
         for (const ref of await this.refs(ctx)) {
@@ -78,13 +79,28 @@ export class CredentialsAdapter {
                 warnings.push(msgOf(ctx)('adapter.credStatusReadFailed', { ref, reason: err instanceof Error ? err.message : String(err) }));
             }
         }
+        // 条目级白名单：未勾选的凭据 ref 不进「需补录」清单（少带一条 = 少录一个值）
+        const picked = filterByUnits(credentials, options.includeItems?.[this.id], (c) => this.unitId(c.ref));
         return {
             sectionId: 'credentialsStatus',
-            data: { version: 1, credentials },
-            counts: { credentials: credentials.length },
+            data: { version: 1, credentials: picked },
+            counts: { credentials: picked.length },
             warnings,
         };
     }
+    /** 单元 id：`credentialsStatus:<凭据 ref>` */
+    unitId(ref) {
+        return this.id + ':' + ref;
+    }
+    /** 条目级单元清单（零 I/O）；label = 凭据 ref，detail = 本机是否有值（不含任何敏感值） */
+    listUnits(section) {
+        return (section.data.credentials ?? []).map((c) => ({
+            id: this.unitId(c.ref),
+            label: c.ref,
+            detail: c.configured ? 'configured' : 'missing',
+            sizeBytes: entryByteSize(c),
+        }));
+    }
     async analyzeImport(_data, _ctx) {
         // MissingSecret 计划项由引擎在 createImportPlan 兜底生成（analyzer.ensureMissingSecrets），
         // 依据 = 本分区里 configured=true 的凭据 → 用户补录清单。这里保持零写入纯计算。

package/lib/adapters/file-collection.js

@@ -287,7 +287,8 @@ export class FileCollectionAdapter {
     }
     /** 单元清单（零 I/O：直接由 export 产物归并）。 */
     listUnits(section) {
-        return unitsFromFiles(this.id, section.data.files, (rel) => this.unitIdOf(rel));
+        // files 可能缺省（空分区 / 手写 section）：按空表处理，不抛错 —— 选择器对任何分区都会调 listUnits
+        return unitsFromFiles(this.id, section.data.files ?? [], (rel) => this.unitIdOf(rel));
     }
     /**
      * 幂等比对用的内容（相对 baseDir 路径 + 盘上/包内字节 → 参与哈希比对的字节）。

package/lib/adapters/mcp.d.ts

@@ -1,6 +1,7 @@
 import type { MsgFunc } from '../core/messages.ts';
 import type { McpServerEntry } from '../schema/types.ts';
-import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
+import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, ExportUnit, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
+import type { McpConnectorExport } from '../core/mcp-connector-store.ts';
 /** 导出记录：McpServerEntry 之外附加来源 patch 行 id 与所在层（导入写回定位用） */
 export interface McpExportEntry extends McpServerEntry {
     sourceLineId: string;
@@ -13,6 +14,13 @@ export interface McpExportEntry extends McpServerEntry {
 export interface McpExportSection {
     version: 1;
     servers: McpExportEntry[];
+    /**
+     * MCP 连接器（\`dsh-mcp-connector\` 插件）的连接，第二个数据源。
+     *
+     * 为什么并列而不是新增分区：两条路径在 DSH 里都是「MCP 服务器」，用户心智里是一件事；
+     * 而备份格式是追加字段 ⇒ 旧备份没有它 = 空，读旧包的代码不受影响。
+     */
+    connectors?: McpConnectorExport;
 }
 /**
  * 从 patch 行数组中提取 MCP server 条目（以 config.serverName 存在为判定）。
@@ -26,13 +34,51 @@ export declare function extractMcpServers(lines: {
 }[]): McpExportEntry[];
 /** 由导出条目构造写回 patch 行 raw（单行形态，与 dsh-mcp-client 组合 config 语义一致） */
 export declare function buildMcpPatchLine(lineId: string, server: McpServerEntry): Record<string, unknown>;
+/**
+ * 单元 id：两条数据源各自独立前缀。
+ *
+ * 为什么必须分开：patch 行的 `serverName` 与连接器的 `serverName` 完全可能同名（同一台服务器的两条
+ * 历史配置路径），共用 id 会让「勾了其中一个」变成「两个一起勾」，与选择器「逐项可勾」的前提冲突。
+ * 命名空间仍以 `mcp:` 开头 —— 与 ExportUnit 的「<section>:<单元>」约定一致。
+ */
+export declare function mcpServerUnitId(serverName: string): string;
+export declare function mcpConnectorUnitId(key: string): string;
 export declare class McpAdapter implements ConfigAdapter<McpExportSection> {
     readonly id: 'mcp';
     readonly displayName: string;
     readonly defaultIncluded: boolean;
     readonly portability: import("../schema/section-registry.ts").SectionPortability;
-    export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<McpExportSection>>;
+    export(ctx: HostContext, options: ExportOptions): Promise<ExportSection<McpExportSection>>;
+    /**
+     * 条目级单元清单（选择器靠它决定「能不能展开」）。
+     *
+     * 契约（core/types.ts:1211）：纯函数、零 I/O，且必须与 export(includeItems) 自洽 ——
+     * 单元 id 就是 export 白名单里认的 id，两边共用 mcpServerUnitId / mcpConnectorUnitId。
+     *
+     * 单元 label 与 detail 只放「能帮用户认出是哪条」的信息：连接器的 detail 复用
+     * describeConnector（stdio 给命令 + 参数、http 给 URL），**绝不**带出 env / header 值。
+     */
+    listUnits(section: ExportSection<McpExportSection>): ExportUnit[];
     analyzeImport(data: McpExportSection, ctx: ImportContext): Promise<PlanItem[]>;
+    /**
+     * 连接器来源的计划项。
+     *
+     * 三条纪律：
+     *  ① 目标存储「存在但解析不了」→ 只报 warning、**零写入**（整文件改写会把 grants 等表一起抹掉）；
+     *  ② 条目里还有占位符 → 不写，产出「需重填凭据」的 warning（写进去 = 给用户一个起不来的 Server）；
+     *  ③ 同名 server 同时来自 patch 行与连接器 → 两条都保留，另加一条 warning（不隐式合并，
+     *     两者在 DSH 里是两份独立配置，合并会悄悄改变用户的生效结果）。
+     */
+    private analyzeConnectors;
     applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;
+    /**
+     * 写入一条连接：读全文件 → 只替换 `tables.connections[<key>]` → 整文件原子写。
+     *
+     * 为什么整文件写而不是走宿主 storage 服务：本机没装 `@deepseek-ai/dsh-storage-domain`，
+     * 我们拿不到 `mcp_connector` 域的表句柄；而直接改文件又会被运行中的宿主内存态覆盖 ⇒
+     * 计划项与本结果都显式要求重启（needsRestart），写之前先把原文件整体快照（引擎侧按
+     * `storages/` 前缀走文件类快照）。
+     */
+    private applyConnectorItem;
     validate(data: McpExportSection, msg?: MsgFunc): Promise<ValidationResult>;
 }

package/lib/adapters/mcp.js

@@ -16,6 +16,7 @@ import { msgOf, zhMsg } from '../core/messages.js';
 import { sectionMeta } from '../schema/section-registry.js';
 import { validateJsonSection } from './json-section.js';
 import { locatePatchLineLayer, readEffectivePatchLines, resolveWriteLayer } from '../core/patch-layers.js';
+import { MCP_CONNECTOR_STORE_REL, buildConnectorRecord, comparableConnector, exportConnectorBlock, findConnectorRecord, mergeConnectorIntoStoreText, pickConnectorKey, readConnectorStore, refillFieldsOf, } from '../core/mcp-connector-store.js';
 /**
  * 从 patch 行数组中提取 MCP server 条目（以 config.serverName 存在为判定）。
  *
@@ -83,17 +84,62 @@ export function buildMcpPatchLine(lineId, server) {
     }
     return { id: lineId, name: 'dsh-mcp-client', config };
 }
+/** 连接器计划项的 id 前缀（导入时按前缀分派到 applyConnectorItem） */
+const MCP_CONNECTOR_ITEM_PREFIX = 'mcp-connector:';
+/** 计划项 detail：stdio 给命令 + 参数，http 给 URL（不打印任何 header/env 值，防凭据入日志） */
+function describeConnector(entry) {
+    const head = entry.transport === 'stdio'
+        ? [entry.command ?? '', ...(entry.args ?? [])].filter((s) => s !== '').join(' ')
+        : (entry.url ?? '');
+    return `${entry.transport} ${head}`.trim().slice(0, 200);
+}
 function newLineId(serverName) {
     const slug = serverName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
     return `mcp-${slug || 'server'}`;
 }
+/**
+ * 单元 id：两条数据源各自独立前缀。
+ *
+ * 为什么必须分开：patch 行的 `serverName` 与连接器的 `serverName` 完全可能同名（同一台服务器的两条
+ * 历史配置路径），共用 id 会让「勾了其中一个」变成「两个一起勾」，与选择器「逐项可勾」的前提冲突。
+ * 命名空间仍以 `mcp:` 开头 —— 与 ExportUnit 的「<section>:<单元>」约定一致。
+ */
+export function mcpServerUnitId(serverName) {
+    return 'mcp:patch:' + serverName;
+}
+export function mcpConnectorUnitId(key) {
+    return 'mcp:connector:' + key;
+}
+/** 单元体积 = 该条目在包里的 UTF-8 字节数（与 /export-preview 对 JSON 分区的口径一致） */
+function unitBytes(value) {
+    return new TextEncoder().encode(JSON.stringify(value) ?? '').byteLength;
+}
+/** 只读的 stdio 描述（命令 + 参数），不打印任何 env / header 值 */
+function stdioDetail(entry) {
+    return [entry.command ?? '', ...(entry.args ?? [])].filter((s) => s !== '').join(' ').slice(0, 200);
+}
+/**
+ * 连接器整块的条目级过滤。
+ *
+ * allow === undefined = 全量（旧调用方零改动）；过滤后一条不剩 → 返回 undefined，
+ * 让 `connectors` 字段整个消失（而不是留一个空块冒充「连接器已备份」）。
+ */
+function filterConnectorBlock(block, allow) {
+    if (allow === undefined)
+        return block;
+    const connections = block.connections.filter((c) => allow.includes(mcpConnectorUnitId(c.key)));
+    const oauthConnections = block.oauthConnections.filter((c) => allow.includes(mcpConnectorUnitId(c.key)));
+    if (connections.length === 0 && oauthConnections.length === 0)
+        return undefined;
+    return { ...block, connections, oauthConnections };
+}
 export class McpAdapter {
     id = 'mcp';
     // 元数据唯一来源 = 注册表（t31）：不再与 ui/export-flow.ts 的导出目录各写一份
     displayName = sectionMeta('mcp').displayName;
     defaultIncluded = sectionMeta('mcp').defaultIncluded;
     portability = sectionMeta('mcp').portability;
-    async export(ctx, _options) {
+    async export(ctx, options) {
         const warnings = [];
         // issue #71：两层都读（home 层优先），否则 profile 层里的 server 全部丢失
         const read = await readEffectivePatchLines(ctx.patchFile, ctx.profile);
@@ -101,13 +147,94 @@ export class McpAdapter {
             warnings.push(msgOf(ctx)('adapter.patchReadFailedMCP', { reason: `${f.file}: ${f.reason}` }));
         }
         const servers = extractMcpServers(read.lines);
+        // 条目级白名单：undefined = 整分区全量（旧调用方零改动）；空数组 = 一条都不带。
+        // 选择器把「部分勾选」翻译成 includeItems['mcp']，这里必须如实过滤，否则勾了等于没勾。
+        const allow = options.includeItems?.[this.id];
+        const pickedServers = allow === undefined
+            ? servers
+            : servers.filter((s) => allow.includes(mcpServerUnitId(s.serverName)));
+        // 第二个数据源：连接器插件的 `storages/mcp_connector.json`（用户实际配置 MCP 的地方）。
+        // 读不到 = 本机没装/没用连接器（正常，静默）；读到了解析不了 = 异常，如实报 warning，
+        // **绝不**当作空表导出 —— 否则用户以为备份里有，恢复时才发现丢了。
+        let connectors;
+        try {
+            const store = await readConnectorStore(ctx.fs);
+            if (store.exists && !store.parsed) {
+                warnings.push(msgOf(ctx)('adapter.mcpConnectorReadFailed', { reason: store.error ?? 'unknown' }));
+            }
+            else if (store.exists && store.parsed) {
+                // 文件不存在 = 本机没有任何连接器：不写这个字段（旧备份也没有它，形状保持一致）
+                connectors = filterConnectorBlock(exportConnectorBlock(store.connections), allow);
+            }
+        }
+        catch (err) {
+            warnings.push(msgOf(ctx)('adapter.mcpConnectorReadFailed', { reason: err instanceof Error ? err.message : String(err) }));
+        }
+        const data = { version: 1, servers: pickedServers };
+        if (connectors !== undefined)
+            data.connectors = connectors;
         return {
             sectionId: 'mcp',
-            data: { version: 1, servers },
-            counts: { servers: servers.length },
+            data,
+            counts: {
+                servers: pickedServers.length,
+                ...(connectors !== undefined ? { connectors: connectors.connections.length } : {}),
+            },
             warnings,
         };
     }
+    /**
+     * 条目级单元清单（选择器靠它决定「能不能展开」）。
+     *
+     * 契约（core/types.ts:1211）：纯函数、零 I/O，且必须与 export(includeItems) 自洽 ——
+     * 单元 id 就是 export 白名单里认的 id，两边共用 mcpServerUnitId / mcpConnectorUnitId。
+     *
+     * 单元 label 与 detail 只放「能帮用户认出是哪条」的信息：连接器的 detail 复用
+     * describeConnector（stdio 给命令 + 参数、http 给 URL），**绝不**带出 env / header 值。
+     */
+    listUnits(section) {
+        const units = [];
+        const seen = new Set();
+        for (const server of section.data.servers ?? []) {
+            const id = mcpServerUnitId(server.serverName);
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            units.push({
+                id,
+                label: server.serverName,
+                detail: server.type === 'stdio' ? stdioDetail(server) : (server.url ?? ''),
+                sizeBytes: unitBytes(server),
+            });
+        }
+        const connectors = section.data.connectors;
+        for (const connection of connectors?.connections ?? []) {
+            const id = mcpConnectorUnitId(connection.key);
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            units.push({
+                id,
+                label: connection.name,
+                detail: describeConnector(connection),
+                sizeBytes: unitBytes(connection),
+            });
+        }
+        for (const oauth of connectors?.oauthConnections ?? []) {
+            const id = mcpConnectorUnitId(oauth.key);
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            units.push({
+                id,
+                label: oauth.name,
+                // OAuth 连接只带引用（Token 永不进备份），detail 说明它靠重新授权才能用
+                detail: 'oauth ' + oauth.serverName,
+                sizeBytes: unitBytes(oauth),
+            });
+        }
+        return units;
+    }
     async analyzeImport(data, ctx) {
         const msg = ctx.msg;
         const items = [];
@@ -151,9 +278,95 @@ export class McpAdapter {
                 }
             }
         }
+        items.push(...await this.analyzeConnectors(data, ctx));
+        return items;
+    }
+    /**
+     * 连接器来源的计划项。
+     *
+     * 三条纪律：
+     *  ① 目标存储「存在但解析不了」→ 只报 warning、**零写入**（整文件改写会把 grants 等表一起抹掉）；
+     *  ② 条目里还有占位符 → 不写，产出「需重填凭据」的 warning（写进去 = 给用户一个起不来的 Server）；
+     *  ③ 同名 server 同时来自 patch 行与连接器 → 两条都保留，另加一条 warning（不隐式合并，
+     *     两者在 DSH 里是两份独立配置，合并会悄悄改变用户的生效结果）。
+     */
+    async analyzeConnectors(data, ctx) {
+        const msg = ctx.msg;
+        const block = data.connectors;
+        if (block === undefined)
+            return [];
+        const items = [];
+        const target = await readConnectorStore(ctx.target.fs);
+        if (target.exists && !target.parsed) {
+            items.push({
+                id: 'mcp-connector:store',
+                kind: 'Warning',
+                adapter: 'mcp',
+                description: msg('adapter.mcpConnectorTargetUnreadable', { reason: target.error ?? 'unknown' }),
+                severity: 'warning',
+            });
+        }
+        const writable = target.parsed;
+        for (const entry of block.connections ?? []) {
+            const id = `mcp-connector:${entry.key}`;
+            // 双来源同名：告诉用户「这条连接和 patch 行里的同名 server 是两份」，不替用户做决定。
+            // 放在「需重填」判断**之前**——两条事实都要讲，不能因为一条要重填就吞掉另一条。
+            if (data.servers.some((s) => s.serverName === entry.serverName)) {
+                items.push({
+                    id: `mcp-connector-name:${entry.key}`,
+                    kind: 'Warning', adapter: 'mcp',
+                    description: msg('adapter.mcpConnectorDuplicateName', { serverName: entry.serverName }),
+                    severity: 'warning',
+                });
+            }
+            const refill = refillFieldsOf(entry);
+            if (refill.length > 0) {
+                items.push({
+                    id, kind: 'Warning', adapter: 'mcp',
+                    description: msg('adapter.mcpConnectorNeedsRefill', { name: entry.name }),
+                    detail: refill.join(', '),
+                    severity: 'warning',
+                });
+                continue;
+            }
+            if (!writable)
+                continue;
+            const existing = findConnectorRecord(target.connections, entry);
+            const detail = describeConnector(entry);
+            if (existing === undefined) {
+                items.push({
+                    id, kind: 'Create', adapter: 'mcp',
+                    description: msg('adapter.mcpConnectorCreate', { name: entry.name }),
+                    detail,
+                    severity: 'info',
+                    target: { adapter: 'mcp', ref: MCP_CONNECTOR_STORE_REL },
+                });
+            }
+            else if (isDeepStrictEqual(comparableConnector(existing), comparableConnector(entry))) {
+                items.push({ id, kind: 'Skip', adapter: 'mcp', description: msg('adapter.mcpConnectorSame', { name: entry.name }), severity: 'info' });
+            }
+            else {
+                items.push({
+                    id, kind: 'Conflict', adapter: 'mcp',
+                    description: msg('adapter.mcpConnectorDiff', { name: entry.name }),
+                    detail: `current=${JSON.stringify(comparableConnector(existing))} imported=${JSON.stringify(comparableConnector(entry))}`.slice(0, 200),
+                    severity: 'warning',
+                    target: { adapter: 'mcp', ref: MCP_CONNECTOR_STORE_REL },
+                });
+            }
+        }
+        for (const oauth of block.oauthConnections ?? []) {
+            items.push({
+                id: `mcp-connector:${oauth.key}`, kind: 'Warning', adapter: 'mcp',
+                description: msg('adapter.mcpConnectorOauth', { name: oauth.name }),
+                severity: 'warning',
+            });
+        }
         return items;
     }
     async applyItem(item, ctx) {
+        if (item.id.startsWith(MCP_CONNECTOR_ITEM_PREFIX))
+            return this.applyConnectorItem(item, ctx);
         const msg = ctx.msg;
         const serverName = item.id.replace(/^mcp:/, '');
         const data = ctx.sections.get('mcp');
@@ -174,6 +387,39 @@ export class McpAdapter {
         ]);
         return { ok: true, needsRestart: true, message: msg('adapter.mcpWritten', { serverName }) };
     }
+    /**
+     * 写入一条连接：读全文件 → 只替换 `tables.connections[<key>]` → 整文件原子写。
+     *
+     * 为什么整文件写而不是走宿主 storage 服务：本机没装 `@deepseek-ai/dsh-storage-domain`，
+     * 我们拿不到 `mcp_connector` 域的表句柄；而直接改文件又会被运行中的宿主内存态覆盖 ⇒
+     * 计划项与本结果都显式要求重启（needsRestart），写之前先把原文件整体快照（引擎侧按
+     * `storages/` 前缀走文件类快照）。
+     */
+    async applyConnectorItem(item, ctx) {
+        const msg = ctx.msg;
+        const key = item.id.slice(MCP_CONNECTOR_ITEM_PREFIX.length);
+        const data = ctx.sections.get('mcp');
+        const entry = data?.connectors?.connections.find((c) => c.key === key);
+        if (entry === undefined)
+            return { ok: false, message: msg('adapter.mcpConnectorMissing', { name: key }) };
+        const refill = refillFieldsOf(entry);
+        if (refill.length > 0) {
+            return { ok: false, message: msg('adapter.mcpConnectorNeedsRefill', { name: entry.name }) };
+        }
+        const store = await readConnectorStore(ctx.target.fs);
+        if (store.exists && !store.parsed) {
+            return { ok: false, message: msg('adapter.mcpConnectorTargetUnreadable', { reason: store.error ?? 'unknown' }) };
+        }
+        const existing = findConnectorRecord(store.connections, entry);
+        const record = buildConnectorRecord(entry, {
+            existing,
+            key: pickConnectorKey(store.connections, entry),
+            now: Date.now(),
+        });
+        const text = mergeConnectorIntoStoreText(store, record);
+        await ctx.target.fs.writeFile(MCP_CONNECTOR_STORE_REL, new TextEncoder().encode(text));
+        return { ok: true, needsRestart: true, message: msg('adapter.mcpConnectorWritten', { name: entry.name }) };
+    }
     async validate(data, msg = zhMsg) {
         return validateJsonSection('mcp', data, msg, (section, issues) => {
             if (!Array.isArray(section.servers)) {
@@ -186,6 +432,22 @@ export class McpAdapter {
                     }
                 }
             }
+            // connectors 是**可选追加字段**：旧备份没有它 = 合法；有它但形态不对才算错
+            const connectors = section.connectors;
+            if (connectors !== undefined) {
+                if (connectors === null || typeof connectors !== 'object' || !Array.isArray(connectors.connections)) {
+                    issues.push({ path: 'connectors.connections', message: msg('adapter.validate.array', { subject: 'connectors.connections' }), severity: 'error' });
+                }
+                else {
+                    for (const c of connectors.connections) {
+                        if (c === null || typeof c !== 'object'
+                            || typeof c.key !== 'string' || c.key === ''
+                            || typeof c.serverName !== 'string' || c.serverName === '') {
+                            issues.push({ path: 'connectors.connections[]', message: msg('adapter.mcpConnectorInvalid'), severity: 'error' });
+                        }
+                    }
+                }
+            }
         });
     }
 }

package/lib/adapters/messages.d.ts

@@ -15,6 +15,9 @@ export declare const zh: {
     readonly 'adapter.pluginDataEnvOverridden': '{path} 的位置被环境变量 {env} 覆盖，本次已跳过（不猜它指向哪里）';
     readonly 'adapter.pluginDataPathNotAllowed': '路径不在第三方插件数据的允许范围内，已拒绝写入: {path}';
     readonly 'adapter.pluginDataNoOsHome': '第三方插件的数据在系统主目录下，但当前宿主没有提供该目录的文件通道（旧版本宿主）：本次不读取也不导入 / third-party plugin data lives under the system home directory, but this host offers no file channel for it (older host): nothing is read or imported this time';
+    readonly 'adapter.pwMachinePathStripped': '已剥离 {count} 条与本机路径绑定的 pnpm 设置（换机后会指向不存在的目录）：{keys}';
+    readonly 'adapter.pwMachinePathKept': '保留本机原有的 {count} 条 pnpm 路径设置（不搬运来源机的路径）：{keys}';
+    readonly 'adapter.pwLocalReadFailed': '读取本机 pnpm-workspace.yaml 失败：{reason}（未写入 —— 避免把本机自己的 pnpm 路径设置清掉）';
 };
 export declare const en: Record<keyof typeof zh, string>;
 /** 本域活翻译器（与 core 的 engineMsg 同一实现；导入本模块即完成目录注册）。 */

package/lib/adapters/messages.js

@@ -33,6 +33,10 @@ export const zh = {
     'adapter.pluginDataEnvOverridden': '{path} 的位置被环境变量 {env} 覆盖，本次已跳过（不猜它指向哪里）',
     'adapter.pluginDataPathNotAllowed': '路径不在第三方插件数据的允许范围内，已拒绝写入: {path}',
     'adapter.pluginDataNoOsHome': '第三方插件的数据在系统主目录下，但当前宿主没有提供该目录的文件通道（旧版本宿主）：本次不读取也不导入 / third-party plugin data lives under the system home directory, but this host offers no file channel for it (older host): nothing is read or imported this time',
+    // ---------- pnpm 配置可移植净化（机器相关路径键） ----------
+    'adapter.pwMachinePathStripped': '已剥离 {count} 条与本机路径绑定的 pnpm 设置（换机后会指向不存在的目录）：{keys}',
+    'adapter.pwMachinePathKept': '保留本机原有的 {count} 条 pnpm 路径设置（不搬运来源机的路径）：{keys}',
+    'adapter.pwLocalReadFailed': '读取本机 pnpm-workspace.yaml 失败：{reason}（未写入 —— 避免把本机自己的 pnpm 路径设置清掉）',
 };
 export const en = {
     'adapter.linkDirEntry': '{path} ({files})',
@@ -50,6 +54,9 @@ export const en = {
     'adapter.pluginDataEnvOverridden': "the location of {path} is overridden by the {env} environment variable; skipped this time (the new location is never guessed)",
     'adapter.pluginDataPathNotAllowed': 'the path is outside the range allowed for third-party plugin data and was refused: {path}',
     'adapter.pluginDataNoOsHome': 'third-party plugin data lives under the system home directory, but this host offers no file channel for it (older host): nothing is read or imported this time',
+    'adapter.pwMachinePathStripped': 'Stripped {count} pnpm setting(s) bound to machine-specific paths (they would point to non-existent directories on another machine): {keys}',
+    'adapter.pwMachinePathKept': "Kept this machine's own {count} pnpm path setting(s) (the source machine's paths are never carried over): {keys}",
+    'adapter.pwLocalReadFailed': "Failed to read the local pnpm-workspace.yaml: {reason} (nothing was written, so this machine's own pnpm path settings are not dropped)",
 };
 registerMessageCatalog({ id: 'adapters-domain', zh, en });
 /** 本域活翻译器（与 core 的 engineMsg 同一实现；导入本模块即完成目录注册）。 */

package/lib/adapters/plugin-files.js

@@ -106,7 +106,8 @@ export class PluginFilesAdapter {
     }
     /** 单元清单（零 I/O）：逐文件单元，id 与导入侧 `pluginFiles:<relPath>` 一致。 */
     listUnits(section) {
-        return unitsFromFiles(this.id, section.data.files, (rel) => rel);
+        // files 可能缺省（空分区 / 手写 section）：按空表处理，不抛错 —— 选择器对任何分区都会调 listUnits
+        return unitsFromFiles(this.id, section.data.files ?? [], (rel) => rel);
     }
     async analyzeImport(data, ctx) {
         const msg = ctx.msg;

package/lib/adapters/plugins.d.ts

@@ -72,6 +72,22 @@ export declare class PluginsAdapter implements ConfigAdapter<PluginsSection> {
      * 不做任何写入（写入在 applyItem 内、且先于 pnpm-workspace.yaml）。
      */
     private patchAvailability;
+    /**
+     * 读目标机 profile 的 `dsh.profile.bundles`（issue #95）。
+     *
+     * 相对路径与写入目标同源（`profiles/<profile>/package.json`），走 `ctx.target.fs` 而不是
+     * 宿主私有通道：与 pnpm-workspace.yaml / patch 文件同一条 I/O 纪律（受限、可被 MemFs 测试）。
+     */
+    private targetBundles;
+    /**
+     * 把 host 自带的层声明进目标机 profile 的 `dsh.profile.bundles`（issue #95）。
+     *
+     * 为什么**不走安装通道**：这类层的包由 DSH 从自己的安装位置解析；按裸包名 `dsh plugin add`
+     * 会把 npm `dist-tags.latest` 的副本装进 profile，与 host 的版本线脱节 —— 真机故障：
+     * host 0.2.1-rc.2 + 包 0.2.1-alpha.2 的隔离组契约对不上 → `session-controller` 一直 pending
+     * → 新建会话 service-unavailable。声明不了时只报非致命 warning（§34.17），不拖垮其余配置。
+     */
+    private declareHostBundle;
     analyzeImport(data: PluginsSection, ctx: ImportContext): Promise<PlanItem[]>;
     applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;
     validate(data: PluginsSection, msg?: MsgFunc): Promise<ValidationResult>;