dsh-desktop-kit 2.2.0 → 2.7.2

package/plugins/dsh-memory-bridge/lib/state.js

@@ -0,0 +1,565 @@
+/**
+ * dsh-memory-bridge — configuration, machine identity, project state, backups
+ * and the small filesystem helpers shared by the sync service.
+ *
+ * Everything the bridge owns lives under `<DSH_HOME>/memory-sync/`, outside
+ * `projects-memory/`, so the kit and `dsh-profile-transfer` keep their layout
+ * untouched.
+ */
+
+import crypto from "node:crypto";
+import fsp from "node:fs/promises";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+
+import {
+  BridgeError,
+  SECTION_FILES,
+  JOURNAL_FILE,
+  dshHome,
+  ensureDir,
+  exists,
+  hashContentMap,
+  isAllowedSyncPath,
+  memoryRoot,
+  readJsonIfExists,
+  readTextIfExists,
+  removeFileQuiet,
+  safeRelPath,
+  sha256,
+  syncRoot,
+  writeFileAtomic,
+  writeJsonAtomic,
+} from "./bridge.js";
+
+export const DEFAULT_CONFIG = Object.freeze({
+  version: 2,
+  enabled: false,
+  repo: "",
+  branch: "main",
+  localDir: "",
+  intervalSeconds: 300,
+  autoSync: true,
+  excludeProjects: [],
+  links: {},
+});
+
+export function pathsFor(home = dshHome()) {
+  const root = syncRoot(home);
+  return {
+    home,
+    root,
+    config: path.join(root, "config.json"),
+    machine: path.join(root, "machine.json"),
+    global: path.join(root, "global.json"),
+    githubRoot: path.join(root, "github"),
+    baseDir: path.join(root, "base"),
+    conflictsDir: path.join(root, "github-conflicts"),
+    tmpDir: path.join(root, "tmp"),
+    backupsDir: path.join(root, "backups"),
+    logFile: path.join(root, "log.txt"),
+    projectsMemory: memoryRoot(home),
+  };
+}
+
+/* ------------------------------------------------------------------ */
+/* config                                                              */
+/* ------------------------------------------------------------------ */
+
+export function normaliseConfig(raw) {
+  const value = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  return {
+    ...DEFAULT_CONFIG,
+    ...value,
+    version: 2,
+    enabled: value.enabled === true,
+    repo: typeof value.repo === "string" ? value.repo.trim() : "",
+    branch: typeof value.branch === "string" && value.branch.trim().length > 0 ? value.branch.trim() : "main",
+    localDir: typeof value.localDir === "string" ? value.localDir : "",
+    intervalSeconds: clampNumber(value.intervalSeconds, 60, 3600, DEFAULT_CONFIG.intervalSeconds),
+    autoSync: value.autoSync !== false,
+    excludeProjects: Array.isArray(value.excludeProjects) ? value.excludeProjects.filter((item) => typeof item === "string") : [],
+    links: value.links !== null && typeof value.links === "object" && !Array.isArray(value.links) ? { ...value.links } : {},
+  };
+}
+
+function clampNumber(value, min, max, fallback) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  return Math.max(min, Math.min(max, Math.trunc(number)));
+}
+
+export async function loadConfig(home = dshHome()) {
+  const parsed = await readJsonIfExists(pathsFor(home).config);
+  return normaliseConfig(parsed);
+}
+
+export async function saveConfig(home, config) {
+  const normalised = normaliseConfig(config);
+  await writeJsonAtomic(pathsFor(home).config, normalised);
+  return normalised;
+}
+
+/* ------------------------------------------------------------------ */
+/* machine identity                                                    */
+/* ------------------------------------------------------------------ */
+
+export async function loadMachine(home = dshHome()) {
+  const file = pathsFor(home).machine;
+  const parsed = await readJsonIfExists(file);
+  if (parsed !== undefined && typeof parsed.machineId === "string" && parsed.machineId.length > 0) {
+    const label = typeof parsed.label === "string" ? parsed.label : "";
+    return {
+      machineId: parsed.machineId,
+      label,
+      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : new Date().toISOString(),
+      mismatch: label.length > 0 && label !== os.hostname(),
+      hostname: os.hostname(),
+    };
+  }
+  const machine = {
+    machineId: crypto.randomUUID(),
+    label: os.hostname(),
+    createdAt: new Date().toISOString(),
+  };
+  await writeJsonAtomic(file, machine);
+  return { ...machine, mismatch: false, hostname: os.hostname() };
+}
+
+export async function resetMachine(home = dshHome()) {
+  const machine = {
+    machineId: crypto.randomUUID(),
+    label: os.hostname(),
+    createdAt: new Date().toISOString(),
+  };
+  await writeJsonAtomic(pathsFor(home).machine, machine);
+  return machine;
+}
+
+/* ------------------------------------------------------------------ */
+/* global state (approvals, pauses, profile-transfer signature)        */
+/* ------------------------------------------------------------------ */
+
+export async function loadGlobal(home = dshHome()) {
+  const parsed = await readJsonIfExists(pathsFor(home).global);
+  const value = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  return {
+    version: 1,
+    approvedMachines: value.approvedMachines !== null && typeof value.approvedMachines === "object" ? { ...value.approvedMachines } : {},
+    pendingApprovals: value.pendingApprovals !== null && typeof value.pendingApprovals === "object" ? { ...value.pendingApprovals } : {},
+    lastProfileTransfer: value.lastProfileTransfer ?? null,
+    paused: value.paused ?? null,
+    lastCycleAt: typeof value.lastCycleAt === "string" ? value.lastCycleAt : null,
+    lastPullAt: typeof value.lastPullAt === "string" ? value.lastPullAt : null,
+    lastPushAt: typeof value.lastPushAt === "string" ? value.lastPushAt : null,
+    warnings: Array.isArray(value.warnings) ? value.warnings.slice(0, 20) : [],
+  };
+}
+
+export async function saveGlobal(home, global) {
+  await writeJsonAtomic(pathsFor(home).global, global);
+}
+
+/* ------------------------------------------------------------------ */
+/* per-project state                                                   */
+/* ------------------------------------------------------------------ */
+
+export function emptyProjectState(projectKey, localSlug, fingerprint) {
+  return {
+    version: 1,
+    projectKey,
+    localSlug,
+    fingerprint,
+    base: {},
+    remotes: {},
+    lastExport: null,
+    exportRevision: 0,
+    conflictsSeen: {},
+    updatedAt: null,
+  };
+}
+
+export async function loadProjectState(home, projectKey) {
+  const file = path.join(pathsFor(home).stateDir, `${projectKey}.json`);
+  const parsed = await readJsonIfExists(file);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+  if (parsed.version !== 1) return undefined;
+  return {
+    ...emptyProjectState(parsed.projectKey ?? projectKey, parsed.localSlug, parsed.fingerprint ?? ""),
+    ...parsed,
+    base: parsed.base !== null && typeof parsed.base === "object" ? { ...parsed.base } : {},
+    remotes: parsed.remotes !== null && typeof parsed.remotes === "object" ? { ...parsed.remotes } : {},
+    conflictsSeen: parsed.conflictsSeen !== null && typeof parsed.conflictsSeen === "object" ? { ...parsed.conflictsSeen } : {},
+  };
+}
+
+export async function saveProjectState(home, state) {
+  state.updatedAt = new Date().toISOString();
+  await writeJsonAtomic(path.join(pathsFor(home).stateDir, `${state.projectKey}.json`), state);
+}
+
+/* ------------------------------------------------------------------ */
+/* registry (read-only) and project mapping                            */
+/* ------------------------------------------------------------------ */
+
+export async function readRegistry(home = dshHome()) {
+  const parsed = await readJsonIfExists(path.join(memoryRoot(home), "registry.json"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return { projects: [], settings: {} };
+  const projects = Array.isArray(parsed.projects)
+    ? parsed.projects.filter((project) => project !== null && typeof project === "object" && typeof project.slug === "string")
+    : [];
+  return { projects, settings: parsed.settings ?? {} };
+}
+
+export function projectKeyFor(fingerprint) {
+  return sha256(String(fingerprint ?? "")).slice(0, 12);
+}
+
+/** Projects that can participate in sync on this machine. */
+export async function syncTargets(home, config) {
+  const registry = await readRegistry(home);
+  const links = config.links ?? {};
+  const excluded = new Set(config.excludeProjects ?? []);
+  const targets = [];
+  const skipped = [];
+  const seenSlugs = new Set();
+  for (const project of registry.projects) {
+    const slug = String(project.slug);
+    if (seenSlugs.has(slug)) continue;
+    seenSlugs.add(slug);
+    if (excluded.has(slug)) continue;
+    const fingerprint = String(project.fingerprint ?? "");
+    let projectKey;
+    if (fingerprint.startsWith("git:")) projectKey = projectKeyFor(fingerprint);
+    else if (typeof links[slug] === "string" && /^[a-f0-9]{12}$/u.test(links[slug])) projectKey = links[slug];
+    if (!projectKey) {
+      skipped.push({ slug, reason: "не-git проект без /sync link" });
+      continue;
+    }
+    const directory = path.join(memoryRoot(home), slug);
+    if (!(await exists(directory))) {
+      skipped.push({ slug, reason: "каталог досье не найден" });
+      continue;
+    }
+    targets.push({
+      slug,
+      name: typeof project.name === "string" ? project.name : slug,
+      fingerprint,
+      projectKey,
+      directory,
+      roots: Array.isArray(project.roots) ? project.roots.filter((root) => typeof root === "string") : [],
+    });
+  }
+  return { targets, skipped, registry };
+}
+
+/* ------------------------------------------------------------------ */
+/* folder helpers                                                      */
+/* ------------------------------------------------------------------ */
+
+export async function resolveWritableFolder(folder, { home = dshHome(), projectRoots = [] } = {}) {
+  if (typeof folder !== "string" || folder.trim().length === 0) {
+    throw new BridgeError("folder/empty", "папка обмена не задана: /sync folder <путь>");
+  }
+  const resolved = path.resolve(folder.trim());
+  let stat;
+  try {
+    stat = await fsp.stat(resolved);
+  } catch {
+    throw new BridgeError("folder/missing", `папка обмена не найдена: ${resolved}`);
+  }
+  if (!stat.isDirectory()) throw new BridgeError("folder/not-directory", `это не папка: ${resolved}`);
+  const homeResolved = path.resolve(home);
+  const relativeHome = path.relative(homeResolved, resolved);
+  if (relativeHome.length === 0 || (!relativeHome.startsWith("..") && !path.isAbsolute(relativeHome))) {
+    throw new BridgeError("folder/inside-home", "папка обмена не должна находиться внутри DSH_HOME");
+  }
+  for (const root of projectRoots) {
+    const relative = path.relative(path.resolve(root), resolved);
+    if (relative.length === 0 || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+      throw new BridgeError("folder/inside-project", `папка обмена не должна находиться внутри проекта: ${root}`);
+    }
+  }
+  const probe = path.join(resolved, `.dsh-memory-bridge-write-test-${process.pid}-${Date.now()}`);
+  try {
+    await fsp.writeFile(probe, "ok", { mode: 0o600 });
+    await removeFileQuiet(probe);
+  } catch {
+    throw new BridgeError("folder/not-writable", `нет прав на запись в папку обмена: ${resolved}`);
+  }
+  return resolved;
+}
+
+export function projectFolderName(project, config) {
+  if (config.folderNaming === "opaque") return project.projectKey;
+  const slug = String(project.slug ?? "project").replace(/[^A-Za-z0-9._-]+/gu, "-").slice(0, 40) || "project";
+  return `${slug}--${project.projectKey.slice(0, 8)}`;
+}
+
+/* ------------------------------------------------------------------ */
+/* backups                                                             */
+/* ------------------------------------------------------------------ */
+
+function backupStamp() {
+  const d = new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+
+export async function backupDossier(home, slug, directory, limits = {}) {
+  const destination = path.join(pathsFor(home).backupsDir, slug, backupStamp());
+  await ensureDir(destination);
+  let copied = 0;
+  for (const name of SECTION_FILES) await copyIfExists(path.join(directory, name), path.join(destination, name), limits);
+  const journalDir = path.join(directory, "JOURNAL");
+  try {
+    for (const entry of await fsp.readdir(journalDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      await copyIfExists(path.join(journalDir, entry.name), path.join(destination, "JOURNAL", entry.name), limits);
+    }
+  } catch {
+    /* no journal yet */
+  }
+  const manifest = { createdAt: new Date().toISOString(), slug, files: copied };
+  await writeJsonAtomic(path.join(destination, "backup.json"), manifest);
+  await pruneBackups(home, slug, 10);
+  return { directory: destination, ...manifest };
+}
+
+async function copyIfExists(source, target, limits = {}) {
+  try {
+    const stat = await fsp.lstat(source);
+    if (stat.isSymbolicLink() || !stat.isFile()) return;
+    if (Number.isFinite(limits.maxFileBytes) && stat.size > limits.maxFileBytes) return;
+    await ensureDir(path.dirname(target));
+    await fsp.copyFile(source, target);
+  } catch {
+    /* missing file is fine */
+  }
+}
+
+async function pruneBackups(home, slug, keep) {
+  const directory = path.join(pathsFor(home).backupsDir, slug);
+  try {
+    const entries = (await fsp.readdir(directory, { withFileTypes: true }))
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort()
+      .reverse();
+    for (const name of entries.slice(keep)) await fsp.rm(path.join(directory, name), { recursive: true, force: true });
+  } catch {
+    /* nothing to prune */
+  }
+}
+
+export async function listBackups(home, slug) {
+  const directory = path.join(pathsFor(home).backupsDir, slug);
+  try {
+    return (await fsp.readdir(directory, { withFileTypes: true }))
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort()
+      .reverse();
+  } catch {
+    return [];
+  }
+}
+
+export async function restoreBackup(home, slug, directory, backupId) {
+  const source = path.join(pathsFor(home).backupsDir, slug, backupId);
+  if (!(await exists(source))) throw new BridgeError("backup/missing", `бэкап не найден: ${backupId}`);
+  await backupDossier(home, slug, directory);
+  let restored = 0;
+  for (const name of SECTION_FILES) {
+    const from = path.join(source, name);
+    if (!(await exists(from))) continue;
+    await writeFileAtomic(path.join(directory, name), await fsp.readFile(from));
+    restored += 1;
+  }
+  const journalFrom = path.join(source, "JOURNAL");
+  try {
+    for (const entry of await fsp.readdir(journalFrom, { withFileTypes: true })) {
+      if (!entry.isFile()) continue;
+      await writeFileAtomic(path.join(directory, "JOURNAL", entry.name), await fsp.readFile(path.join(journalFrom, entry.name)));
+      restored += 1;
+    }
+  } catch {
+    /* no journal in backup */
+  }
+  const global = await loadGlobal(home);
+  global.paused = {
+    reason: "восстановлен бэкап досье — сверьте версии и выполните /sync pull (или /sync push, если восстановление намеренное)",
+    at: new Date().toISOString(),
+  };
+  await saveGlobal(home, global);
+  return { restored, source, paused: true };
+}
+
+/* ------------------------------------------------------------------ */
+/* incoming / conflicts / log                                          */
+/* ------------------------------------------------------------------ */
+
+export async function writeIncoming(home, projectKey, machineId, relativePath, text) {
+  const safe = safeRelPath(relativePath);
+  const target = path.join(pathsFor(home).incomingDir, projectKey, String(machineId).replace(/[^A-Za-z0-9._-]+/gu, "_"), ...safe.split("/"));
+  await writeFileAtomic(target, text);
+  return target;
+}
+
+export async function appendConflict(home, slug, { machineId, relativePath, remoteHash, reason, remoteText }) {
+  const key = `${machineId}:${relativePath}:${remoteHash}`;
+  const file = path.join(pathsFor(home).conflictsDir, `${slug}.md`);
+  const raw = (await readTextIfExists(file)) ?? `# Конфликты синхронизации — ${slug}\n\n> Локальная версия оставлена без изменений. Чужая версия лежит в incoming и в этом отчёте.\n`;
+  if (raw.includes(`<!-- conflict:${key} -->`)) return { added: false, key, file };
+  const entry = [
+    "",
+    `<!-- conflict:${key} -->`,
+    `## ${new Date().toISOString()} · ${machineId} · ${relativePath}`,
+    `Причина: ${reason}`,
+    `Чужая версия сохранена в каталоге incoming (memory-sync/incoming). Хэш: \`${remoteHash}\``,
+    "",
+    "```",
+    String(remoteText ?? "").slice(0, 4000),
+    "```",
+    "",
+  ].join("\n");
+  await writeFileAtomic(file, `${raw.trimEnd()}\n${entry}`);
+  return { added: true, key, file };
+}
+
+export async function readConflictReportText(home, slug) {
+  return readTextIfExists(path.join(pathsFor(home).conflictsDir, `${slug}.md`));
+}
+
+/** Snapshot of the content that was accepted as the local synced state. */
+export async function writeBaseSnapshot(home, projectKey, content) {
+  const directory = path.join(pathsFor(home).baseDir, projectKey);
+  try {
+    await ensureDir(directory);
+    for (const [relativePath, text] of content) {
+      const safe = safeRelPath(relativePath);
+      await writeFileAtomic(path.join(directory, ...safe.split("/")), text);
+    }
+  } catch {
+    /* base snapshots are diagnostics only; the hashes in state.json are authoritative */
+  }
+}
+
+export async function logLine(home, message) {
+  try {
+    const file = pathsFor(home).logFile;
+    const line = `${new Date().toISOString()} ${String(message).replace(/\s+/gu, " ").slice(0, 500)}\n`;
+    await ensureDir(path.dirname(file));
+    await fsp.appendFile(file, line, { mode: 0o600 });
+    const stat = await fsp.stat(file);
+    if (stat.size > 160 * 1024) {
+      const raw = await fsp.readFile(file, "utf8");
+      const tail = raw.split(/\r?\n/u).slice(-300).join("\n");
+      await writeFileAtomic(file, `${tail}\n`);
+    }
+  } catch {
+    /* diagnostics must never break sync */
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* environment probes                                                  */
+/* ------------------------------------------------------------------ */
+
+export function kitVersion() {
+  const candidates = [];
+  try {
+    const require = createRequire(import.meta.url);
+    candidates.push(require.resolve("dsh-desktop-kit/package.json"));
+  } catch {
+    /* installed through a local link: node_modules is not a sibling */
+  }
+  const profileDir = process.env.DSH_PROFILE_DIR;
+  if (typeof profileDir === "string" && profileDir.length > 0) {
+    candidates.push(path.join(profileDir, "node_modules", "dsh-desktop-kit", "package.json"));
+  }
+  const home = dshHome();
+  const profileName = process.env.DSH_PROFILE;
+  if (typeof profileName === "string" && profileName.length > 0) {
+    candidates.push(path.join(home, "profiles", profileName, "node_modules", "dsh-desktop-kit", "package.json"));
+  }
+  candidates.push(path.join(home, "profiles", "desktop", "node_modules", "dsh-desktop-kit", "package.json"));
+  for (const file of candidates) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(file, "utf8"));
+      if (typeof manifest.version === "string") return manifest.version;
+    } catch {
+      /* try the next candidate */
+    }
+  }
+  return undefined;
+}
+
+export async function profileTransferSignature(home = dshHome()) {
+  try {
+    const stat = await fsp.stat(path.join(home, "profile-transfer-last.json"));
+    return { mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {
+    return null;
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* local dossier read / sync content                                   */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Read the dossier files that participate in sync.
+ * @returns {Promise<{raw:Map<string,string>, content:Map<string,string>, skipped:Array}>}
+ */
+export async function readLocalDossier(directory, { maxFileBytes, maxBundleBytes, maxFiles }) {
+  const raw = new Map();
+  const content = new Map();
+  const skipped = [];
+  let total = 0;
+  const add = async (relativePath) => {
+    const file = path.join(directory, ...relativePath.split("/"));
+    try {
+      const stat = await fsp.lstat(file);
+      if (stat.isSymbolicLink() || !stat.isFile()) return;
+      if (stat.size > maxFileBytes) {
+        skipped.push({ path: relativePath, reason: `больше лимита файла (${stat.size} B)` });
+        return;
+      }
+      const text = await fsp.readFile(file, "utf8");
+      total += Buffer.byteLength(text, "utf8");
+      if (total > maxBundleBytes) {
+        skipped.push({ path: relativePath, reason: "пакет превысил лимит" });
+        return;
+      }
+      raw.set(relativePath, text);
+    } catch (error) {
+      if (error?.code !== "ENOENT") skipped.push({ path: relativePath, reason: String(error?.message ?? error) });
+    }
+  };
+  for (const name of SECTION_FILES) await add(name);
+  try {
+    const journalDir = path.join(directory, "JOURNAL");
+    const entries = (await fsp.readdir(journalDir, { withFileTypes: true }))
+      .filter((entry) => entry.isFile() && /^\d{4}-\d{2}\.md$/u.test(entry.name))
+      .map((entry) => entry.name)
+      .sort();
+    for (const name of entries) {
+      if (raw.size >= maxFiles) {
+        skipped.push({ path: `JOURNAL/${name}`, reason: "превышено число файлов" });
+        continue;
+      }
+      await add(`JOURNAL/${name}`);
+    }
+  } catch {
+    /* no journal directory yet */
+  }
+  for (const [relativePath, text] of raw) {
+    content.set(relativePath, isAllowedSyncPath(relativePath) ? text : "");
+  }
+  return { raw, content, skipped };
+}
+
+export { hashContentMap };