dsh-config-manager 0.1.19 → 0.1.21

package/src/sync/risk.test.ts

@@ -0,0 +1,131 @@
+/**
+ * m-sync-flow：分级自动应用策略测试。
+ * 覆盖：风险映射、首次强制预览、决策分流、形状 contract、互斥分组。
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { SECTION_RISK_TIER, classifyMergePlan, summarizeApplyPlan } from './risk.ts';
+import type { MergePlan, MergeSectionResult } from './merge.ts';
+
+const sec = (
+  id: MergeSectionResult['id'],
+  decision: MergeSectionResult['decision'],
+  merged?: MergeSectionResult['merged'],
+  conflicts: MergeSectionResult['conflicts'] = [],
+): MergeSectionResult => ({ id, decision, conflicts, ...(merged !== undefined ? { merged } : {}) });
+
+test('SECTION_RISK_TIER：规划表约定的映射正确', () => {
+  assert.equal(SECTION_RISK_TIER.settings, 'low');
+  assert.equal(SECTION_RISK_TIER.ui, 'low');
+  assert.equal(SECTION_RISK_TIER.providers, 'low');
+  assert.equal(SECTION_RISK_TIER.prompts, 'low');
+  assert.equal(SECTION_RISK_TIER.workspaces, 'medium');
+  assert.equal(SECTION_RISK_TIER.plugins, 'medium');
+  assert.equal(SECTION_RISK_TIER.mcp, 'medium');
+  assert.equal(SECTION_RISK_TIER.credentialsStatus, 'high');
+  assert.equal(SECTION_RISK_TIER.secrets, 'high');
+});
+
+test('classifyMergePlan：firstSync=false 时低风险 useRemote/keepLocal → autoApply', () => {
+  const plan: MergePlan = { sections: [
+    sec('settings', 'useRemote', { version: 1, namespaces: {} }),
+    sec('providers', 'useRemote', { version: 1, providers: {} }),
+  ]};
+  const out = classifyMergePlan(plan, { firstSync: false });
+  assert.equal(out.autoApply.length, 2);
+  assert.equal(out.review.length, 0);
+  assert.equal(out.skipped.length, 0);
+});
+
+test('classifyMergePlan：firstSync=false 时中风险 → review', () => {
+  const plan: MergePlan = { sections: [
+    sec('workspaces', 'useRemote', { version: 1, workspaces: [] }),
+    sec('plugins', 'keepLocal', { version: 1, plugins: [], patch: [] }),
+    sec('mcp', 'useRemote', { version: 1, servers: [] }),
+  ]};
+  const out = classifyMergePlan(plan, { firstSync: false });
+  assert.equal(out.autoApply.length, 0);
+  assert.equal(out.review.length, 3);
+  assert.equal(out.skipped.length, 0);
+});
+
+test('classifyMergePlan：firstSync=false 时 high → review（永不自动）', () => {
+  const plan: MergePlan = { sections: [
+    sec('credentialsStatus', 'useRemote', { version: 1, credentials: [] }),
+    sec('secrets', 'keepLocal', { version: 1, files: [] } as MergeSectionResult['merged']),
+  ]};
+  const out = classifyMergePlan(plan, { firstSync: false });
+  assert.equal(out.autoApply.length, 0);
+  assert.equal(out.review.length, 2);
+});
+
+test('classifyMergePlan：双向冲突永远进 review（无论 firstSync）', () => {
+  const plan: MergePlan = { sections: [
+    sec('settings', 'conflict', undefined, [{ path: 'general', kind: 'key' }]),
+  ]};
+  assert.equal(classifyMergePlan(plan, { firstSync: false }).review.length, 1);
+  assert.equal(classifyMergePlan(plan, { firstSync: true }).review.length, 1);
+});
+
+test('classifyMergePlan：firstSync=true 时所有非 skip 项一律进 review', () => {
+  const plan: MergePlan = { sections: [
+    sec('settings', 'useRemote', { version: 1, namespaces: {} }),
+    sec('providers', 'keepLocal', { version: 1, providers: {} }),
+    sec('workspaces', 'useRemote', { version: 1, workspaces: [] }),
+    sec('settings', 'skip'), // 重复测试：skip 永远进 skipped
+  ]};
+  const out = classifyMergePlan(plan, { firstSync: true });
+  assert.equal(out.review.length, 3, '低+中风险全部进 review');
+  assert.equal(out.autoApply.length, 0);
+  assert.equal(out.skipped.length, 1);
+});
+
+test('classifyMergePlan：决策为 skip → skipped（与 firstSync 无关）', () => {
+  const plan: MergePlan = { sections: [sec('settings', 'skip')] };
+  assert.equal(classifyMergePlan(plan, { firstSync: false }).skipped.length, 1);
+  assert.equal(classifyMergePlan(plan, { firstSync: true }).skipped.length, 1);
+});
+
+test('classifyMergePlan：同一 section 不出现在多个分组', () => {
+  const plan: MergePlan = { sections: [
+    sec('settings', 'useRemote', { version: 1, namespaces: {} }),
+    sec('providers', 'skip'),
+    sec('workspaces', 'conflict', undefined, [{ path: '$', kind: 'key' }]),
+    sec('mcp', 'keepLocal', { version: 1, servers: [] }),
+  ]};
+  const out = classifyMergePlan(plan, { firstSync: false });
+  const seen = new Set<string>();
+  for (const bucket of [out.autoApply, out.review, out.skipped]) {
+    for (const r of bucket) {
+      assert.ok(!seen.has(r.id), `section ${r.id} 出现在多个分组`);
+      seen.add(r.id);
+    }
+  }
+  assert.equal(out.autoApply.length, 1, 'settings → autoApply');
+  assert.equal(out.review.length, 2, 'workspaces conflict + mcp medium → review');
+  assert.equal(out.skipped.length, 1, 'providers skip → skipped');
+});
+
+test('classifyMergePlan：输出 SyncApplyPlan 形状符合 contract', () => {
+  const plan: MergePlan = { sections: [] };
+  const out = classifyMergePlan(plan, { firstSync: false });
+  assert.ok(Array.isArray(out.autoApply));
+  assert.ok(Array.isArray(out.review));
+  assert.ok(Array.isArray(out.skipped));
+});
+
+test('summarizeApplyPlan：计数正确', () => {
+  const plan: MergePlan = { sections: [
+    sec('settings', 'useRemote', { version: 1, namespaces: {} }),
+    sec('providers', 'useRemote', { version: 1, providers: {} }),
+    sec('workspaces', 'useRemote', { version: 1, workspaces: [] }),
+    sec('settings', 'skip'),
+  ]};
+  const apply = classifyMergePlan(plan, { firstSync: false });
+  const sum = summarizeApplyPlan(apply);
+  assert.equal(sum.autoApplyCount, 2);
+  assert.equal(sum.reviewCount, 1);
+  assert.equal(sum.skippedCount, 1);
+  assert.equal(sum.totalCount, 4);
+});

package/src/sync/risk.ts

@@ -0,0 +1,122 @@
+/**
+ * m-sync-flow：分级自动应用策略 + 首次强制预览（纯函数）。
+ *
+ * 数据源：P2a 的 MergePlan（每分区 decision + conflicts）。
+ * 产出：SyncApplyPlan 三组（autoApply / review / skipped），供 SyncEngine.applyMergePlan 与 UI 使用。
+ *
+ * 规则：
+ *  - SECTION_RISK_TIER 把每个 SectionId 静态归类到 low / medium / high；
+ *  - 双向 conflict 分区永远进 review（无论风险与 firstSync 与否）；
+ *  - firstSync=true 时所有非 skip 项一律进 review（安全第一：人工确认后才开启自动）；
+ *  - firstSync=false 时按风险等级分流：低风险且 useRemote/keepLocal 进 autoApply；
+ *    中风险、high、双向冲突 → review；skip 或无变化 → skipped。
+ */
+import type { MergePlan, MergeSectionResult } from './merge.ts';
+import type { SectionId } from '../schema/types.ts';
+
+/** 分区风险等级（驱动自动应用 vs 待审） */
+export type RiskTier = 'low' | 'medium' | 'high';
+
+/**
+ * 分区风险映射（v1 静态表；可后续接入适配器声明的 risk 字段动态化）。
+ * - low    ：低风险——自动应用（无冲突时）
+ *   settings / ui / providers / prompts
+ * - medium ：中风险——待审队列（路径映射、安装、变更）
+ *   workspaces / plugins / mcp
+ * - high   ：高风险——永不自动（含双向冲突、设备专属、凭据/秘密）
+ *   credentialsStatus / secrets / sessions / pluginFiles / workspaces? 不，
+ *   按规划表 workspaces 归 medium（中风险），credentialsStatus/secrets 归 high；
+ *   agentPresets / skills 暂归 low（受 sync 通道的 portable 过滤实际不会携带 skills）。
+ */
+export const SECTION_RISK_TIER: Readonly<Record<SectionId, RiskTier>> = {
+  settings: 'low',
+  ui: 'low',
+  providers: 'low',
+  prompts: 'low',
+  workspaces: 'medium',
+  plugins: 'medium',
+  mcp: 'medium',
+  skills: 'low',
+  agentPresets: 'low',
+  pluginFiles: 'high',
+  sessions: 'high',
+  credentialsStatus: 'high',
+  secrets: 'high',
+};
+
+export interface ClassifyOptions {
+  /**
+   * true = 首次同步：所有非 skip 项一律进 review（无论风险等级）；
+   * false（默认）= 按风险等级分流。
+   * 调用方在 SyncEngine 中维护 firstSyncCompleted 标志。
+   */
+  firstSync: boolean;
+}
+
+/** 自动应用三组结果（互斥：同一 sectionId 只出现在一组） */
+export interface SyncApplyPlan {
+  autoApply: MergeSectionResult[];
+  review: MergeSectionResult[];
+  skipped: MergeSectionResult[];
+}
+
+/**
+ * 按风险等级 + firstSync 标志将 MergePlan 分流到三组。
+ * 纯函数：相同输入 → 相同输出；不读 fs、不发网络。
+ */
+export function classifyMergePlan(plan: MergePlan, opts: ClassifyOptions): SyncApplyPlan {
+  const autoApply: MergeSectionResult[] = [];
+  const review: MergeSectionResult[] = [];
+  const skipped: MergeSectionResult[] = [];
+  for (const r of plan.sections) {
+    // 跳过：决策为 skip（远端缺且本地未改 / 完全无变化）
+    if (r.decision === 'skip') {
+      skipped.push(r);
+      continue;
+    }
+    // 双向冲突永远进 review（最高优先级）
+    if (r.decision === 'conflict') {
+      review.push(r);
+      continue;
+    }
+    // 首次同步强制预览：所有非 skip 项一律进 review
+    if (opts.firstSync) {
+      review.push(r);
+      continue;
+    }
+    const tier = SECTION_RISK_TIER[r.id];
+    // 未知分区（防御性）一律进 review 而非自动应用
+    if (tier === undefined) {
+      review.push(r);
+      continue;
+    }
+    if (tier === 'low') {
+      // 低风险且决策明确（useRemote / keepLocal）→ 自动应用
+      autoApply.push(r);
+    } else {
+      // medium / high → 待审
+      review.push(r);
+    }
+  }
+  return { autoApply, review, skipped };
+}
+
+/**
+ * 分流摘要计数（供 UI 徽章显示）。
+ * 同一函数复用：纯函数无副作用。
+ */
+export interface SyncApplySummary {
+  autoApplyCount: number;
+  reviewCount: number;
+  skippedCount: number;
+  totalCount: number;
+}
+
+export function summarizeApplyPlan(apply: SyncApplyPlan): SyncApplySummary {
+  return {
+    autoApplyCount: apply.autoApply.length,
+    reviewCount: apply.review.length,
+    skippedCount: apply.skipped.length,
+    totalCount: apply.autoApply.length + apply.review.length + apply.skipped.length,
+  };
+}

