dsh-desktop-kit 2.2.1 → 2.7.3

package/plugins/dsh-memory-bridge/cordis.patch.yml

@@ -0,0 +1,5 @@
+# One Host row for the memory bridge. This is a separate bundle: disabling or
+# removing it never touches dsh-desktop-kit or the project dossiers themselves.
+- insert:
+    - id: dsh-memory-bridge
+      name: dsh-memory-bridge

package/plugins/dsh-memory-bridge/icon.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Project memory bridge">
+  <defs>
+    <linearGradient id="bridgeGradient" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#3b82f6"/>
+      <stop offset="1" stop-color="#8b5cf6"/>
+    </linearGradient>
+  </defs>
+  <rect x="2" y="2" width="60" height="60" rx="14" fill="url(#bridgeGradient)"/>
+  <rect x="9" y="17" width="17" height="30" rx="4" fill="#ffffff" opacity="0.92"/>
+  <rect x="38" y="17" width="17" height="30" rx="4" fill="#ffffff" opacity="0.92"/>
+  <path d="M29 27h6M29 37h6" stroke="#ffffff" stroke-width="3.2" stroke-linecap="round"/>
+  <path d="M34 25.5 37.5 27 34 28.5M34 35.5 37.5 37 34 38.5" fill="none" stroke="#ffffff" stroke-width="2.6" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/plugins/dsh-memory-bridge/index.js

