@logictan/dsh-config-manager 0.1.60

package/lib/adapters/test-helpers.js

@@ -0,0 +1,236 @@
+/**
+ * 适配器测试基础设施（仿 src/core/smoke.test.ts 的内存 mock 门面）。
+ * 仅供 src/adapters/*.test.ts 使用，不参与生产构建语义。
+ */
+import { normalizePath } from '../utils/paths.js';
+import { createLogger } from '../utils/logger.js';
+import { sha256Hex } from '../utils/hashing.js';
+import { zhMsg } from '../core/messages.js';
+export class MemFs {
+    files = new Map();
+    /** 可选（issue #37）：详细的链接遍历。测试按需注入；缺省走 listRecursive 回退路径。 */
+    listRecursiveDetailed;
+    homeDir;
+    constructor(homeDir) {
+        this.homeDir = homeDir;
+    }
+    key(p) {
+        return normalizePath(p.startsWith(this.homeDir) ? p : `${this.homeDir}/${p}`);
+    }
+    async readFile(relPath) {
+        const v = this.files.get(this.key(relPath));
+        if (v === undefined)
+            throw new Error(`ENOENT: ${relPath}`);
+        return v;
+    }
+    async writeFile(relPath, data) {
+        this.files.set(this.key(relPath), data);
+    }
+    async exists(relPath) {
+        return this.files.has(this.key(relPath));
+    }
+    async copy(from, to) {
+        const v = this.files.get(this.key(from));
+        if (v === undefined)
+            throw new Error(`ENOENT: ${from}`);
+        this.files.set(this.key(to), v);
+    }
+    async remove(relPath) {
+        this.files.delete(this.key(relPath));
+    }
+    async listRecursive(dir) {
+        const base = normalizePath(this.homeDir);
+        const prefix = normalizePath(dir) === '' ? base : `${base}/${normalizePath(dir)}`;
+        const out = [];
+        for (const k of this.files.keys()) {
+            if (k === prefix || k.startsWith(prefix + '/')) {
+                out.push(k.slice(base.length).replace(/^[\\/]+/, ''));
+            }
+        }
+        return out.sort();
+    }
+    async mkdir() { }
+}
+/** ns.set 时自动注册（有值即视为对应插件已激活；对齐真实 dsh-settings 的注册语义） */
+class AutoRegisterMap extends Map {
+    registered;
+    constructor(registered) {
+        super();
+        this.registered = registered;
+    }
+    set(key, value) {
+        this.registered.add(key);
+        return super.set(key, value);
+    }
+}
+export class MemSettings {
+    /** 已注册命名空间（对齐真实 dsh-settings：插件激活时注册；未注册的 describe/replace 抛错） */
+    registered = new Set();
+    /** 有值的命名空间自动视为已注册 */
+    ns = new AutoRegisterMap(this.registered);
+    async describe(namespace, _opts) {
+        if (!this.registered.has(namespace))
+            throw new Error(`settings namespace "${namespace}" is not registered`);
+        const rec = this.ns.get(namespace);
+        return {
+            value: rec?.value,
+            base: rec?.base,
+            revision: rec?.revision ?? 0,
+            applies: rec?.applies,
+            secrets: rec?.secrets ?? [],
+        };
+    }
+    async replace(namespace, value, expectedRevision) {
+        if (!this.registered.has(namespace))
+            throw new Error(`settings namespace "${namespace}" is not registered`);
+        const rec = this.ns.get(namespace);
+        if (expectedRevision !== undefined && rec && rec.revision !== expectedRevision) {
+            throw new Error(`SETTINGS_CONFLICT: ${namespace} revision ${rec.revision} !== ${expectedRevision}`);
+        }
+        this.ns.set(namespace, {
+            value, revision: (rec?.revision ?? 0) + 1, secrets: rec?.secrets ?? [], base: rec?.base, applies: rec?.applies,
+        });
+    }
+    async update(namespace, patch, expectedRevision) {
+        if (!this.registered.has(namespace))
+            throw new Error(`settings namespace "${namespace}" is not registered`);
+        const rec = this.ns.get(namespace);
+        if (expectedRevision !== undefined && rec && rec.revision !== expectedRevision) {
+            throw new Error(`SETTINGS_CONFLICT: ${namespace} revision ${rec.revision} !== ${expectedRevision}`);
+        }
+        const merged = { ...rec?.value, ...patch };
+        this.ns.set(namespace, { value: merged, revision: (rec?.revision ?? 0) + 1, secrets: rec?.secrets ?? [] });
+    }
+}
+export class MemCredentials {
+    values = new Map();
+    async describe(ref) {
+        const v = this.values.get(ref);
+        return { configured: v !== undefined, source: v !== undefined ? 'file' : 'env', writable: true };
+    }
+    async set(ref, value) { this.values.set(ref, value); }
+    async unset(ref) { this.values.delete(ref); }
+}
+export class MemPlugins {
+    installed = new Map();
+    /** 测试钩子：install 抛错（模拟 npm ERESOLVE / 网络失败） */
+    failInstall = false;
+    /** 测试钩子：记录最近一次 install 收到的 spec（验证非 registry spec 透传） */
+    lastSpec;
+    async listInstalled() {
+        return [...this.installed.values()];
+    }
+    async install(pkg, spec) {
+        if (this.failInstall)
+            throw new Error(`npm error code ERESOLVE: could not resolve ${pkg}`);
+        if (this.installed.has(pkg))
+            return { needsRestart: false };
+        this.lastSpec = spec;
+        this.installed.set(pkg, { name: pkg, version: '1.0.0', enabled: true, spec });
+        return { needsRestart: true };
+    }
+}
+export class MemWorkspace {
+    records = new Map();
+    async listRecords() { return [...this.records.values()]; }
+    async writeRecord(r) { this.records.set(r.id, r); }
+    async removeRecord(id) { this.records.delete(id); }
+}
+export class MemPatch {
+    lines = new Map();
+    async readPatchLines(_file) {
+        return [...this.lines.values()];
+    }
+    async applyPatchChanges(_file, changes) {
+        for (const c of changes) {
+            if (c.action === 'remove')
+                this.lines.delete(c.lineId);
+            else
+                this.lines.set(c.lineId, { lineId: c.lineId, raw: c.raw });
+        }
+    }
+}
+export class MemSnapshotStore {
+    snapshots = new Map();
+    blobs = new Map();
+    async save(snapshot, blobs = new Map()) {
+        this.snapshots.set(snapshot.id, snapshot);
+        for (const [k, v] of blobs)
+            this.blobs.set(`${snapshot.id}/${k}`, v);
+        return snapshot.id;
+    }
+    async load(id) {
+        const s = this.snapshots.get(id);
+        if (!s)
+            throw new Error(`snapshot not found: ${id}`);
+        return s;
+    }
+    async readBlob(id, blobPath) {
+        const v = this.blobs.get(`${id}/${blobPath}`);
+        if (!v)
+            throw new Error(`blob not found: ${id}/${blobPath}`);
+        return v;
+    }
+    async updateStatus(id, status) {
+        const s = this.snapshots.get(id);
+        if (!s)
+            throw new Error(`snapshot not found: ${id}`);
+        s.status = status;
+    }
+}
+export class MockHostContext {
+    platform;
+    arch = 'x64';
+    homeDir;
+    dshVersion = '0.1.0-rc.6';
+    log;
+    profile;
+    settings = new MemSettings();
+    credentials = new MemCredentials();
+    plugins = new MemPlugins();
+    workspace = new MemWorkspace();
+    patchFile = new MemPatch();
+    fs;
+    constructor(platform, homeDir, profile) {
+        this.platform = platform;
+        this.homeDir = homeDir;
+        this.profile = profile;
+        this.fs = new MemFs(homeDir);
+        this.log = createLogger({ level: 'error', sink: () => { } });
+    }
+}
+export function makeContext(platform, homeDir, profile) {
+    return new MockHostContext(platform, homeDir, profile);
+}
+/** 构造最小合法 manifest（adapter 单测用；真实 manifest 由 exporter 生成） */
+export function makeManifest(platform = 'win32') {
+    return {
+        schemaVersion: 1,
+        exporter: { name: 'dsh-config-manager-test', version: '0.0.0' },
+        source: { dshVersion: '0.1.0-rc.6', platform: platform, arch: 'x64' },
+        exportedAt: new Date('2026-08-14T12:00:00.000Z').toISOString(),
+        sections: {
+            settings: false, ui: false, providers: false, plugins: false, mcp: false, prompts: false,
+            skills: false, agentPresets: false, agentInstructions: false, workspaces: false, pluginFiles: false,
+            credentialsStatus: false, secrets: false, sessions: false, self: false,
+        },
+        security: { containsSecrets: false, encrypted: false, encryption: null },
+    };
+}
+/** 构造 ImportContext（adapter 单测用；sections 键运行时即 SectionId 字符串） */
+export function makeImportContext(target, sections, overrides = {}) {
+    return {
+        manifest: makeManifest(target.platform),
+        targetPlatform: target.platform,
+        target,
+        sections: sections,
+        pathMappings: [],
+        resolutions: {},
+        secretInputs: {},
+        log: target.log,
+        msg: zhMsg,
+        ...overrides,
+    };
+}
+export { sha256Hex };
+//# sourceMappingURL=test-helpers.js.map

