@logictan/dsh-config-manager 0.1.60

package/lib/adapters/self.js

@@ -0,0 +1,71 @@
+/**
+ * self 分区 adapter（插件自身配置，设计「self 分区」）：
+ * 数据源 = $DSH_HOME/dsh-config-manager/ 下的插件自身配置文件（白名单收集，非递归）：
+ *   - sync/sync-config.json     同步通道配置（git repoUrl / webdav url+username；凭据值走 credentials 槽位，不含 secret）
+ *   - sync/sync-autosync.json   自动同步调度配置
+ *   - sync/sync-selection.json  同步分区选择（默认/高级模式 + 勾选分区）
+ *   - sync/ui-prefs.json        插件 UI 偏好（如上次选择的同步通道；从 localStorage 迁入）
+ *
+ * 排除项：sync/sync-history.json（执行记录，属数据非配置）、market/cache/（缓存）、
+ * snapshots/（快照）、tmp/ exports/（临时/导出产物）——只备份「配置」，不备份数据。
+ *
+ * 实现：继承 FileCollectionAdapter 复用 analyzeImport/applyItem/validate（幂等 hash 比对、
+ * 快照/回滚路径一致），仅覆写 export() 为白名单收集（self 目录内存在大量非配置子目录，
+ * 不能像 skills/sessions 那样整体递归）。
+ *
+ * relativePath 一律是「相对 baseDir」的路径（如 sync/sync-config.json），与
+ * FileCollectionAdapter 的基准目录语义一致：导入时按 path.join(baseDir, rel) 写回
+ * $DSH_HOME/dsh-config-manager/<rel>；ZIP 内位于 self/<rel>。
+ *
+ * 安全不变量：配置文件本身不含凭据值（同步凭据走 DSH credentials 槽位引用），
+ * 且文件类分区不进 SecretScanner（与 pluginFiles/skills 同语义）。
+ */
+import path from 'node:path';
+import { msgOf } from '../core/messages.js';
+import { sha256Hex } from '../utils/hashing.js';
+import { FileCollectionAdapter } from './file-collection.js';
+/** self 分区白名单文件（相对 baseDir，即 $DSH_HOME/dsh-config-manager/）。 */
+export const SELF_CONFIG_FILES = [
+    'sync/sync-config.json',
+    'sync/sync-autosync.json',
+    'sync/sync-selection.json',
+    'sync/ui-prefs.json',
+    // P0-④：导出产物备注清单（exports/.backup-notes.json）——随 self 分区迁移，
+    // 换机器后备份列表仍能看到手动导出时填写的备注
+    'exports/.backup-notes.json',
+];
+export class SelfAdapter extends FileCollectionAdapter {
+    id = 'self';
+    displayName = 'Plugin Self Config';
+    defaultIncluded = true;
+    portability = 'portable';
+    /** 插件自身配置目录（相对 homeDir；宿主按 dataDir 解析注入，缺省 dsh-config-manager） */
+    baseDir;
+    constructor(baseDir = 'dsh-config-manager') {
+        super();
+        this.baseDir = baseDir;
+    }
+    /** 白名单收集：只导出配置类文件（存在才收），不递归（排除快照/历史/缓存/临时产物）。
+     *  relativePath 产出相对 baseDir 的路径（与 analyzeImport/applyItem 的 path.join(baseDir, ref) 匹配）。 */
+    async export(ctx, _options) {
+        const files = [];
+        const warnings = [];
+        for (const rel of SELF_CONFIG_FILES) {
+            // ctx.fs.readFile 语义 = 相对 homeDir 的完整路径 → 拼接 baseDir；产出仍为相对 baseDir
+            const data = await ctx.fs.readFile(path.join(this.baseDir, rel)).catch(() => null);
+            if (data === null)
+                continue; // 未创建过的配置文件跳过（如从未配置市场/同步）
+            files.push({ relativePath: rel, data, contentHash: sha256Hex(data) });
+        }
+        if (files.length === 0) {
+            warnings.push(msgOf(ctx)('adapter.dirEmpty', { type: this.displayName }));
+        }
+        return {
+            sectionId: this.id,
+            data: { version: 1, files },
+            counts: { files: files.length },
+            warnings,
+        };
+    }
+}
+//# sourceMappingURL=self.js.map