package/src/sync/sync-config.test.ts

@@ -0,0 +1,106 @@
+/**
+ * m-sync-ui：sync-config.json schemaVersion 迁移与往返测试。
+ * - 写入 schemaVersion=1 + 字段；读回字段一致。
+ * - 旧文件无 schemaVersion 字段视为 v1 兼容读取。
+ * - 不支持的 schemaVersion 抛错（返回 null）。
+ * - 损坏 JSON 返回 null（不静默降级）。
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  readSyncConfig, writeSyncConfig, SYNC_CONFIG_FILE, SYNC_CONFIG_SCHEMA_VERSION,
+} from './sync-config.ts';
+
+test('writeSyncConfig + readSyncConfig：写入 schemaVersion=1 + repoUrl/gitBin → 读回字段一致', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-rt-'));
+  try {
+    await writeSyncConfig(dir, { repoUrl: 'git@github.com:foo/bar.git', gitBin: '/usr/bin/git' });
+    const loaded = await readSyncConfig(dir);
+    assert.deepEqual(loaded, { repoUrl: 'git@github.com:foo/bar.git', gitBin: '/usr/bin/git' });
+    const raw = JSON.parse(await fs.readFile(path.join(dir, SYNC_CONFIG_FILE), 'utf8'));
+    assert.equal(raw.schemaVersion, SYNC_CONFIG_SCHEMA_VERSION);
+    assert.equal(raw.repoUrl, 'git@github.com:foo/bar.git');
+    assert.equal(raw.gitBin, '/usr/bin/git');
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('writeSyncConfig：未传 gitBin 时不写入字段（保持文件精简）', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-nogitbin-'));
+  try {
+    await writeSyncConfig(dir, { repoUrl: 'git@github.com:foo/bar.git' });
+    const raw = JSON.parse(await fs.readFile(path.join(dir, SYNC_CONFIG_FILE), 'utf8'));
+    assert.equal(raw.repoUrl, 'git@github.com:foo/bar.git');
+    assert.equal(raw.gitBin, undefined);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readSyncConfig：旧文件无 schemaVersion 字段 → 视为 v1 兼容读取', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-legacy-'));
+  try {
+    // 旧版（无 schemaVersion 字段）
+    await fs.writeFile(
+      path.join(dir, SYNC_CONFIG_FILE),
+      JSON.stringify({ repoUrl: 'git@github.com:foo/bar.git', gitBin: '/bin/git' }),
+      'utf8',
+    );
+    const loaded = await readSyncConfig(dir);
+    assert.deepEqual(loaded, { repoUrl: 'git@github.com:foo/bar.git', gitBin: '/bin/git' });
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readSyncConfig：不支持的 schemaVersion → 返回 null（拒绝）', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-badver-'));
+  try {
+    await fs.writeFile(
+      path.join(dir, SYNC_CONFIG_FILE),
+      JSON.stringify({ schemaVersion: 99, repoUrl: 'git@github.com:foo/bar.git' }),
+      'utf8',
+    );
+    const loaded = await readSyncConfig(dir);
+    assert.equal(loaded, null);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readSyncConfig：schemaVersion 字段非数字 → 返回 null', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-badtype-'));
+  try {
+    await fs.writeFile(
+      path.join(dir, SYNC_CONFIG_FILE),
+      JSON.stringify({ schemaVersion: 'v1', repoUrl: 'git@github.com:foo/bar.git' }),
+      'utf8',
+    );
+    const loaded = await readSyncConfig(dir);
+    assert.equal(loaded, null);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readSyncConfig：损坏 JSON → 返回 null', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-badjson-'));
+  try {
+    await fs.writeFile(path.join(dir, SYNC_CONFIG_FILE), '{not-json', 'utf8');
+    const loaded = await readSyncConfig(dir);
+    assert.equal(loaded, null);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readSyncConfig：文件不存在 → 返回 null（视为未配置）', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-missing-'));
+  try {
+    const loaded = await readSyncConfig(dir);
+    assert.equal(loaded, null);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('writeSyncConfig：自动创建目录', async () => {
+  const base = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-mkdir-'));
+  try {
+    const dir = path.join(base, 'nested', 'sync');
+    await writeSyncConfig(dir, { repoUrl: 'git@github.com:foo/bar.git' });
+    const loaded = await readSyncConfig(dir);
+    assert.ok(loaded);
+  } finally { await fs.rm(base, { recursive: true, force: true }); }
+});

package/src/sync/sync-config.ts

@@ -16,13 +16,19 @@ import { parseJsonSafe, stringifyJsonSafe } from '../utils/json.ts';
 
 export const SYNC_CONFIG_FILE = 'sync-config.json';
 
+/** 当前 sync-config.json schema 版本号。 */
+export const SYNC_CONFIG_SCHEMA_VERSION = 1;
+/** 历史可读取版本：v1 缺 schemaVersion 字段做兼容读取（视为 v1）。 */
+export const SYNC_CONFIG_SUPPORTED_VERSIONS: readonly number[] = [1];
+
 /** 持久化的仓库配置（不含任何凭据） */
 export interface SyncConfig {
   repoUrl: string;
   gitBin?: string;
 }
 