package/lib/adapters/ui.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ui 分区 adapter（设计 §3.3/§4.1/§4.3）：
+ * 数据源 = settings.yaml 中「UI 类」namespace（pet / dsh-better-sidebar / remote-web-ui / ui-onboarding / skin 等）。
+ * localStorage 等 Host 不可迁移的 UI 状态以 uiMigrationNotes 纯说明形式导出（不含任何值）。
+ */
+import type { UiSection } 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 NamespaceProvider } from './settings.ts';
+/** UI 类 namespace 前缀名单（设计 §4.1；随新插件扩展，只影响「某一 namespace 归哪一边」，不影响数据完整性） */
+export declare const KNOWN_UI_NAMESPACE_PREFIXES: readonly string[];
+/** namespace 名是否属于 UI 类（大小写不敏感前缀匹配） */
+export declare function isUiNamespace(name: string): boolean;
+/** localStorage 等 Host 无通道的 UI 状态说明（纯说明，不含值；研究报告 §2.2/§4.4） */
+export declare const UI_MIGRATION_NOTES: UiSection['uiMigrationNotes'];
+export declare class UiAdapter implements ConfigAdapter<UiSection> {
+    readonly id: 'ui';
+    readonly displayName = "UI Preferences";
+    readonly defaultIncluded = true;
+    readonly portability: 'portable';
+    private readonly namespaces;
+    constructor(namespaces?: string[] | NamespaceProvider);
+    export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<UiSection>>;
+    analyzeImport(data: UiSection, ctx: ImportContext): Promise<PlanItem[]>;
+    applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;
+    validate(data: UiSection, msg?: MsgFunc): Promise<ValidationResult>;
+}

