ygc-dsh-sync 1.0.2 → 1.2.0

package/lib/features.js

@@ -0,0 +1,409 @@
+/**
+ * 本机特征文件夹（`<工作区>/.dsh-sync/sessions/<本机标识>/`）的采纳、撤销与「谁参与」判定。
+ *
+ * 用户 2026-11-14 定的规矩（这一层是这套规矩的唯一实现）：
+ *
+ *   1. **检测到的匹配目录要人点**：巡检扫出「符合插件结构、但本机还没建特征文件夹」
+ *      的目录时，只列出来问人，绝不自己建。人点了同意 → 建格子 + 注册成工作区
+ *      （进侧边栏，参与备份与拉取），一次做完。
+ *   2. **新建的保持原样**：本机新建的共享工作区默认就带特征文件夹
+ *      （1.1.0 之前一直是这个行为，升级不能把它改成必须点一下）。
+ *   3. **外部删掉会自愈**：曾经建过、现在磁盘上没有 → 巡检自动补建，不进人工队列。
+ *   4. **删工作区就删格**：本机把某个工作区从侧边栏删掉后，它的特征文件夹跟着删。
+ *      只删本机那一格，别人的格子一个字节都不动。
+ *   5. **没格子的不干活**：备份、拉取、自动备份、自动拉取、补登记，
+ *      一律只对「特征文件夹存在」的工作区生效。
+ *
+ * 判据永远是磁盘：「特征文件夹存在」= 已参与。state 里只记三样辅助信息：
+ *   initialized  1.2.0 首次运行是否已经把「存量工作区」归过档
+ *   decisions    人对某个路径的表态（adopt / decline），防止反复骚扰
+ *   known        已经采纳过的工作区（id → 路径），用来判「被删除」与「被外部删除」
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { TARGET_DIR_NAME, normSlash, ownRoot, pathKey, safeStat } from './core.js';
+
+/* --------------------------------------------------------------- 基础判定 */
+
+/** 本机特征文件夹的绝对路径（就是写边界里那个 ownRoot）。 */
+export function featurePath(workspacePath, machineId) {
+  return ownRoot(workspacePath, machineId);
+}
+
+/** 特征文件夹是否已存在（必须真的是目录）。 */
+export function hasFeature(workspacePath, machineId) {
+  const st = safeStat(featurePath(workspacePath, machineId));
+  return !!st && st.isDirectory();
+}
+
+/**
+ * 建本机特征文件夹。
+ *
+ * 只建 `<工作区>/.dsh-sync/sessions/<本机标识>/` 这一格，
+ * 不碰别人的目录，也不动任何会话文件。
+ */
+export function adoptFeature(workspacePath, machineId) {
+  if (!machineId) throw new Error('缺少本机标识，拒绝建特征文件夹');
+  const target = featurePath(workspacePath, machineId);
+  // 防 machineId 里带 `..` 或分隔符把目标打穿到别处
+  if (path.basename(target) !== String(machineId)) {
+    throw new Error(`特征文件夹名与本机标识不一致：${target}`);
+  }
+  fs.mkdirSync(target, { recursive: true });
+  return target;
+}
+
+/**
+ * 删本机特征文件夹（删工作区时调用）。
+ *
+ * 三条约束：
+ *   - 只删本机那一格；
+ *   - `sessions/` 里还有别人的备份时，`sessions/` 与 `.dsh-sync/` 一概不动；
+ *   - 目标不存在算成功（幂等）。
+ */
+export function dropFeature(workspacePath, machineId, { log = () => {} } = {}) {
+  if (!machineId) return { removed: false, reason: '缺少本机标识' };
+  const target = featurePath(workspacePath, machineId);
+  if (path.basename(target) !== String(machineId)) {
+    return { removed: false, reason: '目标不是本机特征文件夹' };
+  }
+  const st = safeStat(target);
+  if (!st) return { removed: false, reason: '本来就没有' };
+  if (!st.isDirectory()) return { removed: false, reason: '不是目录' };
+  fs.rmSync(target, { recursive: true, force: true });
+  log(`删除本机特征文件夹 ${target}`);
+
+  // 收尾：空了才收，避免把别人的备份目录一起删掉
+  const sessionsDir = path.join(normSlash(workspacePath), TARGET_DIR_NAME);
+  const dshSyncDir = path.dirname(sessionsDir);
+  for (const dir of [sessionsDir, dshSyncDir]) {
+    try {
+      if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+    } catch {
+      /* 收尾失败不影响主结果 */
+    }
+  }
+  return { removed: true, target };
+}
+
+/* ----------------------------------------------------------- 决策与基线 */
+
+/** 决策键：路径的大小写不敏感写法（Windows 下同一个目录只有一份）。 */
+const keyOf = (p) => {
+  try {
+    return pathKey(p);
+  } catch {
+    return String(p || '').toLowerCase();
+  }
+};
+
+/** 人为某个路径表过态吗？返回 'adopt' | 'decline' | 'ask' | null。 */
+export function decisionOf(state, workspacePath) {
+  const bag = (state && state.features && state.features.decisions) || {};
+  const hit = bag[keyOf(workspacePath)];
+  if (!hit) return null;
+  if (hit.action === 'decline') return 'decline';
+  if (hit.action === 'ask') return 'ask';
+  return 'adopt';
+}
+
+/**
+ * 记一次表态。
+ *
+ *   adopt    人点了「建格子」（之后缺了就自动补）
+ *   decline  人点了「不要」（之后只列出来，不自动建）
+ *   ask      已经在面板上问过人、还等回话 —— 不写这一条，下一轮巡检
+ *            会把「等待表态」误当成「本机新建」，直接替人建了格子。
+ */
+export function rememberDecision(state, workspacePath, action) {
+  if (!state.features || typeof state.features !== 'object') {
+    state.features = { initialized: false, decisions: {}, known: {} };
+  }
+  if (!state.features.decisions || typeof state.features.decisions !== 'object') {
+    state.features.decisions = {};
+  }
+  const normalized = action === 'decline' ? 'decline' : action === 'ask' ? 'ask' : 'adopt';
+  state.features.decisions[keyOf(workspacePath)] = {
+    action: normalized,
+    path: normSlash(workspacePath),
+    at: Date.now(),
+  };
+  return state;
+}
+
+/** 清掉某路径的表态（人后来又把格子建回来时用）。 */
+export function forgetDecision(state, workspacePath) {
+  const bag = (state.features && state.features.decisions) || null;
+  if (!bag) return state;
+  delete bag[keyOf(workspacePath)];
+  return state;
+}
+
+/* --------------------------------------------------------------- 巡检计划 */
+
+/**
+ * 算本轮该对特征文件夹做什么。**纯函数：不落盘、不改任何文件。**
+ *
+ * 输入：
+ *   folders     特定文件夹前缀
+ *   workspaces  当前工作区清单（id/path/title）
+ *   discover    巡检扫出、但还没注册成工作区的目录（{path,title,folder}）
+ *   state       插件状态（读 features.initialized / known / decisions）
+ *   machineId   本机标识
+ *
+ * 输出：
+ *   active   已有格子、正常参与备份与拉取的工作区
+ *   adopt    本机新建的工作区 → **默认建格子**（保持 1.1.0 原有设置）
+ *   restore  曾经建过、现在磁盘上没有 → 自动补建（被外部删掉的自愈）
+ *   drop     本机已删除的工作区 → 跟着删格子
+ *   pending  必须人工表态的：未注册的匹配目录，以及升级时检出的存量工作区
+ *   seed     首次运行需要把「已有格子」的存量工作区记进基线（不改任何文件）
+ */
+export function planFeatures({
+  folders = [],
+  workspaces = [],
+  discover = [],
+  state = {},
+  machineId = '',
+} = {}) {
+  const features = (state && state.features) || {};
+  const known = features.known || {};
+  const initialized = features.initialized === true;
+  const seenNow = {};
+  const adopt = [];
+  const restore = [];
+  const drop = [];
+  const pending = [];
+  const active = [];
+  const seed = [];
+
+  const underFolders = (p) => {
+    const key = keyOf(p);
+    return (folders || []).some((f) => {
+      const fk = keyOf(f);
+      return key === fk || key.startsWith(fk + path.sep) || key.startsWith(fk + '/');
+    });
+  };
+
+  for (const ws of workspaces || []) {
+    if (!ws || !ws.path) continue;
+    const id = ws.id === undefined || ws.id === null ? keyOf(ws.path) : String(ws.id);
+    seenNow[id] = normSlash(ws.path);
+    const entry = { id, path: ws.path, title: ws.title || path.basename(ws.path) };
+
+    if (hasFeature(ws.path, machineId)) {
+      active.push(entry);
+      // 已有格子的一律进基线：首次运行靠它建档，之后靠它判「被删除」
+      seed.push(entry);
+      continue;
+    }
+
+    // 缺格子：不在特定文件夹里的本来就不归本插件管，不建也不问
+    if (!underFolders(ws.path)) continue;
+
+    const wasKnown = Object.prototype.hasOwnProperty.call(known, id);
+    const said = decisionOf(state, ws.path);
+    if (said === 'decline') {
+      // 人说过不要 → 仍然列出来（可以改主意），但不自己建
+      pending.push({ ...entry, why: 'declined' });
+    } else if (said === 'ask') {
+      // 已经在面板上问过、还没回话 → 继续等着，别替人决定
+      pending.push({ ...entry, why: 'awaiting' });
+    } else if (said === 'adopt' || wasKnown) {
+      // 人点过同意 / 曾经建过又没了 → 自动补
+      restore.push({ ...entry, why: wasKnown ? 'vanished' : 'adopted' });
+    } else if (!initialized) {
+      // 1.2.0 首次运行：存量工作区，交给人决定
+      pending.push({ ...entry, why: 'existing' });
+    } else {
+      // 基线建档之后才出现 = 本机新建的，默认建格子
+      adopt.push({ ...entry, why: 'new' });
+    }
+  }
+
+  // 匹配目录里还没注册成工作区的：必须人工选择（同意后建格子 + 注册一起做）
+  for (const d of discover || []) {
+    if (!d || !d.path) continue;
+    if (decisionOf(state, d.path) === 'decline') continue;
+    if (hasFeature(d.path, machineId)) continue;
+    pending.push({
+      id: null,
+      path: d.path,
+      title: d.title || path.basename(d.path),
+      why: 'unregistered',
+    });
+  }
+
+  // 基线里、这一轮清单里没有的 = 本机删了工作区 → 跟着删格子
+  for (const [id, p] of Object.entries(known)) {
+    if (Object.prototype.hasOwnProperty.call(seenNow, id)) continue;
+    if (!p) continue;
+    if (!hasFeature(p, machineId)) continue;
+    drop.push({ id, path: p, title: path.basename(p) });
+  }
+
+  return { active, adopt, restore, drop, pending, seed, seenNow };
+}
+
+/**
+ * 把「本轮列进 pending 问人的」记成 ask，避免下一轮被当成「本机新建」。
+ *
+ * 只对「已注册工作区缺格子」这一类记（why = existing / awaiting），
+ * 未注册的匹配目录本来就不会自动处理，不必额外打标。
+ */
+export function markAsked(state, plan) {
+  if (!state.features) state.features = { initialized: false, decisions: {}, known: {} };
+  let n = 0;
+  for (const item of (plan && plan.pending) || []) {
+    if (item.why !== 'existing' && item.why !== 'awaiting') continue;
+    if (decisionOf(state, item.path) === 'ask') continue;
+    rememberDecision(state, item.path, 'ask');
+    n++;
+  }
+  return n;
+}
+
+/**
+ * 执行计划里「不需要人点头」的部分（adopt / restore / drop + 基线），
+ * 并把首次运行标记打上。
+ *
+ * `pending` 不在这里处理：那一档必须由人显式调用 /features/adopt 才动。
+ */
+export function applyFeaturePlan({ plan, state, machineId, log = () => {} } = {}) {
+  const adopted = [];
+  const restored = [];
+  const dropped = [];
+  const errors = [];
+
+  for (const item of plan.adopt || []) {
+    try {
+      adoptFeature(item.path, machineId);
+      adopted.push(item);
+    } catch (err) {
+      errors.push({ path: item.path, message: String((err && err.message) || err) });
+    }
+  }
+  for (const item of plan.restore || []) {
+    try {
+      adoptFeature(item.path, machineId);
+      restored.push(item);
+      forgetDecision(state, item.path);
+      log(`补建本机特征文件夹 ${item.path}`);
+    } catch (err) {
+      errors.push({ path: item.path, message: String((err && err.message) || err) });
+    }
+  }
+  for (const item of plan.drop || []) {
+    try {
+      const out = dropFeature(item.path, machineId, { log });
+      if (out.removed) dropped.push(item);
+    } catch (err) {
+      errors.push({ path: item.path, message: String((err && err.message) || err) });
+    }
+  }
+
+  // 基线：只记「这一轮真的在清单里」且「现在有格子」的工作区
+  if (!state.features || typeof state.features !== 'object') {
+    state.features = { initialized: false, decisions: {}, known: {} };
+  }
+  // 这一轮问过人的，打上 ask 标记——否则下一轮 initialized 已是 true，
+  // 会被当成「本机新建」直接建格子，等于替人做了决定。
+  markAsked(state, plan);
+  const keep = {};
+  const live = new Set((plan.seenNow ? Object.keys(plan.seenNow) : []).map(String));
+  for (const item of plan.seed || []) keep[item.id] = item.path;
+  for (const item of adopted) keep[item.id] = item.path;
+  for (const item of restored) keep[item.id] = item.path;
+  // 已有但本轮没扫到的（前缀被改掉等）保留，避免误判成「被删除」
+  for (const [id, p] of Object.entries(state.features.known || {})) {
+    if (keep[id]) continue;
+    if (live.has(String(id))) continue;
+    if (plan.drop && plan.drop.some((d) => String(d.id) === String(id))) continue;
+    keep[id] = p;
+  }
+  state.features.known = keep;
+  state.features.initialized = true;
+  state.features.lastPlanAt = Date.now();
+
+  return { adopted, restored, dropped, errors };
+}
+
+/**
+ * 只做「删掉的工作区 → 删格子」这一件事。
+ *
+ * 供 30 秒一次的轻量巡检用：不扫盘、不建目录，只按给定 id 清单清格子。
+ * `confirmedIds` 由 pickRemovedIds 选出来（已经过二次确认）。
+ */
+export function reconcileRemoved(state, machineId, confirmedIds, { log = () => {} } = {}) {
+  const dropped = [];
+  const errors = [];
+  if (!state.features || typeof state.features !== 'object') return { dropped, errors };
+  const known = state.features.known || {};
+  for (const id of confirmedIds || []) {
+    const key = String(id);
+    const p = known[key];
+    if (!p) continue;
+    try {
+      const out = dropFeature(p, machineId, { log });
+      if (out.removed) dropped.push({ id: key, path: p });
+      delete known[key];
+    } catch (err) {
+      errors.push({ id: key, path: p, message: String((err && err.message) || err) });
+    }
+  }
+  return { dropped, errors };
+}
+
+/**
+ * 挑出「确实已经被删除」的工作区 id。**纯函数**，不碰磁盘。
+ *
+ * 为什么要二次确认：workspaceRegistry 在启动早期、注册表重建、或宿主正在
+ * 切换 profile 时可能短暂返回空清单/缺项。只凭一次快照就删特征文件夹，
+ * 等于把这个工作区的同步历史一把抹掉。规矩：
+ *   - 清单为空 → 本轮什么都不确认（清除计时）；
+ *   - 同一个 id 连续两轮都不在，且间隔 ≥ minAgeMs，才确认删除。
+ *
+ * @param {{known:Object<string,string>, liveIds:string[], missingSince:Map<string,number>,
+ *          now:number, minAgeMs:number}} input
+ * @returns {{confirmed:string[], missingSince:Map<string,number>}}
+ */
+export function pickRemovedIds({ known = {}, liveIds = [], missingSince, now = Date.now(), minAgeMs = 30000 }) {
+  const next = missingSince instanceof Map ? missingSince : new Map();
+  const confirmed = [];
+  const live = new Set((liveIds || []).map(String));
+
+  if (!live.size) {
+    next.clear();
+    return { confirmed, missingSince: next };
+  }
+
+  // 又回来了 / 基线里已经没有它了 → 清掉计时
+  for (const id of [...next.keys()]) {
+    if (live.has(id) || !Object.prototype.hasOwnProperty.call(known, id)) next.delete(id);
+  }
+
+  for (const id of Object.keys(known)) {
+    if (live.has(id)) continue;
+    const since = next.get(id);
+    if (since === undefined) {
+      next.set(id, now);
+      continue;
+    }
+    if (now - since >= minAgeMs) confirmed.push(id);
+  }
+
+  for (const id of confirmed) next.delete(id);
+  return { confirmed, missingSince: next };
+}
+
+/** 过滤：只留下「特征文件夹存在」的工作区。备份/拉取/展示都用它。 */
+export function onlyActive(list, machineId) {
+  return (list || []).filter((ws) => ws && ws.path && hasFeature(ws.path, machineId));
+}
+
+/** 某个工作区为什么没参与，给面板显示用。 */
+export function inactiveReason(workspacePath, machineId, state) {
+  if (hasFeature(workspacePath, machineId)) return '';
+  if (decisionOf(state, workspacePath) === 'decline') return '你选了不在这个文件夹建本机特征文件夹';
+  return '还没有建本机特征文件夹（未参与备份与拉取）';
+}

