ygc-dsh-sync 1.1.0 → 1.2.1

package/lib/features.js

@@ -0,0 +1,409 @@
+/**
+ * 本机特征文件夹（`<工作区>/.dsh-sync/sessions/<本机标识>/`）的采纳、撤销与巡检判据。
+ *
+ * 判据只有一条：**磁盘上有没有那三个东西** —— 别人的特征文件夹、我的特征文件夹、
+ * 对应的工作区（DSH 的 workspaceRegistry 注册）。
+ * 用户 2026-11-14 定的巡检矩阵（这一层就是它的唯一实现）：
+ *
+ * | 别人的格子 | 我的格子 | 工作区 | 动作 |
+ * |---|---|---|---|
+ * | 有 | 没有 | 没有 | **问人**：要不要在本机建特征文件夹（建了就顺带注册工作区） |
+ * | — | 有 | 有 | 正常，参与备份与拉取 |
+ * | — | 有 | 没有 | **补工作区**：把目录注册回侧边栏（不建也不删文件） |
+ * | — | 没有 | 有 | **补文件夹**：给这个工作区建本机特征文件夹 |
+ *
+ * 删除的语义（同样是用户定的）：
+ *
+ * - 删工作区时，**先看有没有别人的格子**：
+ *   - 只有本机这一格 → 连 `.dsh-sync/` 一起收掉，巡检**再也扫不到**它（不留痕、不追问）。
+ *   - 还有别人的格子 → 只删我这一格（连同格里备份的对话记录），`.dsh-sync/` 留着，
+ *     巡检据此认为「本机没有这个共享工作区」，进人工队列问要不要重建。
+ * - 插件**不提供**「只删格子、留着工作区」的入口：那会让工作区变成
+ *   「已注册但没格子」，下一轮必然被补回来，看起来就是「删了又冒出来」。
+ */
+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();
+}
+
+/** 这个工作区里，除了本机之外还有哪些机器的特征文件夹。 */
+export function otherFeatures(workspacePath, machineId) {
+  const sessions = path.join(normSlash(workspacePath), TARGET_DIR_NAME);
+  let names = [];
+  try {
+    names = fs
+      .readdirSync(sessions, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return [];
+  }
+  const me = String(machineId || '');
+  return names.filter((n) => n !== me);
+}
+
+/** 目录里是否还有 `.dsh-sync/` 这套结构（含 sessions）。 */
+export function hasSyncStructure(workspacePath) {
+  const st = safeStat(path.join(normSlash(workspacePath), TARGET_DIR_NAME.split(path.sep)[0]));
+  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/` 一起收掉 ——
+ *     全收掉之后巡检就再也扫不到这个目录，符合「只有本机格子时删干净」；
+ *   - 目标不存在算成功（幂等）。
+ *
+ * @returns {{removed:boolean, target?:string, keptStructure?:boolean, others?:string[], reason?:string}}
+ */
+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 others = otherFeatures(workspacePath, machineId);
+  const st = safeStat(target);
+  if (!st) {
+    return { removed: false, reason: '本来就没有', others, keptStructure: hasSyncStructure(workspacePath) };
+  }
+  if (!st.isDirectory()) return { removed: false, reason: '不是目录', others };
+  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,
+    others,
+    keptStructure: hasSyncStructure(workspacePath),
+  };
+}
+
+/* ----------------------------------------------------------- 决策与基线 */
+
+/** 决策键：路径的大小写不敏感写法（Windows 下同一个目录只有一份）。 */
+const keyOf = (p) => {
+  try {
+    return pathKey(p);
+  } catch {
+    return String(p || '').toLowerCase();
+  }
+};
+
+/** 人为某个路径表过态吗？返回 'adopt' | 'decline' | null。 */
+export function decisionOf(state, workspacePath) {
+  const bag = (state && state.features && state.features.decisions) || {};
+  const hit = bag[keyOf(workspacePath)];
+  if (!hit) return null;
+  return hit.action === 'decline' ? 'decline' : 'adopt';
+}
+
+/**
+ * 记一次人为表态。
+ *
+ *   adopt    人点了「建格子」（之后缺了就自动补）
+ *   decline  人点了「不要」（之后只列出来，不自动建）
+ */
+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 = {};
+  }
+  state.features.decisions[keyOf(workspacePath)] = {
+    action: action === 'decline' ? 'decline' : 'adopt',
+    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    巡检扫出、「有 .dsh-sync 结构但没注册成工作区」的目录
+ *   state       插件状态（读 features.known / decisions）
+ *   machineId   本机标识
+ *
+ * 输出（正好对上那张矩阵）：
+ *   active         有我的格子 + 有工作区 → 正常
+ *   createFolder   有工作区 + 没我的格子 → 补文件夹
+ *   restoreWorkspace  有我的格子 + 没工作区 → 补工作区
+ *   ask            没我的格子 + 没工作区 + 目录有 .dsh-sync → 问人
+ *   drop           基线里有、现在清单里没有 → 工作区被删了，格子要跟着删
+ *   seed           有格子的工作区（进基线，之后靠它判「被删除」）
+ */
+export function planFeatures({
+  folders = [],
+  workspaces = [],
+  discover = [],
+  state = {},
+  machineId = '',
+} = {}) {
+  const features = (state && state.features) || {};
+  const known = features.known || {};
+  const seenNow = {};
+  const active = [];
+  const createFolder = [];
+  const restoreWorkspace = [];
+  const ask = [];
+  const drop = [];
+  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 + '/');
+    });
+  };
+  const alreadyAsk = (p) => ask.some((x) => keyOf(x.path) === keyOf(p));
+
+  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;
+
+    if (decisionOf(state, ws.path) === 'decline') {
+      // 人明确说过这个目录不要建 → 只列出来，不自作主张
+      ask.push({ ...entry, why: 'declined' });
+      continue;
+    }
+
+    // 有工作区 + 没我的格子 → 补文件夹
+    createFolder.push({ ...entry, why: 'workspace-without-folder' });
+  }
+
+  // 有 .dsh-sync 结构、但没注册成工作区的目录
+  const knownWorkspacePaths = new Set(Object.values(seenNow).map((p) => keyOf(p)));
+  for (const d of discover || []) {
+    if (!d || !d.path) continue;
+    if (alreadyAsk(d.path)) continue;
+    // 已经在「工作区清单」里的，前面那一轮已经按「有工作区没格子 → 补文件夹」处理过了，
+    // 这里必须跳过：同一个目录不能既补文件夹又问人（scanFolders 会把它同时扫进 discover）。
+    if (knownWorkspacePaths.has(keyOf(d.path))) continue;
+    const title = d.title || path.basename(d.path);
+    if (decisionOf(state, d.path) === 'decline') {
+      ask.push({ id: null, path: d.path, title, why: 'declined' });
+      continue;
+    }
+    if (hasFeature(d.path, machineId)) {
+      // 有我的格子 + 没工作区 → 补工作区
+      restoreWorkspace.push({ id: null, path: d.path, title, why: 'folder-without-workspace' });
+      continue;
+    }
+    // 没我的格子 + 没工作区 + 目录有结构 → 问人
+    const others = otherFeatures(d.path, machineId);
+    ask.push({
+      id: null,
+      path: d.path,
+      title,
+      why: others.length ? 'others-only' : 'structure-only',
+      others,
+    });
+  }
+
+  // 基线里有、这一轮清单里没有 = 工作区被删了 → 格子跟着删
+  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, createFolder, restoreWorkspace, ask, drop, seed, seenNow };
+}
+
+/**
+ * 执行计划里「不需要人点头」的部分：补文件夹、删格子，并回写基线。
+ *
+ * **不处理 `restoreWorkspace`**：注册工作区要走宿主接口（async），由调用方做。
+ * `ask` 更不能在这里动。
+ */
+export function applyFeaturePlan({ plan, state, machineId, log = () => {} } = {}) {
+  const created = [];
+  const dropped = [];
+  const errors = [];
+
+  for (const item of plan.createFolder || []) {
+    try {
+      adoptFeature(item.path, machineId);
+      created.push(item);
+    } 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, others: out.others, keptStructure: out.keptStructure });
+      // 删干净之后不能再留任何记录，否则巡检会「记住」一个已经不该存在的目录
+      forgetDecision(state, item.path);
+    } 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: {} };
+  }
+  const keep = {};
+  for (const item of plan.seed || []) keep[item.id] = item.path;
+  for (const item of created) keep[item.id] = item.path;
+  // 已有但本轮没扫到的（前缀被改掉等）保留，避免误判成「被删除」
+  const live = new Set(Object.keys(plan.seenNow || {}).map(String));
+  for (const [id, p] of Object.entries(state.features.known || {})) {
+    if (keep[id]) continue;
+    if (live.has(String(id))) continue;
+    if ((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 { created, dropped, errors };
+}
+
+/**
+ * 挑出「确实已经被删除」的工作区 id。**纯函数**，不碰磁盘。
+ *
+ * 为什么要二次确认：workspaceRegistry 在启动早期、注册表重建、或宿主正在
+ * 切换 profile 时可能短暂返回空清单/缺项。只凭一次快照就删特征文件夹，
+ * 等于把这个工作区的同步历史一把抹掉。规矩：
+ *   - 清单为空 → 本轮什么都不确认（清除计时）；
+ *   - 同一个 id 连续两轮都不在，且间隔 ≥ minAgeMs，才确认删除。
+ */
+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 };
+}
+
+/**
+ * 删掉「被删除的工作区」对应的本机格子（连同格里备份的对话），并清掉基线。
+ *
+ * 只做这一件事，不碰别人的格子；`.dsh-sync/` 是否被一起收掉由 dropFeature 判断。
+ * 删完不再留任何记录 —— 只有本机格子时巡检必须再也看不到它。
+ */
+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 });
+      dropped.push({ id: key, path: p, others: out.others, keptStructure: out.keptStructure });
+      delete known[key];
+      forgetDecision(state, p);
+    } catch (err) {
+      errors.push({ id: key, path: p, message: String((err && err.message) || err) });
+    }
+  }
+  return { dropped, errors };
+}
+
+/** 过滤：只留下「有本机特征文件夹」的工作区。备份/拉取/展示都用它。 */
+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,6 +1,6 @@
 {
   "name": "ygc-dsh-sync",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "type": "module",
   "description": "DSH 同步插件：会话按工作区落地、按机器隔离的跨机备份与拉取；技能本机↔母版双向同步（含记忆插件技能优化闭环）；插件清单共享（只存清单与来源，不存源码，只能联网装）。",
   "icon": "icon.svg",
@@ -24,6 +24,7 @@
     "index.js",
     "client.js",
     "lib/core.js",
+    "lib/features.js",
     "lib/plugins.js",
     "lib/backup.js",
     "lib/attach.js",
@@ -58,4 +59,4 @@
       ]
     }
   }
-}
+}

package/tools/draft-live.mjs

@@ -14,7 +14,6 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const args = process.argv.slice(2);
 const has = (f) => args.includes(f);
@@ -31,11 +30,8 @@ const REPLY = val('--reply');
 const LEDGER = path.join(process.env.USERPROFILE, '.mnemon', 'skills', 'ledger.json');
 const LOCAL = path.join(process.env.USERPROFILE, '.agents', 'skills');
 
-// 优先用源码仓（YGC_SYNC_SRC），否则用已装副本里的同一份 —— 两边逐字一致。
-const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const SRC_ROOT = process.env.YGC_SYNC_SRC || PKG_ROOT;
 const P = await import(
-  pathToFileURL(path.join(SRC_ROOT, 'lib', 'mnemon-pipeline.js')).href
+  'file:///C:/Users/DSH/Documents/deepseek-harness/default-workspace/projects/dsh-sync-backup/lib/mnemon-pipeline.js'
 );
 const log = (m) => console.log(m);
 

package/tools/release-local.mjs

@@ -11,18 +11,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import os from 'node:os';
 import { execFileSync } from 'node:child_process';
 
-// 源码根与 profile 都不写死：换机器只改环境变量。
-// ROOT 指向 ygc-dsh-sync 源码仓（有 package.json 的那层）。
-const ROOT = process.env.YGC_SYNC_SRC || process.argv[2] || process.cwd();
-const PROFILE = process.env.DSH_PROFILE_DIR
-  || path.join(process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'profiles', process.env.DSH_PROFILE || 'desktop');
-if (!fs.existsSync(path.join(ROOT, 'package.json'))) {
-  console.error('找不到源码根：' + ROOT + '（设 YGC_SYNC_SRC 或在仓库根运行）');
-  process.exit(2);
-}
+const ROOT = 'C:/Users/DSH/Documents/deepseek-harness/default-workspace/projects/dsh-sync-backup';
+const PROFILE = 'C:/Users/DSH/.dsh/profiles/desktop';
 const PKG = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf8'));
 const NAME = PKG.name;
 

package/tools/sync-lock.mjs

@@ -10,11 +10,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import os from 'node:os';
 
 const tgz = process.argv[2];
-const PROFILE = process.argv[3] || process.env.DSH_PROFILE_DIR
-  || path.join(process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'profiles', process.env.DSH_PROFILE || 'desktop');
+const PROFILE = process.argv[3] || 'C:/Users/DSH/.dsh/profiles/desktop';
 if (!tgz || !fs.existsSync(tgz)) {
   console.error('usage: node tools/sync-lock.mjs <tgz> [profile]');
   process.exit(2);

package/tools/verify-installed.mjs

@@ -18,8 +18,7 @@ if (!HASH) {
   process.exit(2);
 }
 const NAME = 'ygc-dsh-sync-backup';
-const PROFILE = process.env.DSH_PROFILE_DIR
-  || path.join(process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'profiles', process.env.DSH_PROFILE || 'desktop');
+const PROFILE = 'C:/Users/DSH/.dsh/profiles/desktop';
 
 const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'dsb-verify-'));
 process.env.DSH_SYNC_SKILLS_ROOT = path.join(tmp, 'skills');