@dsh-plugin/dsh-synapse 0.1.0-dev.41044228975 → 0.1.0-dev.41051739681

package/src/panel.ts

@@ -79,20 +79,24 @@ async function saveConfig() {
   view = saved.value;
   draft = structuredClone(view.value);
   dirty = false;
+  await render();
   notify("已保存。通道正在重新连接；可刷新状态检查结果。");
 }
-function field(parent, f, obj, key = f.key) {
+function field(parent, f, obj, key = f.key, path: string[] = []) {
+  const at = f.type === "group" ? path : [...path, String(key)];
   if (f.type === "group" || f.type === "object") {
     const box = node("fieldset");
     box.append(node("legend", f.label));
+    box.dataset.path = at.join(".");
     parent.append(box);
     const target = f.type === "object" ? (obj[key] ??= {}) : obj;
-    for (const child of f.fields) field(box, child, target);
+    for (const child of f.fields) field(box, child, target, child.key, at);
     return;
   }
   if (f.type === "array") {
     const box = node("fieldset");
     box.append(node("legend", f.label));
+    box.dataset.path = at.join(".");
     parent.append(box);
     const list = node("div");
     box.append(list);
@@ -100,7 +104,13 @@ function field(parent, f, obj, key = f.key) {
       list.replaceChildren();
       (obj[key] ||= []).forEach((_, i) => {
         const row = node("div", undefined, { className: "row" });
-        field(row, { ...f.item, label: `第 ${i + 1} 项` }, obj[key], i);
+        field(
+          row,
+          { ...f.item, label: `${f.item.label} ${i + 1}` },
+          obj[key],
+          i,
+          at,
+        );
         row.append(
           button("删除", () => {
             obj[key].splice(i, 1);
@@ -131,6 +141,25 @@ function field(parent, f, obj, key = f.key) {
       obj[key] = control.checked;
       dirty = true;
     };
+  } else if (f.type === "multiselect") {
+    control = node("select", undefined, {
+      multiple: true,
+      size: f.options.length,
+    });
+    for (const opt of f.options)
+      control.append(
+        node("option", opt.label, {
+          value: opt.value,
+          selected: (obj[key] || []).includes(opt.value),
+        }),
+      );
+    control.onchange = () => {
+      obj[key] = Array.from(
+        control.selectedOptions,
+        (option: HTMLOptionElement) => option.value,
+      );
+      dirty = true;
+    };
   } else if (f.type === "select") {
     control = node("select");
     for (const opt of f.options)
@@ -141,8 +170,7 @@ function field(parent, f, obj, key = f.key) {
       dirty = true;
     };
   } else {
-    const isJSON = String(key).toLowerCase().includes("json");
-    control = node(f.type === "textarea" || isJSON ? "textarea" : "input");
+    control = node(f.type === "textarea" ? "textarea" : "input");
     if (control.tagName === "INPUT")
       control.type =
         f.type === "password"
@@ -153,7 +181,9 @@ function field(parent, f, obj, key = f.key) {
     const secret = obj[key] && typeof obj[key] === "object";
     control.value = secret ? "" : (obj[key] ?? "");
     if (secret)
-      control.placeholder = "已保存（不回显）。留空保持不变；输入替换。";
+      control.placeholder = obj[key].set
+        ? "已保存（不回显）。留空保持不变；输入替换。"
+        : "尚未设置";
     control.oninput = () => {
       obj[key] = f.type === "number" ? Number(control.value) : control.value;
       dirty = true;
@@ -161,6 +191,7 @@ function field(parent, f, obj, key = f.key) {
     if (f.min !== undefined) control.min = f.min;
     if (f.max !== undefined) control.max = f.max;
   }
+  control.setAttribute("name", at.join("."));
   labeled(parent, f.label, control);
   if (f.description)
     parent.append(node("div", f.description, { className: "muted" }));
@@ -178,7 +209,7 @@ function defaultOf(f) {
   if (f.default !== undefined) return structuredClone(f.default);
   if (f.type === "object")
     return Object.fromEntries(f.fields.map((x) => [x.key, defaultOf(x)]));
-  if (f.type === "array") return [];
+  if (f.type === "array" || f.type === "multiselect") return [];
   if (f.type === "boolean") return false;
   if (f.type === "select") return f.options[0].value;
   if (f.type === "number") return f.min || 0;
@@ -191,34 +222,32 @@ async function configPanel(root, onlyMcp = false) {
       "p",
       onlyMcp
         ? "添加或修改 MCP 服务，保存后可预览工具。仅允许列表中的工具可被聊天自动调用。"
-        : "所有通道和上游功能均保存在当前 profile；保存使用修订号检查并发修改。",
+        : "按功能填写下方各项设置。聊天与审查使用 DSH 已配置的默认模型，保存后重新连接通道。",
     ),
   );
   for (const f of view.template.fields)
-    if (onlyMcp ? f.key === "mcp" : f.key !== "mcp") field(root, f, draft);
+    if (onlyMcp ? f.key === "mcpServers" : f.key !== "mcpServers")
+      field(root, f, draft);
   root.append(button("保存配置", saveConfig));
   if (!onlyMcp) {
     root.append(
-      button("载入上游功能 JSON 以预览 / 修改", async () => {
-        const rows = await api("features");
-        for (const row of rows) {
-          const f = draft.features.find((f) => f.id === row.id);
-          if (f) f.json = JSON.stringify(row.value, null, 2);
-        }
-        dirty = true;
+      button("同步聊天命令修改的功能设置", async () => {
+        if (
+          dirty &&
+          !confirm("当前修改尚未保存，同步将丢弃这些修改，是否继续？")
+        )
+          return;
+        await api("features/refresh", { expectedRevision: view.revision });
+        dirty = false;
         root.replaceChildren();
-        root.append(
-          node("p", "已载入当前功能配置，可能包含密钥。修改后保存。"),
-        );
-        for (const f of view.template.fields)
-          if (f.key !== "mcp") field(root, f, draft);
-        root.append(button("保存配置", saveConfig));
+        await configPanel(root);
+        notify("已同步当前功能设置，可继续在表单中修改。");
       }),
     );
   } else {
     const box = node("section");
     root.append(box);
-    for (const s of draft.mcp) {
+    for (const s of draft.mcpServers) {
       box.append(
         button(`预览 ${s.name} 工具`, async () => {
           preview.textContent = JSON.stringify(
@@ -297,7 +326,7 @@ async function skillPanel(root) {
       });
       revision = saved.revision;
       dirty = false;
-      notify("Skill 已保存，可被运行中的聊天检索。");
+      notify("Skill 已保存，可被对应通道的 DSH 任务检索。");
       await refresh();
     }),
     button("删除 Skill", async () => {

package/src/types.ts

@@ -11,11 +11,11 @@ export interface McpSpec {
   enabled: boolean;
   transport: "stdio" | "http" | "sse";
   command: string;
-  argsJson: string;
-  envJson: string;
+  args: string[];
+  env: { name: string; value: string }[];
   url: string;
-  headersJson: string;
-  allowedTools: string;
+  headers: { name: string; value: string }[];
+  allowedTools: string[];
 }
 export interface SynapseConfig {
   enabled: boolean;
@@ -26,15 +26,11 @@ export interface SynapseConfig {
   httpToken: string;
   wsToken: string;
   chromePath: string;
-  botJson: string;
-  llmUrl: string;
-  llmKey: string;
-  model: string;
+  userAgent: string;
+  logLevel: string;
+  tokenParams: string;
   timeoutSec: number;
   maxToolRounds: number;
-  externalHermes: boolean;
-  hermesUrl: string;
-  hermesKey: string;
   githubEnabled: boolean;
   githubToken: string;
   webhookSecret: string;
@@ -48,8 +44,74 @@ export interface SynapseConfig {
   learnMemory: boolean;
   learnSkills: boolean;
   maxMemories: number;
-  features: { id: string; json: string }[];
-  mcp: McpSpec[];
+  modules: {
+    management: {
+      groups: number[];
+      operators: number[];
+      discordOperators: string[];
+    };
+    parentheses: { groups: number[] };
+    poke: { groups: number[] };
+    minecraft: { groups: number[] };
+    modrinth: { groups: number[] };
+    command: { groups: number[] };
+    bili: { groups: number[]; follow: number[] };
+    github: { subscriptions: { repository: string; groups: number[] }[] };
+    welcome: { welcomes: { group: number[]; msg: string }[] };
+    discord: {
+      token: string;
+      bridges: {
+        guildId: string;
+        channelName: string;
+        group: string;
+        needReply: boolean;
+        needCmd: boolean;
+      }[];
+    };
+    chat: {
+      botName: string;
+      groups: number[];
+      admins: number[];
+      allowedUsers: number[];
+      blockedUsers: number[];
+      requireMention: boolean;
+      keywordTriggers: string[];
+      progressRateLimitSec: number;
+      progressAsImage: boolean;
+      progressMaxTools: number;
+      maxMessageLength: number;
+      forwardImages: boolean;
+      replyPerSentence: boolean;
+      compactMaxChars: number;
+      compactMaxLines: number;
+      localHistoryMaxMessages: number;
+      persistHistoryEnabled: boolean;
+      persistHistoryMax: number;
+      approvalEnabled: boolean;
+      approvalTimeoutSec: number;
+      reactionEnabled: boolean;
+      reactionEmojiQq: string;
+      reactionEmojiDiscord: string;
+      privateReactionFallbackText: boolean;
+      privateReceiptText: string;
+    };
+    peakValley: {
+      groups: number[];
+      mode: string;
+      time: {
+        start: string;
+        end: string;
+        days: string[];
+        mode: string;
+        msg: string;
+      }[];
+      peak_msg: string;
+      valley_msg: string;
+      cmd_peak_msg: string;
+      cmd_valley_msg: string;
+    };
+  };
+  mcpServers: McpSpec[];
 }
 export type ConfigSource = () => SynapseConfig;
 export type ErrorSink = (error: Error) => void;

package/test/config-migration.test.mjs

@@ -0,0 +1,137 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, readFile } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { defaultsFor } from "@dsh-plugin/dsh-loader/config";
+import { ConfigStore } from "../node_modules/@dsh-plugin/dsh-loader/dist/services/config.js";
+import { template } from "../lib/host/config.js";
+import { registerConfig } from "../lib/host/config-migration.js";
+import { featureFiles } from "../lib/host/feature-config.js";
+
+test("real loader migrates legacy JSON, preserves live commands, backs up and redacts secrets", async () => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "synapse-migrate-"));
+  const profile = path.join(home, "profiles", "test");
+  const directory = path.join(profile, "config", "dsh-synapse");
+  const bot = path.join(
+    profile,
+    "data",
+    "dsh-synapse",
+    "bot",
+    "configs",
+    "features",
+  );
+  await mkdir(directory, { recursive: true });
+  await mkdir(bot, { recursive: true });
+  const old = {
+    ...defaultsFor(template.fields),
+    profileDir: profile,
+    homeDir: home,
+    llmUrl: "https://obsolete.example/v1",
+    llmKey: "old-key",
+    externalHermes: true,
+    botJson: JSON.stringify({ logLevel: "warn" }),
+    features: [
+      {
+        id: "hermes",
+        json: JSON.stringify({
+          groups: [123],
+          apiKey: "old-api-key",
+          requireMention: false,
+        }),
+      },
+      {
+        id: "discord-bridge",
+        json: JSON.stringify({
+          token: "discord-secret",
+          bridges: {
+            "123#general": {
+              group: "456",
+              need_reply: "true",
+              need_cmd: "false",
+            },
+          },
+        }),
+      },
+      {
+        id: "peak-valley-timer",
+        json: JSON.stringify({ time: ["9:00-12:00 Mon-Fri"] }),
+      },
+    ],
+    mcp: [
+      {
+        name: "docs",
+        enabled: true,
+        transport: "stdio",
+        command: "node",
+        argsJson: '["server.mjs"]',
+        envJson: '{"TOKEN":"mcp-secret"}',
+        headersJson: "{}",
+        allowedTools: "read search",
+        url: "",
+      },
+    ],
+  };
+  await writeFile(
+    path.join(directory, "config.json"),
+    JSON.stringify({ formatVersion: 1, revision: 7, value: old }),
+  );
+  await writeFile(
+    path.join(bot, "hermes.json"),
+    JSON.stringify({ groups: [789], requireMention: true }),
+  );
+  const store = new ConfigStore(profile);
+  const ctx = { dshLoader: { config: store } };
+  const handle = await registerConfig(ctx);
+  try {
+    const { value: c, revision } = handle.get();
+    assert.equal(revision, 8);
+    assert.equal(c.logLevel, "warn");
+    assert.deepEqual(c.modules.chat.groups, [789]);
+    assert.equal(c.modules.discord.bridges[0].needReply, true);
+    assert.equal(c.modules.discord.bridges[0].needCmd, false);
+    assert.deepEqual(c.modules.peakValley.time[0].days, [
+      "Mon",
+      "Tue",
+      "Wed",
+      "Thu",
+      "Fri",
+    ]);
+    assert.deepEqual(c.mcpServers[0].allowedTools, ["read", "search"]);
+    for (const key of [
+      "llmUrl",
+      "llmKey",
+      "externalHermes",
+      "features",
+      "botJson",
+      "mcp",
+    ])
+      assert.equal(key in c, false);
+    assert(
+      !JSON.stringify(store.read("dsh-synapse")).includes("discord-secret"),
+    );
+    assert(!JSON.stringify(store.read("dsh-synapse")).includes("mcp-secret"));
+    const discord = featureFiles(c).find(
+      (f) => f.id === "discord-bridge",
+    ).value;
+    assert.equal(discord.bridges["123#general"].need_reply, "true");
+    const backup = JSON.parse(
+      await readFile(
+        path.join(profile, "data", "dsh-synapse", "config-before-forms.json"),
+        "utf8",
+      ),
+    );
+    assert.equal(backup.revision, 7);
+    assert.equal(backup.value.llmKey, "old-key");
+    assert.equal(
+      JSON.parse(await readFile(path.join(directory, "config.json"), "utf8"))
+        .value.llmKey,
+      undefined,
+    );
+  } finally {
+    handle.dispose();
+  }
+  const again = await registerConfig(ctx);
+  assert.equal(again.get().revision, 8);
+  again.dispose();
+});

package/test/core.test.mjs

@@ -14,6 +14,7 @@ import {
   repositoryAllowed,
   Reviews,
 } from "../lib/host/github.js";
+import { hostFixture } from "./fixtures/host.mjs";
 import { Agent } from "../lib/host/agent.js";
 import { Gateway } from "../lib/host/gateway.js";
 import { browserAuthorized } from "../lib/host/http.js";
@@ -39,10 +40,10 @@ const inference = {
     return docs.map((t) => (t.includes("重排") ? 1 : 0));
   },
 };
-test("defaults form valid config and reject malformed JSON / duplicate MCP", () => {
+test("defaults form valid config and reject invalid structured fields", () => {
   const c = config();
   assert.equal(validateConfig(c), c);
-  assert.throws(() => validateConfig({ ...c, botJson: "[]" }));
+  assert.throws(() => validateConfig({ ...c, mcpServers: [{ name: "x" }] }));
   assert.throws(() => validateConfig({ ...c, githubEnabled: true }));
   assert.throws(() => validateConfig({ ...c, recallK: 1.5 }));
 });
@@ -171,7 +172,22 @@ test("agent injects SOUL, retrieved skill and memory; tools execute only in chat
   await writeFile(path.join(p.profile, "SOUL.md"), "shared soul");
   const c = { ...config(), learnSkills: false, learnMemory: false };
   let calls = 0;
+  const host = hostFixture(
+    async ({ variables, tools, restrictions, options }) => {
+      assert.deepEqual(restrictions, [{ allow: [] }]);
+      assert.equal(options.agentOptions.model, "configured-model");
+      assert.match(
+        variables.get("synapse_context")(),
+        /shared soul|Review changes/,
+      );
+      assert.match(variables.get("synapse_context")(), /durable/);
+      if (tools.length)
+        await tools[0].execute({}, { signal: new AbortController().signal });
+      return "done";
+    },
+  );
   const a = new Agent({
+    loader: host.loader,
     paths: p,
     config: () => c,
     memory: { search: async () => [{ text: "durable", source: "test" }] },
@@ -191,24 +207,12 @@ test("agent injects SOUL, retrieved skill and memory; tools execute only in chat
       },
     },
   });
-  let rounds = 0;
-  a.completion = async (messages) => {
-    assert.match(messages[0].content, /shared soul|Review changes/);
-    assert.match(messages[0].content, /durable/);
-    return rounds++ === 0
-      ? {
-          role: "assistant",
-          tool_calls: [
-            { id: "a", function: { name: "mcp_0", arguments: "{}" } },
-          ],
-        }
-      : { role: "assistant", content: "done" };
-  };
   assert.equal(await a.run("question"), "done");
   assert.equal(calls, 1);
-  rounds = 1;
   assert.equal(await a.run("question", "review"), "done");
   assert.equal(calls, 1);
+  assert.equal(host.disposed.length, 2);
+  await a.close();
 });
 test("Gateway authenticates, serves replayable completion events, and stops runs", async () => {
   const g = new Gateway({ run: async () => "hello" }, config, () => {});
@@ -234,6 +238,68 @@ test("Gateway authenticates, serves replayable completion events, and stops runs
     await g.close();
   }
 });
+test("Gateway routes single-use DSH approval and cancels pending approval on stop", async () => {
+  const g = new Gateway(
+    {
+      run: async (
+        _input,
+        _channel,
+        _history,
+        signal,
+        _event,
+        _instructions,
+        ask,
+      ) => ask({ toolName: "docs/read", signal }),
+    },
+    config,
+    () => {},
+  );
+  await g.start();
+  const headers = {
+    Authorization: `Bearer ${g.token}`,
+    "Content-Type": "application/json",
+  };
+  const post = (url, value = {}) =>
+    fetch(g.url + url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(value),
+    });
+  try {
+    const { run_id: first } = await (
+      await post("/v1/runs", { input: "read" })
+    ).json();
+    assert.equal(
+      (await post(`/v1/runs/${first}/approval`, { choice: "always" })).status,
+      400,
+    );
+    assert.equal(
+      (await post(`/v1/runs/${first}/approval`, { choice: "once" })).status,
+      200,
+    );
+    const events = await (
+      await fetch(g.url + `/v1/runs/${first}/events`, { headers })
+    ).text();
+    assert.match(events, /approval.request/);
+    assert.match(events, /allowed-once/);
+    assert.equal(
+      (await post(`/v1/runs/${first}/approval`, { choice: "once" })).status,
+      409,
+    );
+    const { run_id: second } = await (
+      await post("/v1/runs", { input: "read" })
+    ).json();
+    await post(`/v1/runs/${second}/stop`);
+    assert.match(
+      await (
+        await fetch(g.url + `/v1/runs/${second}/events`, { headers })
+      ).text(),
+      /cancelled/,
+    );
+  } finally {
+    await g.close();
+  }
+});
 test("durable GitHub queue creates head-bound review, deduplicates publication and skips stale heads", async () => {
   const memory = new Memory(":memory:", inference, config);
   const c = {

package/test/fixtures/host.mjs

@@ -0,0 +1,133 @@
+import { randomUUID } from "node:crypto";
+
+// Contract fixture for the public native Agent lifecycle (not a second model API).
+export function hostFixture(execute = async () => "done") {
+  const created = [],
+    disposed = [],
+    attachments = [];
+  let selection = {
+    provider: "configured-provider",
+    model: "configured-model",
+  };
+  const loader = {
+    llm: {
+      createUserMessage: (input) => ({
+        id: randomUUID(),
+        role: "user",
+        ...input,
+      }),
+    },
+    services: {
+      get: (name) =>
+        ({
+          agentDefaultModel: { currentSelection: () => ({ ...selection }) },
+          attachments: {
+            saveImage: async (image) => {
+              attachments.push(image);
+              return { attachmentId: "image-1" };
+            },
+          },
+          agents: {
+            create: async (options) => {
+              const listeners = new Map(),
+                tools = [],
+                sections = [],
+                variables = new Map(),
+                injected = [],
+                restrictions = [];
+              const controller = new AbortController();
+              let task = Promise.resolve();
+              const emit = (name, data) =>
+                listeners.get(name)?.({ agent, ...data });
+              const scope = {
+                get: (name) =>
+                  ({
+                    systemPrompt: {
+                      section: (s) => sections.push(s),
+                      variable: (name, fn) => variables.set(name, fn),
+                    },
+                    tools: {
+                      restrict: (filter) => restrictions.push(filter),
+                      register: (tool) => tools.push(tool),
+                    },
+                  })[name],
+                on: (name, fn) => listeners.set(name, fn),
+              };
+              const agent = {
+                id: options.sessionId,
+                ctx: scope,
+                inject: (message) => injected.push(message),
+                cancel: () => controller.abort(),
+                followup: (message) => {
+                  task = (async () => {
+                    try {
+                      await listeners.get("agent/pre-step")?.(
+                        { agent },
+                        async () => ({ kind: "enter" }),
+                      );
+                      const output = await execute({
+                        options,
+                        message,
+                        injected,
+                        tools,
+                        sections,
+                        variables,
+                        restrictions,
+                        signal: controller.signal,
+                        emit,
+                        approve: (req) =>
+                          listeners.get("approval/request")?.(
+                            { agent, ...req },
+                            async () => "unavailable",
+                          ),
+                      });
+                      emit("agent/assistant-stream", {
+                        frame: { type: "start" },
+                      });
+                      emit("agent/assistant-stream", {
+                        frame: {
+                          type: "chunk",
+                          chunk: { type: "text-delta", text: output },
+                        },
+                      });
+                      emit("agent/assistant-stream", {
+                        frame: {
+                          type: "end",
+                          outcome: {
+                            kind: "committed",
+                            eventType: "assistant/message",
+                          },
+                        },
+                      });
+                    } catch (error) {
+                      emit("agent/error", { error });
+                    }
+                  })();
+                },
+                whenIdle: () => task,
+              };
+              await options.setup(scope, agent);
+              created.push({ options, agent, tools, restrictions, injected });
+              return {
+                agent,
+                dispose: async () => {
+                  disposed.push(agent.id);
+                  controller.abort();
+                  await task;
+                },
+              };
+            },
+          },
+        })[name],
+    },
+  };
+  return {
+    loader,
+    created,
+    disposed,
+    attachments,
+    select: (value) => {
+      selection = value;
+    },
+  };
+}