package/package.json

@@ -1,61 +1,62 @@
-{
-  "name": "ygc-dsh-sync",
-  "version": "1.0.2",
-  "type": "module",
-  "description": "DSH 同步插件：会话按工作区落地、按机器隔离的跨机备份与拉取；技能本机↔母版双向同步（含记忆插件技能优化闭环）；插件清单共享（只存清单与来源，不存源码，只能联网装）。",
-  "icon": "icon.svg",
-  "keywords": [
-    "dsh",
-    "deepseek-harness",
-    "dsh-plugin",
-    "session",
-    "sync",
-    "backup",
-    "plugin-manifest"
-  ],
-  "license": "MIT",
-  "exports": {
-    ".": "./index.js",
-    "./client": "./client.js",
-    "./locale/*.json": "./locale/*.json",
-    "./icon": "./icon.svg"
-  },
-  "files": [
-    "index.js",
-    "client.js",
-    "lib/core.js",
-    "lib/plugins.js",
-    "lib/backup.js",
-    "lib/attach.js",
-    "lib/api.js",
-    "lib/patrol.js",
-    "lib/skills.js",
-    "lib/mnemon.js",
-    "lib/mnemon-optimize.js",
-    "lib/changelog.js",
-    "lib/zstd-frame.js",
-    "cordis.patch.yml",
-    "locale/*.json",
-    "icon.svg",
-    "README.md",
-    "tools/*.mjs",
-    "lib/mnemon-pipeline.js",
-    "lib/mnemon-drafter.js"
-  ],
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "public"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "immediately": true,
-      "inject": [
-        "@deepseek-ai/dsh-client-ui-conversation"
-      ]
-    }
-  }
-}
+{
+  "name": "ygc-dsh-sync",
+  "version": "1.2.0",
+  "type": "module",
+  "description": "DSH 同步插件：会话按工作区落地、按机器隔离的跨机备份与拉取；技能本机↔母版双向同步（含记忆插件技能优化闭环）；插件清单共享（只存清单与来源，不存源码，只能联网装）。",
+  "icon": "icon.svg",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "session",
+    "sync",
+    "backup",
+    "plugin-manifest"
+  ],
+  "license": "MIT",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "lib/core.js",
+    "lib/features.js",
+    "lib/plugins.js",
+    "lib/backup.js",
+    "lib/attach.js",
+    "lib/api.js",
+    "lib/patrol.js",
+    "lib/skills.js",
+    "lib/mnemon.js",
+    "lib/mnemon-optimize.js",
+    "lib/changelog.js",
+    "lib/zstd-frame.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "tools/*.mjs",
+    "lib/mnemon-pipeline.js",
+    "lib/mnemon-drafter.js"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  }
+}