package/lib/adapters/ui.js

@@ -0,0 +1,89 @@
+import { zhMsg } from '../core/messages.js';
+import { collectNamespaceRecords, planNamespaceItems, applyNamespaceItem, resolveNamespaces } from './settings.js';
+/** UI 类 namespace 前缀名单（设计 §4.1；随新插件扩展，只影响「某一 namespace 归哪一边」，不影响数据完整性） */
+export const KNOWN_UI_NAMESPACE_PREFIXES = [
+    'pet',
+    'dsh-better-sidebar',
+    'remote-web-ui',
+    'ui-onboarding',
+    'dsh-client-ui',
+    'skin',
+    'theme',
+    'layout',
+    'sidebar',
+    'appearance',
+];
+/** namespace 名是否属于 UI 类（大小写不敏感前缀匹配） */
+export function isUiNamespace(name) {
+    const lower = name.toLowerCase();
+    return KNOWN_UI_NAMESPACE_PREFIXES.some((p) => lower.startsWith(p.toLowerCase()));
+}
+/** localStorage 等 Host 无通道的 UI 状态说明（纯说明，不含值；研究报告 §2.2/§4.4） */
+export const UI_MIGRATION_NOTES = [
+    {
+        plugin: 'dsh-task-board',
+        storage: 'localStorage',
+        key: 'dsh.taskBoard.v1',
+        migratable: false,
+        reason: '任务看板数据存于浏览器 localStorage，Host 侧无访问通道，需在目标机器重新配置',
+    },
+    {
+        plugin: 'dsh-aionui-panel',
+        storage: 'localStorage',
+        key: 'aionui-panel.*',
+        migratable: false,
+        reason: '面板宽度/折叠状态存于浏览器 localStorage，Host 侧无访问通道，需在目标机器重新配置',
+    },
+    {
+        plugin: 'dsh-client-ui-*',
+        storage: 'localStorage',
+        key: '*',
+        migratable: false,
+        reason: '浏览器端 UI 状态无法经 Host API 迁移',
+    },
+];
+export class UiAdapter {
+    id = 'ui';
+    displayName = 'UI Preferences';
+    defaultIncluded = true;
+    portability = 'portable';
+    namespaces;
+    constructor(namespaces = []) {
+        this.namespaces = namespaces;
+    }
+    async export(ctx, _options) {
+        const warnings = [];
+        const all = await resolveNamespaces(this.namespaces, ctx);
+        const uiNames = all.filter((n) => isUiNamespace(n));
+        const namespaces = await collectNamespaceRecords(ctx, uiNames, warnings);
+        return {
+            sectionId: 'ui',
+            data: { version: 1, namespaces, uiMigrationNotes: UI_MIGRATION_NOTES },
+            counts: { namespaces: Object.keys(namespaces).length, notes: UI_MIGRATION_NOTES.length },
+            warnings,
+        };
+    }
+    async analyzeImport(data, ctx) {
+        return planNamespaceItems(data.namespaces, 'ui', ctx);
+    }
+    async applyItem(item, ctx) {
+        return applyNamespaceItem(item, 'ui', ctx);
+    }
+    async validate(data, msg = zhMsg) {
+        const issues = [];
+        if (data === null || typeof data !== 'object') {
+            return { valid: false, issues: [{ path: '$', message: msg('adapter.validate.object', { subject: 'ui' }), severity: 'error' }] };
+        }
+        if (data.version !== 1) {
+            issues.push({ path: 'version', message: msg('adapter.validate.version', { value: String(data.version) }), severity: 'error' });
+        }
+        if (data.namespaces === null || typeof data.namespaces !== 'object') {
+            issues.push({ path: 'namespaces', message: msg('adapter.validate.missingObject', { subject: 'namespaces' }), severity: 'error' });
+        }
+        if (data.uiMigrationNotes !== undefined && !Array.isArray(data.uiMigrationNotes)) {
+            issues.push({ path: 'uiMigrationNotes', message: msg('adapter.validate.array', { subject: 'uiMigrationNotes' }), severity: 'error' });
+        }
+        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+    }
+}
+//# sourceMappingURL=ui.js.map

