@dsh-plugin/dsh-synapse 0.0.0-stage → 0.1.0-dev.41044228975

package/src/bot.ts

@@ -0,0 +1,173 @@
+import type { ConfigSource, PluginPaths, ErrorSink } from "./types.js";
+import { fork } from "node:child_process";
+import { mkdir, cp, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { once } from "node:events";
+import { atomicWrite } from "./files.js";
+export class Bot {
+  paths: PluginPaths;
+  config: ConfigSource;
+  gateway: import("./gateway.js").Gateway;
+  onError: ErrorSink;
+  state: string;
+  stopping: boolean;
+  child: import("node:child_process").ChildProcess;
+  stderr: string;
+
+  constructor(
+    paths: PluginPaths,
+    config: ConfigSource,
+    gateway: import("./gateway.js").Gateway,
+    onError: ErrorSink,
+  ) {
+    Object.assign(this, { paths, config, gateway, onError });
+    this.state = "stopped";
+    this.stopping = false;
+  }
+  async start() {
+    const c = this.config();
+    if (!c.enabled) return;
+    const cwd = path.join(this.paths.data, "bot");
+    await mkdir(path.join(cwd, "configs", "features"), { recursive: true });
+    await cp(
+      fileURLToPath(
+        new URL("../../vendor/gugle-chat-bot/src", import.meta.url),
+      ),
+      path.join(cwd, "src"),
+      { recursive: true },
+    );
+    const base = JSON.parse(c.botJson);
+    await atomicWrite(
+      path.join(cwd, "configs", "bot-config.json"),
+      JSON.stringify({
+        ...base,
+        httpUrl: c.httpUrl,
+        wsUrl: c.wsUrl,
+        httpToken: c.httpToken,
+        wsToken: c.wsToken,
+        chromePath: c.chromePath,
+        githubAllowedRepositories: c.repositories.split(/\s+/).filter(Boolean),
+        logLevel: base.logLevel || "info",
+      }),
+    );
+    // Existing feature files contain live /github subscribe and admin changes.
+    // Only replace a module when its dashboard configuration has changed.
+    let previous = {};
+    const marker = path.join(cwd, "applied-config.json");
+    try {
+      previous = JSON.parse(await readFile(marker, "utf8"));
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    const applied = {};
+    for (const f of c.features) {
+      applied[f.id] = f.json;
+      const file = path.join(
+        cwd,
+        "configs",
+        ...(f.id === "peak-valley-timer" ? [] : ["features"]),
+        `${f.id}.json`,
+      );
+      let feature = JSON.parse(f.json);
+      if (previous[f.id] === f.json)
+        try {
+          feature = JSON.parse(await readFile(file, "utf8"));
+        } catch (e) {
+          if (e.code !== "ENOENT") throw e;
+        }
+      if (f.id === "hermes")
+        feature = {
+          ...feature,
+          apiUrl: this.gateway.url,
+          apiKey: this.gateway.token,
+        };
+      await atomicWrite(file, JSON.stringify(feature, null, 2));
+    }
+    await atomicWrite(marker, JSON.stringify(applied));
+    this.stopping = false;
+    this.state = "starting";
+    this.child = fork(
+      fileURLToPath(new URL("../bot.cjs", import.meta.url)),
+      [],
+      {
+        cwd,
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "pipe", "ipc"],
+        env: {
+          ...process.env,
+          SYNAPSE_PROFILE: this.paths.profile,
+          SYNAPSE_HOME: this.paths.home,
+        },
+      },
+    );
+    this.stderr = "";
+    this.child.stderr?.on("data", (chunk) => {
+      this.stderr = (this.stderr + chunk.toString()).slice(-6000);
+    });
+    this.child.on("message", (msg: { type?: string }) => {
+      if (msg?.type === "ready") this.state = "running";
+      if (msg?.type === "restart" && !this.stopping)
+        void this.restart().catch(this.onError);
+    });
+    this.child.on("error", (e) => {
+      this.state = "error";
+      this.onError(e);
+    });
+    this.child.on("exit", (code) => {
+      this.state = this.stopping ? "stopped" : `exited (${code})`;
+    });
+    // Parent disconnect guarantees the upstream child cannot outlive its owner.
+  }
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+  notify(event, payload) {
+    if (this.child?.connected)
+      this.child.send({ type: "github", event, payload }, (e) => {
+        if (e) this.onError(e);
+      });
+  }
+  async stop() {
+    this.stopping = true;
+    const child = this.child;
+    this.child = null;
+    if (child && child.exitCode === null) {
+      const done = once(child, "exit").catch(() => {});
+      child.kill();
+      await done;
+    }
+    this.state = "stopped";
+  }
+  async liveFeatures() {
+    const root = path.join(this.paths.data, "bot", "configs", "features");
+    let files;
+    try {
+      files = await readdir(root);
+    } catch (e) {
+      if (e.code === "ENOENT") return [];
+      throw e;
+    }
+    const result = [];
+    for (const file of files.filter((f) => f.endsWith(".json"))) {
+      const data = JSON.parse(await readFile(path.join(root, file), "utf8"));
+      if (file === "hermes.json") {
+        delete data.apiKey;
+        delete data.apiUrl;
+      }
+      result.push({ id: file.slice(0, -5), value: data });
+    }
+    try {
+      result.push({
+        id: "peak-valley-timer",
+        value: JSON.parse(
+          await readFile(path.join(root, "../peak-valley-timer.json"), "utf8"),
+        ),
+      });
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    return result;
+  }
+}

package/src/client.ts

@@ -0,0 +1,20 @@
+export const inject = ["dshLoaderUi"];
+export function apply(ctx) {
+  const ui = ctx.dshLoaderUi ?? ctx.get?.("dshLoaderUi");
+  ctx.effect(() =>
+    ui.mount("settings.nav", {
+      id: "synapse:management",
+      render(mount) {
+        const link = document.createElement("a");
+        link.href = "/synapse";
+        link.target = "_blank";
+        link.rel = "noopener";
+        link.textContent = "Synapse · 通道与记忆";
+        link.style.cssText =
+          "display:block;padding:10px;color:inherit;font:inherit";
+        mount.append(link);
+        return () => link.remove();
+      },
+    }),
+  );
+}

package/src/config.ts

@@ -0,0 +1,217 @@
+import { defineConfig, type ConfigField } from "@dsh-plugin/dsh-loader/config";
+const text = (
+  key,
+  label,
+  value = "",
+  type: ConfigField["type"] = "text",
+): ConfigField => ({ type, key, label, default: value });
+const flag = (key, label, value = false): ConfigField => ({
+  type: "boolean",
+  key,
+  label,
+  default: value,
+});
+const num = (
+  key,
+  label,
+  value: number,
+  min: number,
+  max: number,
+): ConfigField => ({ type: "number", key, label, default: value, min, max });
+export const FEATURES = [
+  "management",
+  "parentheses",
+  "poke",
+  "minecraft",
+  "modrinth",
+  "bili",
+  "command",
+  "github",
+  "welcome",
+  "discord-bridge",
+  "hermes",
+  "peak-valley-timer",
+];
+export const template = defineConfig({
+  id: "dsh-synapse",
+  packageName: "@dsh-plugin/dsh-synapse",
+  title: "Synapse · 通道与记忆",
+  description:
+    "保存后重新连接通道。Skill、MCP、Hermes 导入位于 Synapse 管理面板。密码仅保存在当前 profile。",
+  fields: [
+    flag("enabled", "启用机器人"),
+    text("profileDir", "当前 profile 绝对路径（自动定位失败时填写）"),
+    text("homeDir", "DSH Home 绝对路径（默认 profile 上两级）"),
+    {
+      type: "group",
+      label: "OneBot · NapCat / Snowluma",
+      fields: [
+        text("httpUrl", "HTTP 地址", "http://127.0.0.1:3000"),
+        text("wsUrl", "WebSocket 地址", "ws://127.0.0.1:3001"),
+        text("httpToken", "HTTP Token", "", "password"),
+        text("wsToken", "WS Token", "", "password"),
+        text("chromePath", "Chrome / Chromium 路径"),
+        text("botJson", "上游 bot-config 扩展 JSON", "{}", "textarea"),
+      ],
+    },
+    {
+      type: "group",
+      label: "AI 对话 / 审查",
+      fields: [
+        text("llmUrl", "OpenAI 兼容 API 地址", "https://api.deepseek.com/v1"),
+        text("llmKey", "API Key", "", "password"),
+        text("model", "模型", "deepseek-chat"),
+        num("timeoutSec", "请求超时（秒）", 120, 5, 600),
+        num("maxToolRounds", "工具轮数上限", 6, 1, 20),
+        flag("externalHermes", "使用外部 Hermes（保留其工具及审批）"),
+        text("hermesUrl", "Hermes API 地址", "http://127.0.0.1:8642"),
+        text("hermesKey", "Hermes Key", "", "password"),
+      ],
+    },
+    {
+      type: "group",
+      label: "GitHub",
+      fields: [
+        flag("githubEnabled", "启用 Webhook 审查"),
+        text("githubToken", "GitHub Token", "", "password"),
+        text("webhookSecret", "Webhook Secret", "", "password"),
+        text(
+          "repositories",
+          "允许的 owner/repo（每行一个，支持 owner/*）",
+          "",
+          "textarea",
+        ),
+        flag("publishReviews", "自动发布审查评论"),
+        num("maxDiffChars", "最大差异字符数", 80000, 1000, 500000),
+      ],
+    },
+    {
+      type: "group",
+      label: "RAG / Skill 自总结",
+      fields: [
+        flag("ragEnabled", "启用本地混合记忆", true),
+        num("recallK", "初步召回数量", 50, 1, 200),
+        num("memoryK", "上下文记忆条数", 8, 1, 50),
+        flag("reranker", "启用本地 bge-reranker-base"),
+        flag("learnMemory", "总结重要事项到长期记忆", true),
+        flag("learnSkills", "自动总结 Skill", true),
+        num("maxMemories", "最大记忆条数", 20000, 100, 1000000),
+      ],
+    },
+    {
+      type: "array",
+      key: "features",
+      label: "gugle-chat-bot 全量功能配置（JSON）",
+      default: FEATURES.map((id) => ({
+        id,
+        json: JSON.stringify(
+          id === "github"
+            ? { version: 2, groups: {} }
+            : id === "welcome"
+              ? { version: 1, welcomes: [] }
+              : id === "discord-bridge"
+                ? { version: 1, token: "", bridges: {} }
+                : { version: 1, groups: [] },
+          null,
+          2,
+        ),
+      })),
+      item: {
+        type: "object",
+        label: "功能",
+        fields: [
+          {
+            type: "select",
+            key: "id",
+            label: "模块",
+            options: FEATURES.map((value) => ({ label: value, value })),
+          },
+          text("json", "配置 JSON（可能含密钥）", "{}", "password"),
+        ],
+      },
+    },
+    {
+      type: "array",
+      key: "mcp",
+      label: "MCP 服务",
+      item: {
+        type: "object",
+        label: "服务",
+        fields: [
+          text("name", "名称"),
+          flag("enabled", "启用", true),
+          {
+            type: "select",
+            key: "transport",
+            label: "传输",
+            options: [
+              { label: "stdio", value: "stdio" },
+              { label: "Streamable HTTP", value: "http" },
+              { label: "SSE", value: "sse" },
+            ],
+          },
+          text("command", "命令"),
+          text("argsJson", "参数 JSON", "[]", "textarea"),
+          text("envJson", "环境变量 JSON", "{}", "password"),
+          text("url", "URL"),
+          text("headersJson", "HTTP 请求头 JSON", "{}", "password"),
+          text(
+            "allowedTools",
+            "允许自动调用的工具名称（每行一个）",
+            "",
+            "textarea",
+          ),
+        ],
+      },
+    },
+  ],
+});
+export function parseObject(raw) {
+  const value = JSON.parse(raw);
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("需要 JSON 对象");
+  return value;
+}
+export function validateConfig(c) {
+  parseObject(c.botJson);
+  const ids = new Set();
+  for (const f of c.features) {
+    if (!FEATURES.includes(f.id) || ids.has(f.id))
+      throw new Error("功能 ID 无效或重复");
+    ids.add(f.id);
+    parseObject(f.json);
+  }
+  const names = new Set();
+  for (const s of c.mcp) {
+    if (!/^[a-zA-Z0-9_-]{1,32}$/.test(s.name) || names.has(s.name))
+      throw new Error("MCP 名称无效或重复");
+    names.add(s.name);
+    const args = JSON.parse(s.argsJson);
+    if (!Array.isArray(args) || args.some((x) => typeof x !== "string"))
+      throw new Error("MCP 参数必须是字符串数组");
+    for (const raw of [s.envJson, s.headersJson])
+      if (Object.values(parseObject(raw)).some((x) => typeof x !== "string"))
+        throw new Error("MCP 环境变量和请求头必须是字符串");
+    if (s.transport !== "stdio" && !/^https?:\/\//.test(s.url))
+      throw new Error("MCP URL 无效");
+  }
+  if (
+    c.githubEnabled &&
+    (!c.webhookSecret || !c.githubToken || !c.repositories.trim())
+  )
+    throw new Error("启用 GitHub 需要 Secret、Token 和仓库允许列表");
+  for (const k of [
+    "recallK",
+    "memoryK",
+    "maxMemories",
+    "maxToolRounds",
+    "timeoutSec",
+    "maxDiffChars",
+  ])
+    if (!Number.isInteger(c[k])) throw new Error(`${k} 必须是整数`);
+  for (const key of ["httpUrl", "llmUrl", "hermesUrl"])
+    if (!/^https?:\/\//.test(c[key]))
+      throw new Error(`${key} 必须是 HTTP(S) URL`);
+  if (!/^wss?:\/\//.test(c.wsUrl)) throw new Error("wsUrl 必须是 WS(S) URL");
+  return c;
+}

package/src/files.ts

@@ -0,0 +1,206 @@
+import type { PluginPaths, Skill } from "./types.js";
+import {
+  mkdir,
+  readFile,
+  writeFile,
+  rename,
+  lstat,
+  readdir,
+  unlink,
+} from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID, createHash } from "node:crypto";
+export const ID = "dsh-synapse";
+export function pathsFor(ctx, c) {
+  let profile = c.profileDir;
+  const url =
+    ctx.baseUrl ??
+    ctx.get?.("loader")?.ctx?.baseUrl ??
+    ctx.get?.("loader")?.config?.baseUrl;
+  if (!profile && typeof url === "string" && url.startsWith("file:"))
+    profile = fileURLToPath(new URL(".", url));
+  if (!profile || !path.isAbsolute(profile))
+    throw new Error("无法定位当前 profile；请填写 profileDir 绝对路径");
+  const home = c.homeDir || path.resolve(profile, "../..");
+  if (!path.isAbsolute(home)) throw new Error("homeDir 必须是绝对路径");
+  return {
+    profile,
+    home,
+    data: path.join(profile, "data", ID),
+    skills: path.join(profile, "skills"),
+  };
+}
+export async function safePath(root, ...parts) {
+  const target = path.resolve(root, ...parts),
+    relative = path.relative(path.resolve(root), target);
+  if (relative.startsWith("..") || path.isAbsolute(relative))
+    throw new Error("路径越界");
+  // System ancestors may be symlinks (macOS /var -> /private/var).
+  // The configured root itself and every path inside it must stay link-free.
+  let current = path.resolve(root);
+  for (const part of ["", ...relative.split(path.sep).filter(Boolean)]) {
+    current = path.join(current, part);
+    try {
+      if ((await lstat(current)).isSymbolicLink())
+        throw new Error("不允许符号链接路径");
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+  return target;
+}
+export async function atomicWrite(file, content) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmp, content, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o600,
+    });
+    await rename(tmp, file);
+  } finally {
+    await unlink(tmp).catch((e) => {
+      if (e.code !== "ENOENT") throw e;
+    });
+  }
+}
+export async function promptFor(paths, channel) {
+  const name = channel === "review" ? "AGENTS.md" : "SOUL.md";
+  for (const root of [paths.profile, paths.home]) {
+    try {
+      return await readFile(await safePath(root, name), "utf8");
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+  return channel === "review"
+    ? "Review changes for concrete defects. Explain evidence and actionable fixes."
+    : "你是一位友善、准确的聊天助手。";
+}
+export function skillName(name) {
+  if (
+    !/^[a-z0-9][a-z0-9_-]{0,63}$/.test(name) ||
+    /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i.test(name)
+  )
+    throw new Error("Skill 名称无效");
+  return name;
+}
+export const revisionOf = (text) =>
+  createHash("sha256").update(text).digest("hex");
+export class SkillStore {
+  paths: PluginPaths;
+  queue: Promise<unknown>;
+
+  constructor(paths: PluginPaths) {
+    this.paths = paths;
+    this.queue = Promise.resolve();
+  }
+  async list() {
+    const found = new Map<string, Skill>();
+    for (const root of [
+      path.join(this.paths.home, "skills"),
+      this.paths.skills,
+    ]) {
+      let names;
+      try {
+        names = await readdir(await safePath(root));
+      } catch (e) {
+        if (e.code === "ENOENT") continue;
+        throw e;
+      }
+      for (const entry of names) {
+        const name = entry.endsWith(".md") ? entry.slice(0, -3) : entry;
+        try {
+          skillName(name);
+        } catch {
+          continue;
+        }
+        const file = await safePath(
+          root,
+          entry,
+          ...(entry.endsWith(".md") ? [] : ["SKILL.md"]),
+        );
+        try {
+          const content = await readFile(file, "utf8");
+          found.set(name, {
+            name,
+            content,
+            revision: revisionOf(content),
+            inherited: root !== this.paths.skills,
+          });
+        } catch (e) {
+          if (!["ENOENT", "EISDIR", "ENOTDIR"].includes(e.code)) throw e;
+        }
+      }
+    }
+    return [...found.values()];
+  }
+  mutate(fn) {
+    const task = this.queue.then(fn);
+    this.queue = task.catch(() => {});
+    return task;
+  }
+  save(name, content, revision = null) {
+    return this.mutate(async () => {
+      skillName(name);
+      if (
+        typeof content !== "string" ||
+        !content.trim() ||
+        content.length > 200000
+      )
+        throw new Error("Skill 文档为空或过大");
+      const current = (await this.list()).find((x) => x.name === name);
+      if ((current?.revision ?? null) !== revision)
+        throw Object.assign(new Error("Skill 已变更，请重新载入"), {
+          status: 409,
+        });
+      const flat = await safePath(this.paths.skills, `${name}.md`);
+      const useFlat = await lstat(flat).then(
+        () => true,
+        (e) => {
+          if (e.code === "ENOENT") return false;
+          throw e;
+        },
+      );
+      await atomicWrite(
+        useFlat ? flat : await safePath(this.paths.skills, name, "SKILL.md"),
+        content,
+      );
+      return { name, revision: revisionOf(content) };
+    });
+  }
+  remove(name, revision) {
+    return this.mutate(async () => {
+      skillName(name);
+      const current = (await this.list()).find((x) => x.name === name);
+      if (!current || current.inherited)
+        throw new Error("只能删除当前 profile 的 Skill");
+      if (current.revision !== revision)
+        throw Object.assign(new Error("Skill 已变更"), { status: 409 });
+      for (const parts of [[name, "SKILL.md"], [`${name}.md`]])
+        await unlink(await safePath(this.paths.skills, ...parts)).catch((e) => {
+          if (e.code !== "ENOENT") throw e;
+        });
+    });
+  }
+  async retrieve(query, channel) {
+    const terms = query.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) || [];
+    return (await this.list())
+      .filter(
+        (x) =>
+          !x.name.startsWith("auto-") || x.name.startsWith(`auto-${channel}-`),
+      )
+      .map((x) => ({
+        ...x,
+        score: terms.reduce(
+          (n, t) => n + (x.content.toLowerCase().includes(t) ? 1 : 0),
+          0,
+        ),
+      }))
+      .filter((x) => x.score > 0)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, 3);
+  }
+}