-/** 读取仓库配置；文件不存在/损坏 → null（视为未配置，UI 显示空表单） */
+/** 读取仓库配置；文件不存在/损坏/不支持 schema → null（视为未配置，UI 显示空表单）。
+ * 兼容旧文件：缺 schemaVersion 字段视为 v1（保留字段）。 */
 export async function readSyncConfig(dir: string): Promise<SyncConfig | null> {
   const file = path.join(dir, SYNC_CONFIG_FILE);
   let raw: string;
@@ -31,19 +37,32 @@ export async function readSyncConfig(dir: string): Promise<SyncConfig | null> {
   } catch {
     return null;
   }
-  const parsed = parseJsonSafe(raw);
+  let parsed: unknown;
+  try {
+    parsed = parseJsonSafe(raw);
+  } catch {
+    // 损坏 JSON / 体积超限 / 嵌套过深 → 视为未配置（不抛错）
+    return null;
+  }
   if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
   const obj = parsed as Record<string, unknown>;
+  // schemaVersion：缺省视为 v1（兼容旧文件）；非缺省但不在支持列表 → 拒绝
+  if (obj['schemaVersion'] !== undefined && typeof obj['schemaVersion'] !== 'number') {
+    return null;
+  }
+  const ver = typeof obj['schemaVersion'] === 'number' ? obj['schemaVersion'] : 1;
+  if (!SYNC_CONFIG_SUPPORTED_VERSIONS.includes(ver)) return null;
   if (typeof obj['repoUrl'] !== 'string' || obj['repoUrl'] === '') return null;
   const cfg: SyncConfig = { repoUrl: obj['repoUrl'] };
   if (typeof obj['gitBin'] === 'string' && obj['gitBin'] !== '') cfg.gitBin = obj['gitBin'];
   return cfg;
 }
 
-/** 保存仓库配置（自动创建目录；覆盖旧值） */
+/** 保存仓库配置（自动创建目录；覆盖旧值；写 schemaVersion=1） */
 export async function writeSyncConfig(dir: string, cfg: SyncConfig): Promise<void> {
   await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(path.join(dir, SYNC_CONFIG_FILE), stringifyJsonSafe(cfg, { space: 2 }), 'utf8');
+  const payload = { schemaVersion: SYNC_CONFIG_SCHEMA_VERSION, repoUrl: cfg.repoUrl, ...(cfg.gitBin !== undefined && cfg.gitBin !== '' ? { gitBin: cfg.gitBin } : {}) };
+  await fs.writeFile(path.join(dir, SYNC_CONFIG_FILE), stringifyJsonSafe(payload, { space: 2 }), 'utf8');
 }
 
 /**