package/lib/adapters/workspaces.d.ts

@@ -0,0 +1,13 @@
+import type { MsgFunc } from '../core/messages.ts';
+import type { WorkspacesSection } from '../schema/types.ts';
+import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
+export declare class WorkspacesAdapter implements ConfigAdapter<WorkspacesSection> {
+    readonly id: 'workspaces';
+    readonly displayName = "Workspaces";
+    readonly defaultIncluded = true;
+    readonly portability: 'platformSpecific';
+    export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<WorkspacesSection>>;
+    analyzeImport(data: WorkspacesSection, ctx: ImportContext): Promise<PlanItem[]>;
+    applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;
+    validate(data: WorkspacesSection, msg?: MsgFunc): Promise<ValidationResult>;
+}

package/lib/adapters/workspaces.js

@@ -0,0 +1,106 @@
+/**
+ * workspaces 分区 adapter（设计 §3.3/§11）：
+ * 数据源 = ~/.dsh/storages/workspace.json 的 tables.workspaces（经 ctx.workspace 门面）。
+ * workspace.path 为绝对路径 → 跨设备必须 PathMapping（analyzeImport 生成 PathMapping 项，
+ * 映射由引擎 PathMapper 先行应用到 sections，applyItem 拿到的已是映射后数据）。
+ */
+import { isDeepStrictEqual } from 'node:util';
+import { zhMsg } from '../core/messages.js';
+export class WorkspacesAdapter {
+    id = 'workspaces';
+    displayName = 'Workspaces';
+    defaultIncluded = true;
+    portability = 'platformSpecific';
+    async export(ctx, _options) {
+        const records = await ctx.workspace.listRecords();
+        return {
+            sectionId: 'workspaces',
+            data: { version: 1, workspaces: records },
+            counts: { workspaces: records.length },
+            warnings: [],
+        };
+    }
+    async analyzeImport(data, ctx) {
+        const msg = ctx.msg;
+        const items = [];
+        for (const rec of data.workspaces) {
+            const id = `workspace:${rec.id}`;
+            const existing = (await ctx.target.workspace.listRecords()).find((r) => r.id === rec.id);
+            if (!existing) {
+                items.push({
+                    id, kind: 'Create', adapter: 'workspaces',
+                    description: msg('adapter.workspaceCreate', { title: rec.title ?? rec.id, path: rec.path }), severity: 'info',
+                    target: { adapter: 'workspaces', ref: rec.id },
+                });
+            }
+            else if (isDeepStrictEqual(existing, rec)) {
+                items.push({ id, kind: 'Skip', adapter: 'workspaces', description: msg('adapter.workspaceSame', { id: rec.id }), severity: 'info' });
+            }
+            else {
+                items.push({
+                    id, kind: 'Conflict', adapter: 'workspaces',
+                    description: msg('adapter.workspaceDiff', { id: rec.id }),
+                    detail: `current=${JSON.stringify(existing)} imported=${JSON.stringify(rec)}`.slice(0, 200),
+                    severity: 'warning', target: { adapter: 'workspaces', ref: rec.id },
+                });
+            }
+            // 绝对路径 → 路径映射提示（oldPrefix 先用整条路径占位，newPrefix 由 UI 确认）
+            if (rec.path.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(rec.path)) {
+                items.push({
+                    id: `${id}:path`, kind: 'PathMapping', adapter: 'workspaces',
+                    description: msg('adapter.workspacePathMapping', { path: rec.path }), severity: 'warning',
+                    pathMapping: { oldPrefix: rec.path, newPrefix: '', appliesTo: ['workspaces'] },
+                    target: { adapter: 'workspaces', ref: rec.id },
+                });
+            }
+        }
+        return items;
+    }
+    async applyItem(item, ctx) {
+        // PathMapping 项：数据已由 PathMapper 应用到 sections，无需额外写入
+        if (item.kind === 'PathMapping')
+            return { ok: true };
+        const ref = item.target?.ref;
+        if (!ref)
+            return { ok: false, message: ctx.msg('adapter.missingTargetRef') };
+        const data = ctx.sections.get('workspaces');
+        const rec = data?.workspaces.find((r) => r.id === ref);
+        if (!rec)
+            return { ok: false, message: ctx.msg('adapter.workspaceMissing', { ref }) };
+        try {
+            await ctx.target.workspace.writeRecord(rec);
+            return { ok: true };
+        }
+        catch (err) {
+            // 目标端无法写入（如路径 realpath 失败/目录不存在）→ 非致命警告（§34.17），
+            // 不触发整体回滚——否则一个失效路径会拖垮已成功导入的其余配置。
+            const reason = err instanceof Error ? err.message : String(err);
+            return {
+                ok: false,
+                warning: true,
+                message: ctx.msg('adapter.workspaceWriteFailed', { ref, msg: reason }),
+            };
+        }
+    }
+    async validate(data, msg = zhMsg) {
+        const issues = [];
+        if (data === null || typeof data !== 'object') {
+            return { valid: false, issues: [{ path: '$', message: msg('adapter.validate.object', { subject: 'workspaces' }), severity: 'error' }] };
+        }
+        if (data.version !== 1) {
+            issues.push({ path: 'version', message: msg('adapter.validate.version', { value: String(data.version) }), severity: 'error' });
+        }
+        if (!Array.isArray(data.workspaces)) {
+            issues.push({ path: 'workspaces', message: msg('adapter.validate.array', { subject: 'workspaces' }), severity: 'error' });
+        }
+        else {
+            for (const w of data.workspaces) {
+                if (w === null || typeof w !== 'object' || typeof w.id !== 'string' || typeof w.path !== 'string') {
+                    issues.push({ path: 'workspaces[]', message: msg('adapter.validate.workspaceIdentity'), severity: 'error' });
+                }
+            }
+        }
+        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+    }
+}
+//# sourceMappingURL=workspaces.js.map