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

package/src/gateway.ts

@@ -1,10 +1,8 @@
 import type { ConfigSource, ErrorSink } from "./types.js";
 import { createServer } from "node:http";
 import { randomUUID, randomBytes } from "node:crypto";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { StringDecoder } from "node:string_decoder";
 import { body, json, equalSecret } from "./http.js";
+import type { ApprovalAnswer } from "./harness.js";
 interface Run {
   created: number;
   events: any[];
@@ -12,6 +10,8 @@ interface Run {
   done: boolean;
   controller: AbortController;
   task?: Promise<void>;
+  approval?: (answer: ApprovalAnswer) => void;
+  approvalQueue: Promise<unknown>;
 }
 export class Gateway {
   agent: import("./agent.js").Agent;
@@ -19,8 +19,6 @@ export class Gateway {
   onError: ErrorSink;
   token: string;
   runs: Map<string, Run>;
-  external: Map<string, { input: any; created: number }>;
-  controllers: Set<AbortController>;
   closed: boolean;
   server: import("node:http").Server;
   url: string;
@@ -36,8 +34,6 @@ export class Gateway {
     Object.assign(this, { agent, config, onError });
     this.token = randomBytes(32).toString("hex");
     this.runs = new Map();
-    this.external = new Map();
-    this.controllers = new Set();
     this.closed = false;
   }
   async start() {
@@ -58,8 +54,6 @@ export class Gateway {
     this.gc = setInterval(() => {
       for (const [id, run] of this.runs)
         if (run.done && Date.now() - run.created > 600000) this.runs.delete(id);
-      for (const [id, run] of this.external)
-        if (Date.now() - run.created > 3600000) this.external.delete(id);
     }, 60000).unref();
   }
   async handle(req, res) {
@@ -73,7 +67,6 @@ export class Gateway {
     )
       return json(res, { error: "Not found" }, 404);
     const c = this.config();
-    if (c.externalHermes) return this.proxy(req, res, url.pathname, c);
     if (url.pathname === "/v1/runs" && req.method === "POST") {
       if (
         [...this.runs.values()].filter((r) => !r.done).length >= 16 ||
@@ -89,6 +82,7 @@ export class Gateway {
         listeners: new Set(),
         done: false,
         controller,
+        approvalQueue: Promise.resolve(),
       };
       this.runs.set(id, run);
       const emit = (event, payload) => {
@@ -110,6 +104,9 @@ export class Gateway {
           controller.signal,
           emit,
           data.instructions || "",
+          c.modules.chat.approvalEnabled
+            ? (request) => this.askApproval(run, request, emit)
+            : undefined,
         )
         .then(
           (output) => emit("run.completed", { output }),
@@ -150,113 +147,50 @@ export class Gateway {
       run.controller.abort();
       return json(res, { ok: true });
     }
-    return json(
-      res,
-      { error: "本地模式仅执行管理员允许的 MCP 工具，无待审批请求" },
-      409,
-    );
-  }
-  async proxy(req, res, pathname, c) {
-    let payload;
-    const controller = new AbortController();
-    this.controllers.add(controller);
-    res.on("close", () => controller.abort());
-    try {
-      if (req.method === "POST")
-        payload = JSON.parse((await body(req)).toString() || "{}");
-      const input = payload?.input;
-      if (pathname === "/v1/runs")
-        payload.instructions =
-          (await this.agent.context(input, "chat")) +
-          "\n\n" +
-          (payload.instructions || "");
-      const upstream = await fetch(c.hermesUrl.replace(/\/$/, "") + pathname, {
-        method: req.method,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${c.hermesKey}`,
-        },
-        body: payload ? JSON.stringify(payload) : undefined,
-        signal: AbortSignal.any([
-          controller.signal,
-          AbortSignal.timeout(c.timeoutSec * 1000),
-        ]),
-      });
-      if (pathname === "/v1/runs") {
-        const result = await upstream.json();
-        if (upstream.ok)
-          this.external.set(result.run_id || result.id, {
-            input,
-            created: Date.now(),
-          });
-        return json(res, result, upstream.status);
-      }
-      res.writeHead(upstream.status, {
-        "Content-Type":
-          upstream.headers.get("content-type") || "application/json",
-        "Cache-Control": "no-store",
-      });
-      if (pathname.endsWith("/events") && upstream.ok) {
-        let buffer = "",
-          eventName = "";
-        const decoder = new StringDecoder("utf8");
-        const id = pathname.split("/")[3];
-        for await (const chunk of Readable.fromWeb(
-          upstream.body as unknown as import("node:stream/web").ReadableStream,
-        )) {
-          res.write(chunk);
-          buffer += decoder.write(chunk);
-          let end;
-          while ((end = buffer.indexOf("\n")) >= 0) {
-            const line = buffer.slice(0, end).trim();
-            buffer = buffer.slice(end + 1);
-            if (line.startsWith("event:")) {
-              eventName = line.slice(6).trim();
-              continue;
-            }
-            if (!line.startsWith("data:")) continue;
-            let event;
-            try {
-              event = JSON.parse(line.slice(5));
-            } catch {
-              continue;
-            }
-            if (
-              event.event === "run.completed" ||
-              event.type === "run.completed" ||
-              eventName === "run.completed"
-            ) {
-              const run = this.external.get(id);
-              this.external.delete(id);
-              if (run) {
-                const task = this.agent
-                  .learn(
-                    typeof run.input === "string"
-                      ? run.input
-                      : JSON.stringify(run.input),
-                    event.output || "",
-                    "chat",
-                    this.shutdown.signal,
-                  )
-                  .catch(this.onError);
-                this.background.add(task);
-                void task.finally(() => this.background.delete(task));
-              }
-            }
-            eventName = "";
-          }
-        }
-        res.end();
-      } else
-        await pipeline(
-          Readable.fromWeb(
-            upstream.body as unknown as import("node:stream/web").ReadableStream,
-          ),
+    if (action === "approval" && req.method === "POST") {
+      const { choice } = JSON.parse((await body(req)).toString());
+      if (!["once", "deny"].includes(choice))
+        return json(
           res,
+          { error: "DSH 审批仅对本次操作生效，请选择 once 或 deny" },
+          400,
         );
-    } finally {
-      this.controllers.delete(controller);
+      if (!run.approval) return json(res, { error: "当前没有待审批请求" }, 409);
+      run.approval(choice === "once" ? "allowed-once" : "rejected");
+      return json(res, { ok: true });
     }
+    return json(res, { error: "Method not allowed" }, 405);
+  }
+  private askApproval(run: Run, request, emit): Promise<ApprovalAnswer> {
+    const task = run.approvalQueue.then(
+      () =>
+        new Promise<ApprovalAnswer>((resolve) => {
+          const signal = AbortSignal.any([
+            run.controller.signal,
+            ...(request.signal ? [request.signal] : []),
+          ]);
+          if (signal.aborted) return resolve("cancelled");
+          let timer: NodeJS.Timeout;
+          const finish = (answer: ApprovalAnswer) => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", abort);
+            if (run.approval === finish) run.approval = undefined;
+            resolve(answer);
+          };
+          const abort = () => finish("cancelled");
+          run.approval = finish;
+          signal.addEventListener("abort", abort, { once: true });
+          const seconds = this.config().modules.chat.approvalTimeoutSec;
+          if (seconds > 0)
+            timer = setTimeout(() => finish("rejected"), seconds * 1000);
+          emit("approval.request", {
+            command: request.toolName,
+            description: `${request.reason || "DSH 工具操作"}（仅支持本次允许 once / 拒绝 deny）`,
+          });
+        }),
+    );
+    run.approvalQueue = task.catch(() => {});
+    return task;
   }
   async close() {
     this.closed = true;
@@ -265,7 +199,6 @@ export class Gateway {
     for (const run of this.runs.values()) {
       run.controller.abort();
     }
-    for (const c of this.controllers) c.abort();
     this.server?.closeAllConnections();
     await new Promise<void>((resolve) =>
       this.server ? this.server.close(() => resolve()) : resolve(),

package/src/harness.ts

@@ -0,0 +1,253 @@
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import type { HostAPI } from "@dsh-plugin/dsh-loader";
+import type {
+  ConfigSource,
+  PluginPaths,
+  ChatMessage,
+  AgentEvent,
+  AvailableTool,
+} from "./types.js";
+import type { McpManager } from "./mcp.js";
+
+export type ApprovalAnswer = "allowed-once" | "rejected" | "cancelled";
+export type AskApproval = (request: {
+  toolName: string;
+  reason?: string;
+  signal?: AbortSignal;
+}) => Promise<ApprovalAnswer>;
+
+/** DSH owns model routing, the tool loop, policies, cancellation and session logs. */
+export class Harness {
+  private shutdown = new AbortController();
+  private tasks = new Set<Promise<string>>();
+  constructor(
+    private loader: HostAPI,
+    private config: ConfigSource,
+    private paths: PluginPaths,
+    private mcp: McpManager,
+  ) {}
+
+  run(
+    system: string,
+    input: unknown,
+    history: ChatMessage[] = [],
+    tools: AvailableTool[] = [],
+    signal?: AbortSignal,
+    onEvent: AgentEvent = () => {},
+    ask?: AskApproval,
+  ) {
+    const task = this.execute(
+      system,
+      input,
+      history,
+      tools,
+      signal,
+      onEvent,
+      ask,
+    );
+    this.tasks.add(task);
+    void task.finally(() => this.tasks.delete(task)).catch(() => {});
+    return task;
+  }
+
+  private async content(input: unknown): Promise<any[]> {
+    if (typeof input === "string") return [{ type: "text", text: input }];
+    if (!Array.isArray(input)) throw new Error("聊天输入必须是文本或消息数组");
+    const parts = input.flatMap((item) =>
+      item.role
+        ? item.role === "user"
+          ? typeof item.content === "string"
+            ? [{ type: "text", text: item.content }]
+            : item.content
+          : []
+        : [item],
+    );
+    const result = [];
+    for (const part of parts) {
+      if (part.type === "text" && typeof part.text === "string")
+        result.push({ type: "text", text: part.text });
+      else if (part.type === "image_url") {
+        const match = String(part.image_url?.url).match(
+          /^data:(image\/(?:png|jpeg|webp|gif));base64,\s*([A-Za-z0-9+/=\s]+)$/,
+        );
+        if (!match) throw new Error("图片须由聊天通道先转换为 data URL");
+        if (match[2].length > 28_000_000) throw new Error("图片超过大小上限");
+        const attachments = this.loader.services.get("attachments");
+        if (!attachments?.saveImage) throw new Error("DSH 附件服务不可用");
+        result.push({
+          type: "image",
+          attachment: await attachments.saveImage({
+            data: Buffer.from(match[2], "base64"),
+            mediaType: match[1],
+          }),
+        });
+      } else throw new Error(`不支持的消息内容：${part.type}`);
+    }
+    return result;
+  }
+
+  private async execute(
+    system: string,
+    input: unknown,
+    history: ChatMessage[],
+    available: AvailableTool[],
+    callerSignal: AbortSignal,
+    onEvent: AgentEvent,
+    ask?: AskApproval,
+  ): Promise<string> {
+    const signal = AbortSignal.any([
+      this.shutdown.signal,
+      AbortSignal.timeout(this.config().timeoutSec * 1000),
+      ...(callerSignal ? [callerSignal] : []),
+    ]);
+    signal.throwIfAborted();
+    const agents = this.loader.services.get("agents");
+    const defaults = this.loader.services.get("agentDefaultModel");
+    if (!agents?.create || !defaults?.currentSelection)
+      throw new Error("DSH Agent / 默认模型服务不可用，请检查宿主加载状态");
+    const selection = defaults.currentSelection();
+    if (!selection?.provider || !selection?.model)
+      throw new Error("请先在 DSH 的模型设置中选择默认模型");
+    const content = await this.content(input);
+    const cwd = path.join(this.paths.data, "sessions");
+    await mkdir(cwd, { recursive: true });
+    let error: Error;
+    let output = "",
+      attemptText = "";
+    let steps = 0;
+    const handle = await agents.create({
+      sessionId: randomUUID(),
+      meta: { cwd },
+      agentOptions: selection,
+      signal,
+      setup: (scope, agent) => {
+        const prompt = scope.get("systemPrompt"),
+          tools = scope.get("tools");
+        if (
+          !prompt?.section ||
+          !prompt?.variable ||
+          !tools?.restrict ||
+          !tools?.register
+        )
+          throw new Error("DSH 提示词或工具作用域服务不可用");
+        prompt.variable("synapse_context", () => system);
+        prompt.section({
+          name: "deployment:persona-prefix",
+          order: 0,
+          text: "{{synapse_context}}",
+        });
+        // Preserve the existing channel boundary: only explicitly allowed MCP tools.
+        // Actual calls still pass through the DSH executor and permission policies.
+        tools.restrict({ allow: [] });
+        for (const tool of available)
+          tools.register({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            output: {
+              schema: { type: "object", additionalProperties: true },
+              render: (_args, value) => [
+                { type: "text", text: JSON.stringify(value).slice(0, 40000) },
+              ],
+            },
+            execute: async (args, exec) => {
+              const started = Date.now();
+              let failed = false;
+              onEvent("tool.started", {
+                tool: `${tool.server}/${tool.rawName}`,
+              });
+              try {
+                return await this.mcp.call(tool, args, exec.signal);
+              } catch (e) {
+                failed = true;
+                throw e;
+              } finally {
+                onEvent("tool.completed", {
+                  tool: `${tool.server}/${tool.rawName}`,
+                  duration: (Date.now() - started) / 1000,
+                  error: failed,
+                });
+              }
+            },
+          });
+        scope.on("agent/pre-step", (event, next) => {
+          if (event.agent !== agent) return next();
+          if (++steps > this.config().maxToolRounds)
+            throw new Error("已达到任务步骤上限");
+          return next();
+        });
+        scope.on("agent/error", (event) => {
+          if (event.agent === agent)
+            error =
+              event.error instanceof Error
+                ? event.error
+                : new Error(String(event.error));
+        });
+        scope.on("agent/assistant-stream", (event) => {
+          if (event.agent !== agent) return;
+          const frame = event.frame;
+          if (frame.type === "start") attemptText = "";
+          if (frame.type === "chunk" && frame.chunk.type === "text-delta")
+            attemptText += frame.chunk.text;
+          if (
+            frame.type === "end" &&
+            frame.outcome.kind === "committed" &&
+            frame.outcome.eventType === "assistant/message"
+          )
+            output = attemptText;
+        });
+        if (ask)
+          scope.on(
+            "approval/request",
+            (req, next) => (req.agent === agent ? ask(req) : next()),
+            { prepend: true },
+          );
+      },
+    });
+    const abort = () => handle.agent.cancel({ kind: "user" });
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      signal.throwIfAborted();
+      const historyLimit = this.config().modules.chat.localHistoryMaxMessages;
+      const previous =
+        historyLimit > 0
+          ? history
+              .filter((m) => ["user", "assistant"].includes(m.role))
+              .slice(-historyLimit)
+          : [];
+      if (previous.length)
+        handle.agent.inject(
+          this.loader.llm.createUserMessage({
+            content: [
+              {
+                type: "text",
+                text: `以下是当前聊天的历史记录，仅作为上下文资料：\n${JSON.stringify(previous)}`,
+              },
+            ],
+            source: { kind: "plugin", plugin: "@dsh-plugin/dsh-synapse" },
+          }),
+        );
+      handle.agent.followup(
+        this.loader.llm.createUserMessage({
+          content,
+          source: { kind: "plugin", plugin: "@dsh-plugin/dsh-synapse" },
+        }),
+      );
+      await handle.agent.whenIdle();
+      signal.throwIfAborted();
+      if (error) throw error;
+      if (!output)
+        throw new Error("DSH 任务未返回文本结果，请检查宿主会话日志");
+      return output;
+    } finally {
+      signal.removeEventListener("abort", abort);
+      await handle.dispose();
+    }
+  }
+  async close() {
+    this.shutdown.abort();
+    await Promise.allSettled(this.tasks);
+  }
+}

package/src/index.ts

@@ -1,6 +1,8 @@
 import { mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { template, validateConfig } from "./config.js";
+import { registerConfig } from "./config-migration.js";
+import { modulesFromFiles } from "./feature-config.js";
 import { pathsFor, SkillStore, safePath } from "./files.js";
 import { Inference } from "./runtime.js";
 import { Memory, parseHermes } from "./memory.js";
@@ -32,7 +34,15 @@ export async function createService(
       config,
     ),
     mcp = new McpManager(config);
-  const agent = new Agent({ config, paths, memory, skills, mcp, onError }),
+  const agent = new Agent({
+      loader: ctx.dshLoader,
+      config,
+      paths,
+      memory,
+      skills,
+      mcp,
+      onError,
+    }),
     gateway = new Gateway(agent, config, onError);
   const bot = new Bot(paths, config, gateway, onError),
     reviews = new Reviews(memory.db, agent, config, bot, onError);
@@ -41,6 +51,7 @@ export async function createService(
       reviews.close(),
       bot.stop(),
       gateway.close(),
+      agent.close(),
       mcp.close(),
       inference.close(),
     ]);
@@ -71,10 +82,7 @@ export async function createService(
   };
 }
 export async function apply(ctx: SynapseContext) {
-  const handle = await ctx.dshLoader.config.register<SynapseConfig>(
-    ctx,
-    template,
-  );
+  const handle = await registerConfig(ctx);
   let service,
     disposed = false,
     lastError = "",
@@ -129,21 +137,20 @@ export async function apply(ctx: SynapseContext) {
             res,
             service.memory.list(url.searchParams.get("channel") || "chat"),
           );
-        if (req.method === "GET" && action === "features") {
-          const live = await service.bot.liveFeatures();
-          return json(
-            res,
-            service.config().features.map((f) => ({
-              id: f.id,
-              value: {
-                ...JSON.parse(f.json),
-                ...(live.find((x) => x.id === f.id)?.value || {}),
-              },
-            })),
-          );
-        }
         if (req.method === "POST") {
           const data = JSON.parse((await body(req)).toString() || "{}");
+          if (action === "features/refresh") {
+            const current = handle.get();
+            if (current.revision !== data.expectedRevision)
+              return json(res, { error: "配置已变更，请重新载入后同步" }, 409);
+            const modules = modulesFromFiles(
+              current.value.modules,
+              await service.bot.liveFeatures(),
+            );
+            validateConfig({ ...current.value, modules });
+            await handle.update({ modules }, current.revision);
+            return json(res, { ok: true });
+          }
           if (action === "skills/save")
             return json(
               res,

package/src/mcp.ts

@@ -15,7 +15,9 @@ export class McpManager {
   }
   async connect(name) {
     if (this.closed) throw new Error("MCP 已关闭");
-    const spec = this.config().mcp.find((x) => x.name === name && x.enabled);
+    const spec = this.config().mcpServers.find(
+      (x) => x.name === name && x.enabled,
+    );
     if (!spec) throw new Error("MCP 服务未启用");
     if (!this.connections.has(name))
       this.connections.set(
@@ -26,22 +28,32 @@ export class McpManager {
             spec.transport === "stdio"
               ? new StdioClientTransport({
                   command: spec.command,
-                  args: JSON.parse(spec.argsJson),
+                  args: spec.args,
                   env: {
                     PATH: process.env.PATH ?? "",
                     ...(process.env.SystemRoot
                       ? { SystemRoot: process.env.SystemRoot }
                       : {}),
-                    ...JSON.parse(spec.envJson),
+                    ...Object.fromEntries(
+                      spec.env.map((e) => [e.name, e.value]),
+                    ),
                   },
                   stderr: "ignore",
                 })
               : spec.transport === "sse"
                 ? new SSEClientTransport(new URL(spec.url), {
-                    requestInit: { headers: JSON.parse(spec.headersJson) },
+                    requestInit: {
+                      headers: Object.fromEntries(
+                        spec.headers.map((e) => [e.name, e.value]),
+                      ),
+                    },
                   })
                 : new StreamableHTTPClientTransport(new URL(spec.url), {
-                    requestInit: { headers: JSON.parse(spec.headersJson) },
+                    requestInit: {
+                      headers: Object.fromEntries(
+                        spec.headers.map((e) => [e.name, e.value]),
+                      ),
+                    },
                   });
           try {
             await client.connect(transport, { timeout: 15000 });
@@ -75,8 +87,8 @@ export class McpManager {
   }
   async available(): Promise<AvailableTool[]> {
     const result: AvailableTool[] = [];
-    for (const spec of this.config().mcp.filter((s) => s.enabled)) {
-      const allowed = new Set(spec.allowedTools.split(/\s+/).filter(Boolean));
+    for (const spec of this.config().mcpServers.filter((s) => s.enabled)) {
+      const allowed = new Set(spec.allowedTools);
       if (!allowed.size) continue;
       for (const tool of await this.list(spec.name))
         if (allowed.has(tool.name))
@@ -90,16 +102,16 @@ export class McpManager {
     }
     return result;
   }
-  async call(tool, args) {
-    const spec = this.config().mcp.find(
+  async call(tool, args, signal?: AbortSignal) {
+    const spec = this.config().mcpServers.find(
       (s) => s.name === tool.server && s.enabled,
     );
-    if (!spec?.allowedTools.split(/\s+/).includes(tool.rawName))
+    if (!spec?.allowedTools.includes(tool.rawName))
       throw new Error("工具不在允许列表");
     return (await this.connect(tool.server)).callTool(
       { name: tool.rawName, arguments: args },
       undefined,
-      { timeout: 60000 },
+      { timeout: 60000, signal },
     );
   }
   async close() {

package/src/panel.html

@@ -166,7 +166,8 @@
     <div id="content"></div>
     <footer class="muted">
       配置保存在当前 DSH
-      profile。模型首次使用时下载；聊天与审查记忆分开检索。<br />AGPL-3.0 ·
+      profile。本地记忆模型首次使用时下载；聊天与审查记忆分开检索。<br />AGPL-3.0
+      ·
       <a href="https://github.com/dsh-plugins/dsh-synapse">获取完整源码</a>
     </footer>
   </main>