package/lib/adapters/sessions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * sessions 分区 adapter（默认关，设计 §3.3/§15）：
+ * 数据源 = ~/.dsh/sessions/<projectKey>/<sessionId>/…（zstd jsonl，含敏感信息）。
+ * defaultIncluded=false：Quick Export 不包含，用户显式勾选才导出（v1 文件级复制）。
+ * 研究报告 §4.9：DSH 无会话批量导出 API，逐会话文件复制是唯一通道。
+ */
+import { FileCollectionAdapter } from './file-collection.ts';
+export declare class SessionsAdapter extends FileCollectionAdapter {
+    readonly id: 'sessions';
+    readonly displayName = "Sessions";
+    readonly defaultIncluded = false;
+    readonly portability: 'deviceSpecific';
+    readonly baseDir = "sessions";
+}

package/lib/adapters/sessions.js

@@ -0,0 +1,15 @@
+/**
+ * sessions 分区 adapter（默认关，设计 §3.3/§15）：
+ * 数据源 = ~/.dsh/sessions/<projectKey>/<sessionId>/…（zstd jsonl，含敏感信息）。
+ * defaultIncluded=false：Quick Export 不包含，用户显式勾选才导出（v1 文件级复制）。
+ * 研究报告 §4.9：DSH 无会话批量导出 API，逐会话文件复制是唯一通道。
+ */
+import { FileCollectionAdapter } from './file-collection.js';
+export class SessionsAdapter extends FileCollectionAdapter {
+    id = 'sessions';
+    displayName = 'Sessions';
+    defaultIncluded = false;
+    portability = 'deviceSpecific';
+    baseDir = 'sessions';
+}
+//# sourceMappingURL=sessions.js.map

package/lib/adapters/settings.d.ts

@@ -0,0 +1,28 @@
+import type { MsgFunc } from '../core/messages.ts';
+import type { NamespaceRecord, SettingsSection } from '../schema/types.ts';
+import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
+/** namespace 清单提供者：宿主从 settings.yaml 顶层 key / 插件注册表获得 */
+export type NamespaceProvider = (ctx: HostContext) => Promise<string[]> | string[];
+export declare function resolveNamespaces(namespaces: string[] | NamespaceProvider, ctx: HostContext): Promise<string[]>;
+/** 批量读取 namespace 的 redacted 记录（settings/ui 共用；单项失败跳过并告警） */
+export declare function collectNamespaceRecords(ctx: HostContext, names: string[], warnings: string[]): Promise<Record<string, NamespaceRecord>>;
+/** 值是否“空”（目标已注册但从未配置 → 视为待初始化，Create 而非 Conflict） */
+export declare function isEmptyValue(v: unknown): boolean;
+/** 对比导入记录与目标当前值：不存在 → Create；一致 → Skip；不同 → Conflict；
+ * 目标端 describe 抛错（命名空间未注册：提供它的插件在目标未激活/未安装）→ MissingDependency（§15 依赖检测），
+ * 此时 Create/Update 必然失败，标记为“需注意”让导入继续，而不是整体失败。纯计算，零写入。 */
+export declare function planNamespaceItems(data: Record<string, NamespaceRecord>, adapter: 'settings' | 'ui', ctx: ImportContext): Promise<PlanItem[]>;
+/** 写入单个 namespace（settings/ui 共用）：读时锁 + expectedRevision 乐观锁，防覆盖并发修改 */
+export declare function applyNamespaceItem(item: PlanItem, sectionId: 'settings' | 'ui', ctx: ImportContext): Promise<ApplyResult>;
+export declare class SettingsAdapter implements ConfigAdapter<SettingsSection> {
+    readonly id: 'settings';
+    readonly displayName = "Settings";
+    readonly defaultIncluded = true;
+    readonly portability: 'portable';
+    private readonly namespaces;
+    constructor(namespaces?: string[] | NamespaceProvider);
+    export(ctx: HostContext, _options: ExportOptions): Promise<ExportSection<SettingsSection>>;
+    analyzeImport(data: SettingsSection, ctx: ImportContext): Promise<PlanItem[]>;
+    applyItem(item: PlanItem, ctx: ImportContext): Promise<ApplyResult>;
+    validate(data: SettingsSection, msg?: MsgFunc): Promise<ValidationResult>;
+}

package/lib/adapters/settings.js