@@ -0,0 +1,378 @@
+/**
+ * dsh-memory-bridge — Host half (v2, GitHub-only).
+ *
+ * - RPC routes for the Settings page (`/api/dsh-memory-bridge/*`);
+ * - background sync: startup, timer, dossier changes, end of a turn;
+ * - hidden `/sync` diagnostics commands for recovery (the UI is the main path);
+ * - no model tools, no prompt injections, no subagents: zero token overhead.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { dshHome } from "./lib/bridge.js";
+import { createSyncService } from "./lib/sync.js";
+import * as st from "./lib/state.js";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const VERSION = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(here, "package.json"), "utf8")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
+
+/** Best-effort boot diagnostics: tells the UI/Host load apart from an apply failure. */
+function boot(stage, extra) {
+  try {
+    const dir = path.join(dshHome(), "memory-sync");
+    fs.mkdirSync(dir, { recursive: true });
+    const line = `${new Date().toISOString()} v${VERSION} ${stage}${extra ? ` ${extra}` : ""}\n`;
+    fs.appendFileSync(path.join(dir, "boot.log"), line);
+  } catch {
+    /* diagnostics must never break the plugin */
+  }
+}
+
+const ROUTE_BASE = "/api/dsh-memory-bridge";
+const RPC_NAMESPACE = "dsh-memory-bridge";
+
+export const inject = ["connection", "commands"];
+
+class RpcError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+}
+
+function okEnvelope(rpcId, value) {
+  return Response.json({ type: "server-response", rpcId, result: { ok: true, value } });
+}
+
+function errorEnvelope(rpcId, code, message, details = {}) {
+  return Response.json({ type: "server-response", rpcId, result: { ok: false, error: { code, message, details } } });
+}
+
+async function readEnvelope(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    throw new RpcError("memory-bridge/bad-request", "тело запроса не JSON");
+  }
+  if (body === null || typeof body !== "object" || body.type !== "client-request" || typeof body.rpcId !== "string" || typeof body.method !== "string") {
+    throw new RpcError("memory-bridge/bad-request", "некорректный конверт Connection");
+  }
+  return { rpcId: body.rpcId, method: body.method, payload: body.payload ?? {} };
+}
+
+export async function apply(ctx) {
+  boot("apply-start", ctx?.logger ? "logger" : "no-logger");
+  const logger = ctx.logger;
+  const home = dshHome();
+  let service;
+  try {
+    service = createSyncService({ home, logger });
+    await service.init();
+    boot("init-ok");
+  } catch (error) {
+    boot("init-failed", String(error));
+    logger?.warn?.(`[memory-bridge] init failed: ${String(error)}`);
+    return;
+  }
+
+  const log = (message) => logger?.debug?.(`[memory-bridge] ${message}`);
+  const warn = (message) => logger?.warn?.(`[memory-bridge] ${message}`);
+  let disposed = false;
+  const timeouts = new Set();
+  const intervals = new Set();
+
+  function timeout(callback, delay) {
+    if (disposed) return undefined;
+    const timer = setTimeout(() => {
+      timeouts.delete(timer);
+      callback();
+    }, delay);
+    timer.unref?.();
+    timeouts.add(timer);
+    return timer;
+  }
+
+  function interval(callback, delay) {
+    if (disposed) return undefined;
+    const timer = setInterval(callback, delay);
+    timer.unref?.();
+    intervals.add(timer);
+    return timer;
+  }
+
+  async function safeSync(reason) {
+    try {
+      return await service.autoSync({ reason });
+    } catch (error) {
+      warn(`sync failed (${reason}): ${String(error)}`);
+      return undefined;
+    }
+  }
+
+  /* ---------------- background sync ---------------- */
+
+  timeout(() => void safeSync("startup"), 10_000);
+  interval(() => void safeSync("timer"), 60_000);
+
+  let syncTimer;
+  let syncPending = false;
+  function scheduleSync(reason, delayMs = 30_000) {
+    if (disposed) return;
+    if (syncPending) return;
+    syncPending = true;
+    if (syncTimer !== undefined) clearTimeout(syncTimer);
+    syncTimer = timeout(() => {
+      syncPending = false;
+      void safeSync(reason);
+    }, delayMs);
+  }
+
+  try {
+    ctx.on("session/event", (session, event) => {
+      try {
+        if (session?.header?.origin === "subagent") return;
+        if (event?.type === "turn/end") scheduleSync("turn-end", 15_000);
+      } catch {
+        /* never break a session event */
+      }
+    });
+  } catch (error) {
+    warn(`session events unavailable: ${String(error)}`);
+  }
+
+  let watcher;
+  try {
+    watcher = fs.watch(service.paths.projectsMemory, { recursive: true }, (eventType, filename) => {
+      try {
+        const name = typeof filename === "string" ? filename.replaceAll("\\", "/") : "";
+        if (name.length === 0 || !name.endsWith(".md")) return;
+        if (/_access\.log$|_state\.json$|scan\.json$|INDEX\.json$/u.test(name)) return;
+        scheduleSync("dossier-write", 60_000);
+      } catch {
+        /* defensive */
+      }
+    });
+    watcher.on?.("error", (error) => warn(`watcher: ${String(error)}`));
+  } catch (error) {
+    warn(`fs.watch unavailable (${String(error)}); timer sync remains active`);
+  }
+
+  /* ---------------- RPC for the Settings page ---------------- */
+
+  let routeCtx = null;
+  function registerOperation(operation, handler) {
+    if (routeCtx === null || typeof routeCtx.connection?.fetch?.register !== "function") return;
+    const route = {
+      path: `${ROUTE_BASE}/${operation}`,
+      methods: ["POST"],
+      requestBody: "buffered",
+      fetch: async (request) => {
+        let rpcId = "invalid-request";
+        try {
+          const envelope = await readEnvelope(request);
+          rpcId = envelope.rpcId;
+          if (envelope.method !== `${RPC_NAMESPACE}/${operation}`) {
+            return errorEnvelope(rpcId, "memory-bridge/bad-request", "метод конверта не совпадает с endpoint");
+          }
+          const value = await handler(envelope.payload);
+          return okEnvelope(rpcId, value);
+        } catch (error) {
+          const code = typeof error?.code === "string" ? error.code : "memory-bridge/internal";
+          if (code === "memory-bridge/internal") warn(`${operation} failed: ${String(error)}`);
+          return errorEnvelope(rpcId, code, error instanceof Error ? error.message : String(error));
+        }
+      },
+    };
+    ctx.effect(() => {
+      const dispose = routeCtx.connection.fetch.register(route);
+      return () => {
+        try {
+          void Promise.resolve(dispose()).catch(() => {});
+        } catch {
+          /* carrier already unloading */
+        }
+      };
+    }, `memory-bridge: ${operation} route`);
+  }
+
+  function registerRoutes(injectedCtx) {
+    if (routeCtx !== null) return;
+    routeCtx = injectedCtx;
+    boot("routes-start", ctx === injectedCtx ? "direct" : "injected");
+    registerOperation("status", async () => service.status());
+    registerOperation("configure", async (payload) => {
+      await service.configure(payload?.repo, payload?.branch);
+      return { ok: true, status: await service.status() };
+    });
+    registerOperation("create-repo", async (payload) => {
+      const result = await service.createRepo(payload?.repo);
+      return { ok: true, created: result.created, repo: result.repo, owner: result.owner, status: result.status };
+    });
+    registerOperation("set-enabled", async (payload) => {
+      await service.setEnabled(payload?.enabled === true);
+      return { ok: true, status: await service.status() };
+    });
+    registerOperation("set-options", async (payload) => {
+      await service.setOptions(payload ?? {});
+      return { ok: true, status: await service.status() };
+    });
+    registerOperation("sync-now", async () => {
+      const report = await service.syncNow({ reason: "ui" });
+      return {
+        ok: true,
+        status: await service.status(),
+        summary: {
+          projects: report.projects,
+          files: report.files,
+          conflicts: report.conflicts,
+          pushed: report.pushed,
+        },
+      };
+    });
+    registerOperation("resolve-conflict", async (payload) => {
+      await service.resolveConflict(String(payload?.id ?? ""), payload?.choice);
+      return { ok: true, status: await service.status() };
+    });
+    registerOperation("history", async (payload) => {
+      const history = await service.history(String(payload?.slug ?? ""), { limit: payload?.limit });
+      return { ok: true, ...history };
+    });
+    registerOperation("restore-version", async (payload) => {
+      const restored = await service.restoreVersion(String(payload?.slug ?? ""), payload?.commit);
+      return { ok: true, ...restored, status: await service.status() };
+    });
+    registerOperation("portable-export", async (payload) => {
+      const exported = await service.portableExport(String(payload?.destination ?? ""));
+      return { ok: true, ...exported };
+    });
+    registerOperation("portable-scan", async (payload) => {
+      const scanned = await service.portableScan(String(payload?.source ?? ""));
+      return { ok: true, ...scanned };
+    });
+    registerOperation("portable-import", async (payload) => {
+      const imported = await service.portableImport(String(payload?.source ?? ""), {
+        projectSlugs: Array.isArray(payload?.projectSlugs) ? payload.projectSlugs : undefined,
+        strategy: payload?.strategy === "skip" ? "skip" : "replace",
+      });
+      return { ok: true, ...imported, status: await service.status() };
+    });
+    log("RPC routes registered");
+    boot("routes-registered", String(routeCtx === ctx ? "direct" : "injected"));
+  }
+
+  try {
+    const direct = typeof ctx.connection?.fetch?.register === "function";
+    boot("connection-check", direct ? "available" : "absent");
+    if (direct) {
+      registerRoutes(ctx);
+    } else {
+      boot("connection-missing");
+      warn("connection service unavailable; UI routes are disabled, commands still work");
+    }
+  } catch (error) {
+    boot("connection-inject-failed", String(error));
+    warn(`connection service unavailable (${String(error)}); UI routes are disabled, commands still work`);
+  }
+
+  /* ---------------- hidden diagnostic commands ---------------- */
+
+  try {
+    const dispose = ctx.commands.register({
+          name: "sync",
+          description: "Диагностика моста памяти (основной интерфейс — Настройки → Память проектов)",
+          input: { hint: "status | on | off | repo <owner/name> | sync | conflicts | resolve <id> local|remote|both" },
+          recordInput: false,
+          handler: async ({ rawInput }) => {
+            const input = String(rawInput ?? "").trim();
+            const [sub, ...rest] = input.length === 0 ? ["status"] : input.split(/\s+/u);
+            try {
+              if (sub === "on" || sub === "off") {
+                await service.setEnabled(sub === "on");
+                return { kind: "success", text: `Синхронизация ${sub === "on" ? "включена" : "выключена"}.` };
+              }
+              if (sub === "repo") {
+                await service.configure(rest.join(" "));
+                return { kind: "success", text: `Репозиторий подключён: ${rest.join(" ")}` };
+              }
+              if (sub === "sync") {
+                const report = await service.syncNow({ reason: "command" });
+                return { kind: "success", text: `Синхронизация: проектов ${report.projects}, файлов ${report.files}, конфликтов ${report.conflicts}, отправлено ${report.pushed ? "да" : "нет"}.` };
+              }
+              if (sub === "conflicts") {
+                const status = await service.status();
+                return { kind: "success", text: status.conflicts.length === 0 ? "Конфликтов нет." : status.conflicts.map((conflict) => `- ${conflict.projectSlug}/${conflict.path} (${conflict.id})`).join("\n") };
+              }
+              if (sub === "resolve") {
+                await service.resolveConflict(String(rest[0] ?? ""), rest[1]);
+                return { kind: "success", text: `Конфликт ${rest[0]} разрешён: ${rest[1] ?? "local"}.` };
+              }
+              const status = await service.status();
+              return { kind: "success", text: statusText(status) };
+            } catch (error) {
+              return { kind: "error", text: `Мост памяти: ${error instanceof Error ? error.message : String(error)}` };
+            }
+          },
+    });
+    ctx.effect(() => dispose, "memory-bridge: /sync diagnostic command");
+    log("diagnostic command registered: /sync");
+  } catch (error) {
+    warn(`command registration failed: ${String(error)}`);
+  }
+
+  function statusText(status) {
+    const lines = [
+      `Мост памяти проектов (${VERSION})`,
+      `Репозиторий: ${status.configured ? status.repo : "не подключён"}`,
+      `Синхронизация: ${status.enabled ? "включена" : "выключена"}${status.gitAvailable ? "" : " · git не найден"}`,
+      `Последняя синхронизация: ${status.lastSyncAt ?? "—"}`,
+      `Проекты: ${status.projects.length} · локальных правок: ${status.pending.localChanges} · конфликтов: ${status.conflicts.length}`,
+    ];
+    if (status.lastError) lines.push(`Ошибка: ${status.lastError}`);
+    lines.push("Основной интерфейс: Настройки → Память проектов.");
+    return lines.join("\n");
+  }
+
+  /* ---------------- diagnostics and cleanup ---------------- */
+
+  try {
+    globalThis.__DSH_MEMORY_BRIDGE__ = {
+      version: VERSION,
+      status: () => service.status(),
+    };
+  } catch {
+    /* ignore non-browser hosts */
+  }
+
+  ctx.effect(() => () => {
+    disposed = true;
+    if (syncTimer !== undefined) clearTimeout(syncTimer);
+    for (const timer of timeouts) clearTimeout(timer);
+    timeouts.clear();
+    for (const timer of intervals) clearInterval(timer);
+    intervals.clear();
+    try {
+      watcher?.close();
+    } catch {
+      /* already closed */
+    }
+    void st.logLine(home, "stopped");
+  }, "memory-bridge: cleanup");
+
+  try {
+    const me = await service.machine();
+    const config = await service.config();
+    log(`ready: ${VERSION}, machine ${me.machineId}, repo ${config.repo || "not configured"}`);
+  } catch (error) {
+    log(`ready: ${VERSION}; diagnostics unavailable: ${String(error)}`);
+  }
+}