@logictan/dsh-config-manager 0.1.60

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

@@ -0,0 +1,147 @@
+/**
+ * autosync-config 测试：sync-autosync.json 读写往返、缺省值、损坏 JSON 回退缺省、
+ * 按通道独立（git/webdav 互不干扰）、v1（顶层单通道）迁移为 git、原子写。
+ */
+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 {
+  readAutosyncConfig, writeAutosyncConfig, readAllAutosyncConfigs, AUTOSYNC_CONFIG_FILE,
+  AUTOSYNC_CONFIG_SCHEMA_VERSION, DEFAULT_AUTOSYNC_INTERVAL,
+  DEFAULT_STARTUP_MIN_INTERVAL_MS,
+} from './autosync-config.ts';
+
+test('writeAutosyncConfig + readAutosyncConfig：写入 → 读回字段一致（git 通道）', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-rt-'));
+  try {
+    await writeAutosyncConfig(dir, 'git', {
+      enabled: true,
+      interval: '15m',
+      startupMinIntervalMs: 300000,
+      consecutiveFailures: 2,
+      lastRunAt: '2026-08-16T12:00:00.000Z',
+      lastRunStatus: 'skipped',
+      lastRunMessage: '有冲突项，跳过',
+      lastRunHistoryId: 'hist-1',
+    });
+    const cfg = await readAutosyncConfig(dir, 'git');
+    assert.equal(cfg.enabled, true);
+    assert.equal(cfg.interval, '15m');
+    assert.equal(cfg.startupMinIntervalMs, 300000);
+    assert.equal(cfg.consecutiveFailures, 2);
+    assert.equal(cfg.lastRunAt, '2026-08-16T12:00:00.000Z');
+    assert.equal(cfg.lastRunStatus, 'skipped');
+    assert.equal(cfg.lastRunMessage, '有冲突项，跳过');
+    assert.equal(cfg.lastRunHistoryId, 'hist-1');
+    // 原始文件校验（v2 按通道）
+    const raw = JSON.parse(await fs.readFile(path.join(dir, AUTOSYNC_CONFIG_FILE), 'utf8'));
+    assert.equal(raw.schemaVersion, AUTOSYNC_CONFIG_SCHEMA_VERSION);
+    assert.equal(raw.channels.git.enabled, true);
+    assert.equal(raw.channels.git.interval, '15m');
+    assert.equal(raw.channels.webdav.enabled, false, '未配置的 webdav 通道落盘为缺省');
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readAutosyncConfig：文件不存在 → 返回缺省值（两个通道都缺省）', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-default-'));
+  try {
+    const cfg = await readAutosyncConfig(dir, 'git');
+    assert.equal(cfg.enabled, false);
+    assert.equal(cfg.interval, DEFAULT_AUTOSYNC_INTERVAL);
+    assert.equal(cfg.startupMinIntervalMs, DEFAULT_STARTUP_MIN_INTERVAL_MS);
+    assert.equal(cfg.consecutiveFailures, 0);
+    assert.equal(cfg.lastRunAt, undefined);
+    assert.equal(cfg.lastRunStatus, undefined);
+    const webdav = await readAutosyncConfig(dir, 'webdav');
+    assert.equal(webdav.enabled, false);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readAutosyncConfig：损坏 JSON → 回退缺省', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-corrupt-'));
+  try {
+    await fs.writeFile(path.join(dir, AUTOSYNC_CONFIG_FILE), '{not-json', 'utf8');
+    const cfg = await readAutosyncConfig(dir, 'git');
+    assert.equal(cfg.enabled, false);
+    assert.equal(cfg.interval, DEFAULT_AUTOSYNC_INTERVAL);
+    assert.equal(cfg.startupMinIntervalMs, DEFAULT_STARTUP_MIN_INTERVAL_MS);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('readAutosyncConfig：不支持的 schemaVersion → 回退缺省', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-badver-'));
+  try {
+    await fs.writeFile(path.join(dir, AUTOSYNC_CONFIG_FILE),
+      JSON.stringify({ schemaVersion: 99, enabled: true }), 'utf8');
+    const cfg = await readAutosyncConfig(dir, 'git');
+    assert.equal(cfg.enabled, false);
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('writeAutosyncConfig：原子写（自动创建目录）', async () => {
+  const base = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-mkdir-'));
+  try {
+    const dir = path.join(base, 'nested', 'sync');
+    await writeAutosyncConfig(dir, 'git', { enabled: true, interval: '30m', startupMinIntervalMs: 300000, consecutiveFailures: 0 });
+    const cfg = await readAutosyncConfig(dir, 'git');
+    assert.ok(cfg);
+    assert.equal(cfg.enabled, true);
+    // 确认没有残留临时文件
+    const files = await fs.readdir(dir);
+    assert.ok(files.length >= 1, '应有配置文件');
+    assert.ok(!files.some((f) => f.includes('.tmp')), '不应残留 .tmp 临时文件');
+  } finally { await fs.rm(base, { recursive: true, force: true }); }
+});
+
+test('按通道独立：写 webdav 不影响 git，反之亦然', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-perchannel-'));
+  try {
+    await writeAutosyncConfig(dir, 'git', { enabled: true, interval: '5m', startupMinIntervalMs: 300000, consecutiveFailures: 0 });
+    await writeAutosyncConfig(dir, 'webdav', { enabled: true, interval: '24h', startupMinIntervalMs: 300000, consecutiveFailures: 3, lastRunAt: '2026-08-16T12:00:00.000Z', lastRunStatus: 'failed' });
+    // git 通道保持首次写入的值
+    const git = await readAutosyncConfig(dir, 'git');
+    assert.equal(git.enabled, true);
+    assert.equal(git.interval, '5m');
+    assert.equal(git.consecutiveFailures, 0);
+    // webdav 通道独立
+    const webdav = await readAutosyncConfig(dir, 'webdav');
+    assert.equal(webdav.enabled, true);
+    assert.equal(webdav.interval, '24h');
+    assert.equal(webdav.consecutiveFailures, 3);
+    assert.equal(webdav.lastRunStatus, 'failed');
+    // 全量读取视图
+    const all = await readAllAutosyncConfigs(dir);
+    assert.equal(all.git.interval, '5m');
+    assert.equal(all.webdav.interval, '24h');
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});
+
+test('v1 迁移：顶层单通道字段 → git 通道（webdav 缺省）', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-autosync-v1-'));
+  try {
+    await fs.writeFile(
+      path.join(dir, AUTOSYNC_CONFIG_FILE),
+      JSON.stringify({ schemaVersion: 1, enabled: true, interval: '60m', consecutiveFailures: 1, lastRunAt: '2026-08-15T08:00:00.000Z' }),
+      'utf8',
+    );
+    const git = await readAutosyncConfig(dir, 'git');
+    assert.equal(git.enabled, true, 'v1 enabled 迁移到 git 通道');
+    assert.equal(git.interval, '60m');
+    assert.equal(git.consecutiveFailures, 1);
+    assert.equal(git.lastRunAt, '2026-08-15T08:00:00.000Z');
+    const webdav = await readAutosyncConfig(dir, 'webdav');
+    assert.equal(webdav.enabled, false, 'webdav 通道回退缺省');
+    // 缺 schemaVersion 的旧文件同样视为 v1
+    await fs.writeFile(
+      path.join(dir, AUTOSYNC_CONFIG_FILE),
+      JSON.stringify({ enabled: true, interval: '12h' }),
+      'utf8',
+    );
+    const git2 = await readAutosyncConfig(dir, 'git');
+    assert.equal(git2.enabled, true);
+    assert.equal(git2.interval, '12h');
+  } finally { await fs.rm(dir, { recursive: true, force: true }); }
+});

package/src/sync/autosync-config.ts

@@ -0,0 +1,179 @@
+/**
+ * m-autosync：自动同步配置持久化（sync-autosync.json）。
+ *
+ * 与 sync-config.json 并列独立文件：语义清楚、schema 演进独立。
+ * schemaVersion:2 —— 按同步通道拆分（git / webdav 各自独立的自动同步配置与运行状态）：
+ * ```
+ * { "schemaVersion": 2,
+ *   "channels": {
+ *     "git":    { enabled, interval, startupMinIntervalMs, consecutiveFailures, lastRunAt, ... },
+ *     "webdav": { ... } } }
+ * ```
+ * v1（顶层单通道）→ 读取时归一为 v2 的 git 通道（webdav 回退缺省）。
+ *
+ * 原子写（临时文件 + rename），损坏/不支持 schema 回退缺省（enabled=false,
+ * interval='30m', startupMinIntervalMs=5*60*1000）。
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+import type { SyncTransportType } from './sync-config.ts';
+import { parseJsonSafe, stringifyJsonSafe } from '../utils/json.ts';
+import { atomicWriteFile } from '../utils/atomic-write.ts';
+
+export const AUTOSYNC_CONFIG_FILE = 'sync-autosync.json';
+export const AUTOSYNC_CONFIG_SCHEMA_VERSION = 2;
+
+/** 统一间隔类型 */
+export type AutosyncInterval = '5m' | '15m' | '30m' | '60m' | '6h' | '12h' | '24h';
+
+/** 缺省间隔 */
+export const DEFAULT_AUTOSYNC_INTERVAL: AutosyncInterval = '30m';
+
+/** 缺省启动触发最小间隔阈值（5 分钟，防频繁重启反复同步） */
+export const DEFAULT_STARTUP_MIN_INTERVAL_MS = 5 * 60 * 1000;
+
+/** 最近一次自动同步执行状态 */
+export type AutosyncRunStatus = 'success' | 'skipped' | 'failed' | 'partial';
+
+/** 自动同步配置（持久化面；单通道） */
+export interface AutosyncConfig {
+  /** 总开关（同时控制上传 + 下载） */
+  enabled: boolean;
+  /** 统一间隔 */
+  interval: AutosyncInterval;
+  /** 重启触发的「自动下载合并」最小间隔阈值（ms） */
+  startupMinIntervalMs: number;
+  /** 连续失败计数（用于通知判定） */
+  consecutiveFailures: number;
+  /** 最近一次自动同步执行时间（ISO-8601 UTC）；''/undefined = 从未执行 */
+  lastRunAt?: string;
+  /** 最近一次自动同步执行状态 */
+  lastRunStatus?: AutosyncRunStatus;
+  lastRunMessage?: string;
+  /** 最近一次自动同步触发的同步历史条目 id */
+  lastRunHistoryId?: string;
+}
+
+/** 全通道配置视图（v2 文件直接读取；status 路由一次返回两个通道的状态）。 */
+export type AutosyncConfigByChannel = Record<SyncTransportType, AutosyncConfig>;
+
+/** 缺省配置（首次无文件 / 损坏 / 不支持 schema 时回退） */
+export function defaultAutosyncConfig(): AutosyncConfig {
+  return {
+    enabled: false,
+    interval: DEFAULT_AUTOSYNC_INTERVAL,
+    startupMinIntervalMs: DEFAULT_STARTUP_MIN_INTERVAL_MS,
+    consecutiveFailures: 0,
+  };
+}
+
+/** 从 v1 顶层字段（缺 schemaVersion 或 schemaVersion=1）解析单通道配置；非法字段回退缺省。 */
+function parseV1Channel(obj: Record<string, unknown>): AutosyncConfig {
+  const cfg = defaultAutosyncConfig();
+  if (typeof obj['enabled'] === 'boolean') cfg.enabled = obj['enabled'];
+  if (isAutosyncInterval(obj['interval'])) cfg.interval = obj['interval'];
+  if (typeof obj['startupMinIntervalMs'] === 'number' && Number.isFinite(obj['startupMinIntervalMs']) && obj['startupMinIntervalMs'] > 0) {
+    cfg.startupMinIntervalMs = obj['startupMinIntervalMs'];
+  }
+  if (typeof obj['consecutiveFailures'] === 'number' && Number.isFinite(obj['consecutiveFailures']) && obj['consecutiveFailures'] >= 0) {
+    cfg.consecutiveFailures = obj['consecutiveFailures'];
+  }
+  if (typeof obj['lastRunAt'] === 'string' && obj['lastRunAt'] !== '') cfg.lastRunAt = obj['lastRunAt'];
+  if (typeof obj['lastRunStatus'] === 'string' && (obj['lastRunStatus'] === 'success' || obj['lastRunStatus'] === 'skipped' || obj['lastRunStatus'] === 'failed' || obj['lastRunStatus'] === 'partial')) {
+    cfg.lastRunStatus = obj['lastRunStatus'];
+  }
+  if (typeof obj['lastRunMessage'] === 'string') cfg.lastRunMessage = obj['lastRunMessage'];
+  if (typeof obj['lastRunHistoryId'] === 'string') cfg.lastRunHistoryId = obj['lastRunHistoryId'];
+  return cfg;
+}
+
+/** 从 v2 channels 命名空间解析单通道配置；缺失/非法 → 缺省。 */
+function parseV2Channel(ns: unknown): AutosyncConfig {
+  if (ns === null || typeof ns !== 'object' || Array.isArray(ns)) return defaultAutosyncConfig();
+  return parseV1Channel(ns as Record<string, unknown>);
+}
+
+/** 读取全部通道的自动同步配置（v2 文件；v1 迁移为 git；webdav 缺省）。 */
+export async function readAllAutosyncConfigs(dir: string): Promise<AutosyncConfigByChannel> {
+  const file = path.join(dir, AUTOSYNC_CONFIG_FILE);
+  let raw: string;
+  try {
+    raw = await fs.readFile(file, 'utf8');
+  } catch {
+    return { git: defaultAutosyncConfig(), webdav: defaultAutosyncConfig() };
+  }
+  let parsed: unknown;
+  try {
+    parsed = parseJsonSafe(raw);
+  } catch {
+    return { git: defaultAutosyncConfig(), webdav: defaultAutosyncConfig() };
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return { git: defaultAutosyncConfig(), webdav: defaultAutosyncConfig() };
+  }
+  const obj = parsed as Record<string, unknown>;
+  // schemaVersion：缺省视为 v1；非缺省但 != 2 → 回退缺省
+  const ver = typeof obj['schemaVersion'] === 'number' ? obj['schemaVersion'] : 1;
+  if (ver !== 1 && ver !== AUTOSYNC_CONFIG_SCHEMA_VERSION) {
+    return { git: defaultAutosyncConfig(), webdav: defaultAutosyncConfig() };
+  }
+  if (ver === 1) {
+    // v1 迁移：顶层字段 → git 通道（webdav 缺省；首次按 v2 写回时持久化）
+    return { git: parseV1Channel(obj), webdav: defaultAutosyncConfig() };
+  }
+  const channels = obj['channels'];
+  const ch = channels !== null && typeof channels === 'object' && !Array.isArray(channels)
+    ? channels as Record<string, unknown>
+    : {};
+  return {
+    git: parseV2Channel(ch['git']),
+    webdav: parseV2Channel(ch['webdav']),
+  };
+}
+
+/** 读取指定通道的自动同步配置；文件不存在 / 损坏 / 不支持 schema → 缺省值（不抛错）。 */
+export async function readAutosyncConfig(dir: string, channel: SyncTransportType): Promise<AutosyncConfig> {
+  const all = await readAllAutosyncConfigs(dir);
+  return all[channel];
+}
+
+/** 写入指定通道的自动同步配置（原子写：临时文件 + rename；保留另一通道；自动创建目录）。 */
+export async function writeAutosyncConfig(dir: string, channel: SyncTransportType, cfg: AutosyncConfig): Promise<void> {
+  await fs.mkdir(dir, { recursive: true });
+  const existing = await readAllAutosyncConfigs(dir);
+  const channels: Record<SyncTransportType, AutosyncConfig> = {
+    git: channel === 'git' ? cfg : existing.git,
+    webdav: channel === 'webdav' ? cfg : existing.webdav,
+  };
+  const payload: Record<string, unknown> = {
+    schemaVersion: AUTOSYNC_CONFIG_SCHEMA_VERSION,
+    channels: {
+      git: toChannelPayload(channels.git),
+      webdav: toChannelPayload(channels.webdav),
+    },
+  };
+  const target = path.join(dir, AUTOSYNC_CONFIG_FILE);
+  const data = stringifyJsonSafe(payload, { space: 2 });
+  await atomicWriteFile(target, data, { mode: 0o600 });
+}
+
+/** AutosyncConfig → 文件载荷（可选运行字段仅在非空时写入，保持文件干净）。 */
+function toChannelPayload(cfg: AutosyncConfig): Record<string, unknown> {
+  const payload: Record<string, unknown> = {
+    enabled: cfg.enabled,
+    interval: cfg.interval,
+    startupMinIntervalMs: cfg.startupMinIntervalMs,
+    consecutiveFailures: cfg.consecutiveFailures,
+  };
+  if (cfg.lastRunAt !== undefined && cfg.lastRunAt !== '') payload['lastRunAt'] = cfg.lastRunAt;
+  if (cfg.lastRunStatus !== undefined) payload['lastRunStatus'] = cfg.lastRunStatus;
+  if (cfg.lastRunMessage !== undefined && cfg.lastRunMessage !== '') payload['lastRunMessage'] = cfg.lastRunMessage;
+  if (cfg.lastRunHistoryId !== undefined && cfg.lastRunHistoryId !== '') payload['lastRunHistoryId'] = cfg.lastRunHistoryId;
+  return payload;
+}
+
+function isAutosyncInterval(v: unknown): v is AutosyncInterval {
+  return v === '5m' || v === '15m' || v === '30m' || v === '60m' || v === '6h' || v === '12h' || v === '24h';
+}