@@ -0,0 +1,165 @@
+/**
+ * settings 分区 adapter（设计 §3.3/§4.1/§4.2）：
+ * 数据源 = ~/.dsh/settings.yaml 中「非 UI 类」namespace（经 ctx.settings.describe({redactSecrets:true})）。
+ *
+ * 说明：DSH settings 服务没有「枚举全部 namespace」的 API（研究报告 §3.2），
+ * 因此 namespace 清单由宿主注入（真实实现可从 settings.yaml 顶层 key 解析）。
+ * 默认只导出名单内且不属于 UI 类（isUiNamespace）的 namespace，与 ui adapter 互斥并集 = 全部设置。
+ */
+import { isDeepStrictEqual } from 'node:util';
+import { msgOf, zhMsg } from '../core/messages.js';
+import { isUiNamespace } from './ui.js';
+export async function resolveNamespaces(namespaces, ctx) {
+    return typeof namespaces === 'function' ? namespaces(ctx) : namespaces;
+}
+/** 批量读取 namespace 的 redacted 记录（settings/ui 共用；单项失败跳过并告警） */
+export async function collectNamespaceRecords(ctx, names, warnings) {
+    const namespaces = {};
+    for (const name of names) {
+        try {
+            const info = await ctx.settings.describe(name, { redactSecrets: true });
+            namespaces[name] = {
+                value: info.value,
+                base: info.base,
+                revision: info.revision,
+                applies: info.applies,
+                secrets: info.secrets,
+            };
+        }
+        catch (err) {
+            warnings.push(msgOf(ctx)('adapter.settingsNsReadFailed', { name, reason: err instanceof Error ? err.message : String(err) }));
+        }
+    }
+    return namespaces;
+}
+/** 值是否“空”（目标已注册但从未配置 → 视为待初始化，Create 而非 Conflict） */
+export function isEmptyValue(v) {
+    if (v === undefined || v === null)
+        return true;
+    if (typeof v === 'object')
+        return Object.keys(v).length === 0;
+    return false;
+}
+/** 对比导入记录与目标当前值：不存在 → Create；一致 → Skip；不同 → Conflict；
+ * 目标端 describe 抛错（命名空间未注册：提供它的插件在目标未激活/未安装）→ MissingDependency（§15 依赖检测），
+ * 此时 Create/Update 必然失败，标记为“需注意”让导入继续，而不是整体失败。纯计算，零写入。 */
+export async function planNamespaceItems(data, adapter, ctx) {
+    const msg = ctx.msg;
+    const items = [];
+    for (const [name, rec] of Object.entries(data)) {
+        let current = null;
+        let targetUnavailable = false;
+        try {
+            current = await ctx.target.settings.describe(name, { redactSecrets: true });
+        }
+        catch {
+            // 目标连 describe 都失败 → 命名空间未注册（缺少提供插件）或目标不可读：
+            // 不能假定“不存在就创建”（replace 会同样失败），按依赖缺失处理。
+            targetUnavailable = true;
+        }
+        const id = `${adapter}:${name}`;
+        if (targetUnavailable) {
+            items.push({
+                id, kind: 'MissingDependency', adapter,
+                description: msg('adapter.settingsUnregistered', { ns: name }),
+                severity: 'warning', target: { adapter, ref: name },
+            });
+        }
+        else if (current === null || isEmptyValue(current.value)) {
+            // 目标已注册但从未配置（空值）→ 初始化（Create）
+            items.push({
+                id, kind: 'Create', adapter, description: msg('adapter.settingsCreate', { name }), severity: 'info',
+                target: { adapter, ref: name },
+            });
+        }
+        else if (isDeepStrictEqual(current.value, rec.value)) {
+            items.push({ id, kind: 'Skip', adapter, description: msg('adapter.settingsSame', { name }), severity: 'info' });
+        }
+        else {
+            items.push({
+                id, kind: 'Conflict', adapter, description: msg('adapter.settingsDiff', { name }),
+                detail: `current=${JSON.stringify(current.value)} imported=${JSON.stringify(rec.value)}`.slice(0, 200),
+                severity: 'warning', target: { adapter, ref: name },
+            });
+        }
+    }
+    return items;
+}
+/** 写入单个 namespace（settings/ui 共用）：读时锁 + expectedRevision 乐观锁，防覆盖并发修改 */
+export async function applyNamespaceItem(item, sectionId, ctx) {
+    const ref = item.target?.ref;
+    if (!ref)
+        return { ok: false, message: ctx.msg('adapter.missingTargetRef') };
+    const data = ctx.sections.get(sectionId);
+    const rec = data?.namespaces?.[ref];
+    if (!rec)
+        return { ok: false, message: ctx.msg('adapter.namespaceMissing', { ref }) };
+    // 写入前读当前 revision 作为 expectedRevision（读时锁）：目标不存在（Create）则不带锁提交
+    let expected;
+    try {
+        expected = (await ctx.target.settings.describe(ref, { redactSecrets: true })).revision;
+    }
+    catch {
+        expected = undefined;
+    }
+    await ctx.target.settings.replace(ref, rec.value, expected);
+    return { ok: true };
+}
+export class SettingsAdapter {
+    id = 'settings';
+    displayName = 'Settings';
+    defaultIncluded = true;
+    portability = 'portable';
+    namespaces;
+    constructor(namespaces = []) {
+        this.namespaces = namespaces;
+    }
+    async export(ctx, _options) {
+        const warnings = [];
+        const all = await resolveNamespaces(this.namespaces, ctx);
+        const nonUi = all.filter((n) => !isUiNamespace(n));
+        if (nonUi.length === 0)
+            warnings.push(msgOf(ctx)('adapter.noSettingsNamespaces'));
+        const namespaces = await collectNamespaceRecords(ctx, nonUi, warnings);
+        return {
+            sectionId: 'settings',
+            data: { version: 1, namespaces },
+            counts: { namespaces: Object.keys(namespaces).length },
+            warnings,
+        };
+    }
+    async analyzeImport(data, ctx) {
+        return planNamespaceItems(data.namespaces, 'settings', ctx);
+    }
+    async applyItem(item, ctx) {
+        return applyNamespaceItem(item, 'settings', 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: 'settings' }), 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' });
+        }
+        else {
+            for (const [name, rec] of Object.entries(data.namespaces)) {
+                if (rec === null || typeof rec !== 'object') {
+                    issues.push({ path: `namespaces.${name}`, message: msg('adapter.validate.recordObject', { subject: 'namespace' }), severity: 'error' });
+                    continue;
+                }
+                if (typeof rec.revision !== 'number') {
+                    issues.push({ path: `namespaces.${name}.revision`, message: msg('adapter.validate.number', { subject: 'revision' }), severity: 'error' });
+                }
+                if (!('value' in rec)) {
+                    issues.push({ path: `namespaces.${name}.value`, message: msg('adapter.validate.missingValue'), severity: 'error' });
+                }
+            }
+        }
+        return { valid: issues.filter((i) => i.severity === 'error').length === 0, issues };
+    }
+}
+//# sourceMappingURL=settings.js.map

package/lib/adapters/skills.d.ts

@@ -0,0 +1,13 @@
+/**
+ * skills 分区 adapter（设计 §3.3）：
+ * 数据源 = ~/.dsh/skills/（flat .md + 目录 bundle；dsh-skill-filesystem 发现）。
+ * 仅迁移用户主目录技能；~/.agents/skills、项目级技能默认不迁（研究报告 §2.2）。
+ */
+import { FileCollectionAdapter } from './file-collection.ts';
+export declare class SkillsAdapter extends FileCollectionAdapter {
+    readonly id: 'skills';
+    readonly displayName = "Skills";
+    readonly defaultIncluded = true;
+    readonly portability: 'portable';
+    readonly baseDir = "skills";
+}

package/lib/adapters/skills.js

@@ -0,0 +1,14 @@
+/**
+ * skills 分区 adapter（设计 §3.3）：
+ * 数据源 = ~/.dsh/skills/（flat .md + 目录 bundle；dsh-skill-filesystem 发现）。
+ * 仅迁移用户主目录技能；~/.agents/skills、项目级技能默认不迁（研究报告 §2.2）。
+ */
+import { FileCollectionAdapter } from './file-collection.js';
+export class SkillsAdapter extends FileCollectionAdapter {
+    id = 'skills';
+    displayName = 'Skills';
+    defaultIncluded = true;
+    portability = 'portable';
+    baseDir = 'skills';
+}
+//# sourceMappingURL=skills.js.map

package/lib/adapters/test-helpers.d.ts

@@ -0,0 +1,125 @@
+import { type Logger } from '../utils/logger.ts';
+import { sha256Hex } from '../utils/hashing.ts';
+import type { CredentialsFacade, FileSystemFacade, HostContext, ImportContext, NamespaceInfo, PatchFileFacade, PluginInfo, PluginsFacade, SettingsFacade, Snapshot, SnapshotStore, WorkspaceFacade } from '../core/types.ts';
+import type { Manifest, WorkspaceRecord } from '../schema/types.ts';
+export declare class MemFs implements FileSystemFacade {
+    files: Map<string, Uint8Array<ArrayBufferLike>>;
+    /** 可选（issue #37）：详细的链接遍历。测试按需注入；缺省走 listRecursive 回退路径。 */
+    listRecursiveDetailed?: FileSystemFacade['listRecursiveDetailed'];
+    private readonly homeDir;
+    constructor(homeDir: string);
+    private key;
+    readFile(relPath: string): Promise<Uint8Array>;
+    writeFile(relPath: string, data: Uint8Array): Promise<void>;
+    exists(relPath: string): Promise<boolean>;
+    copy(from: string, to: string): Promise<void>;
+    remove(relPath: string): Promise<void>;
+    listRecursive(dir: string): Promise<string[]>;
+    mkdir(): Promise<void>;
+}
+/** ns.set 时自动注册（有值即视为对应插件已激活；对齐真实 dsh-settings 的注册语义） */
+declare class AutoRegisterMap extends Map<string, {
+    value: unknown;
+    base?: unknown;
+    revision: number;
+    applies?: string[];
+    secrets: {
+        path: string[];
+        set: boolean;
+    }[];
+}> {
+    private readonly registered;
+    constructor(registered: Set<string>);
+    set(key: string, value: {
+        value: unknown;
+        base?: unknown;
+        revision: number;
+        applies?: string[];
+        secrets: {
+            path: string[];
+            set: boolean;
+        }[];
+    }): this;
+}
+export declare class MemSettings implements SettingsFacade {
+    /** 已注册命名空间（对齐真实 dsh-settings：插件激活时注册；未注册的 describe/replace 抛错） */
+    registered: Set<string>;
+    /** 有值的命名空间自动视为已注册 */
+    ns: AutoRegisterMap;
+    describe(namespace: string, _opts?: {
+        redactSecrets?: boolean;
+    }): Promise<NamespaceInfo>;
+    replace(namespace: string, value: unknown, expectedRevision?: number): Promise<void>;
+    update?(namespace: string, patch: unknown, expectedRevision?: number): Promise<void>;
+}
+export declare class MemCredentials implements CredentialsFacade {
+    values: Map<string, string>;
+    describe(ref: string): Promise<{
+        configured: boolean;
+        source?: string;
+        writable?: boolean;
+    }>;
+    set(ref: string, value: string): Promise<void>;
+    unset(ref: string): Promise<void>;
+}
+export declare class MemPlugins implements PluginsFacade {
+    installed: Map<string, PluginInfo>;
+    /** 测试钩子：install 抛错（模拟 npm ERESOLVE / 网络失败） */
+    failInstall: boolean;
+    /** 测试钩子：记录最近一次 install 收到的 spec（验证非 registry spec 透传） */
+    lastSpec: string | undefined;
+    listInstalled(): Promise<PluginInfo[]>;
+    install(pkg: string, spec?: string): Promise<{
+        needsRestart: boolean;
+    }>;
+}
+export declare class MemWorkspace implements WorkspaceFacade {
+    records: Map<string, WorkspaceRecord>;
+    listRecords(): Promise<WorkspaceRecord[]>;
+    writeRecord(r: WorkspaceRecord): Promise<void>;
+    removeRecord(id: string): Promise<void>;
+}
+export declare class MemPatch implements PatchFileFacade {
+    lines: Map<string, {
+        lineId: string;
+        raw: unknown;
+    }>;
+    readPatchLines(_file: string): Promise<{
+        lineId: string;
+        raw: unknown;
+    }[]>;
+    applyPatchChanges(_file: string, changes: {
+        lineId: string;
+        raw: unknown;
+        action: 'insert' | 'update' | 'remove';
+    }[]): Promise<void>;
+}
+export declare class MemSnapshotStore implements SnapshotStore {
+    snapshots: Map<string, Snapshot>;
+    blobs: Map<string, Uint8Array<ArrayBufferLike>>;
+    save(snapshot: Snapshot, blobs?: Map<string, Uint8Array>): Promise<string>;
+    load(id: string): Promise<Snapshot>;
+    readBlob(id: string, blobPath: string): Promise<Uint8Array>;
+    updateStatus(id: string, status: Snapshot['status']): Promise<void>;
+}
+export declare class MockHostContext implements HostContext {
+    platform: string;
+    arch: string;
+    homeDir: string;
+    dshVersion: string;
+    log: Logger;
+    profile?: string;
+    settings: MemSettings;
+    credentials: MemCredentials;
+    plugins: MemPlugins;
+    workspace: MemWorkspace;
+    patchFile: MemPatch;
+    fs: MemFs;
+    constructor(platform: string, homeDir: string, profile?: string);
+}
+export declare function makeContext(platform: string, homeDir: string, profile?: string): MockHostContext;
+/** 构造最小合法 manifest（adapter 单测用；真实 manifest 由 exporter 生成） */
+export declare function makeManifest(platform?: string): Manifest;
+/** 构造 ImportContext（adapter 单测用；sections 键运行时即 SectionId 字符串） */
+export declare function makeImportContext(target: HostContext, sections: ReadonlyMap<string, unknown>, overrides?: Partial<ImportContext>): ImportContext;
+export { sha256Hex };