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

package/src/runtime.ts

@@ -0,0 +1,164 @@
+import { Worker } from "node:worker_threads";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import path from "node:path";
+const VERSION = "3.8.1";
+export async function installRuntime(root: string, signal?: AbortSignal) {
+  await mkdir(root, { recursive: true });
+  const file = path.join(root, "package.json");
+  const manifest = {
+    name: "dsh-synapse-inference-runtime",
+    private: true,
+    version: "1.0.0",
+    dependencies: { "@huggingface/transformers": VERSION },
+  };
+  try {
+    const req = createRequire(file);
+    req.resolve("@huggingface/transformers");
+    const pkg = JSON.parse(
+      await readFile(
+        path.join(root, "node_modules/@huggingface/transformers/package.json"),
+        "utf8",
+      ),
+    );
+    if (pkg.version === VERSION) return file;
+  } catch {}
+  await writeFile(file, JSON.stringify(manifest, null, 2));
+  // npm is launched without a command shell, including on Windows.
+  const candidates = [
+    process.env.npm_execpath,
+    path.join(
+      path.dirname(process.execPath),
+      "node_modules/npm/bin/npm-cli.js",
+    ),
+    path.resolve(
+      path.dirname(process.execPath),
+      "../lib/node_modules/npm/bin/npm-cli.js",
+    ),
+    ...(process.env.PATH || "")
+      .split(path.delimiter)
+      .flatMap((dir) => [
+        path.join(dir, "node_modules/npm/bin/npm-cli.js"),
+        path.resolve(dir, "../lib/node_modules/npm/bin/npm-cli.js"),
+      ]),
+    ...(process.platform === "win32"
+      ? []
+      : ["/usr/share/nodejs/npm/bin/npm-cli.js"]),
+  ].filter(Boolean);
+  let npm;
+  for (const c of candidates) {
+    try {
+      await readFile(c);
+      npm = c;
+      break;
+    } catch {}
+  }
+  if (!npm) throw new Error("找不到 npm-cli.js；请安装 Node.js 的 npm 组件");
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      [npm, "install", "--omit=dev", "--no-audit", "--no-fund"],
+      { cwd: root, windowsHide: true, stdio: "ignore", signal },
+    );
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error("推理运行时安装超时"));
+    }, 600000);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      code === 0
+        ? resolve()
+        : reject(new Error(`推理运行时安装失败 (${code})`));
+    });
+  });
+  return file;
+}
+export class Inference {
+  data: string;
+  pending: Map<
+    number,
+    {
+      resolve: (value: number[]) => void;
+      reject: (error: Error) => void;
+      timer: NodeJS.Timeout;
+    }
+  >;
+  counter: number;
+  closed: boolean;
+  starting: Promise<void>;
+  worker: Worker;
+  installer = new AbortController();
+
+  constructor(data: string) {
+    this.data = data;
+    this.pending = new Map();
+    this.counter = 0;
+    this.closed = false;
+  }
+  async start() {
+    if (this.closed) throw new Error("推理 Worker 已关闭");
+    if (!this.starting)
+      this.starting = (async () => {
+        const manifest = await installRuntime(
+          path.join(this.data, "runtime"),
+          this.installer.signal,
+        );
+        if (this.closed) throw new Error("推理 Worker 已关闭");
+        this.worker = new Worker(
+          new URL("./inference-worker.js", import.meta.url),
+          { workerData: { manifest, cache: path.join(this.data, "models") } },
+        );
+        this.worker.on("message", ({ id, value, error }) => {
+          const p = this.pending.get(id);
+          if (!p) return;
+          clearTimeout(p.timer);
+          this.pending.delete(id);
+          error ? p.reject(new Error(error)) : p.resolve(value);
+        });
+        const fail = (e) => {
+          for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(e);
+          }
+          this.pending.clear();
+        };
+        this.worker.on("error", fail);
+        this.worker.on("exit", (code) => {
+          this.closed = true;
+          fail(new Error(`推理 Worker 退出 (${code})`));
+        });
+      })();
+    return this.starting;
+  }
+  async call(method, args) {
+    await this.start();
+    if (this.closed) throw new Error("推理 Worker 已关闭");
+    if (this.pending.size >= 100) throw new Error("推理队列已满");
+    return new Promise<number[]>((resolve, reject) => {
+      const id = ++this.counter;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("模型下载或推理超时"));
+      }, 600000);
+      this.pending.set(id, { resolve, reject, timer });
+      this.worker.postMessage({ id, method, args });
+    });
+  }
+  embed(text, query = false) {
+    return this.call("embed", { text, query });
+  }
+  rerank(query, documents) {
+    return this.call("rerank", { query, documents });
+  }
+  async close() {
+    this.closed = true;
+    this.installer.abort();
+    await this.starting?.catch(() => {});
+    await this.worker?.terminate();
+  }
+}

package/src/types.ts

@@ -0,0 +1,106 @@
+import type { HostAPI, CordisContext } from "@dsh-plugin/dsh-loader";
+export type Channel = "chat" | "review";
+export interface PluginPaths {
+  profile: string;
+  home: string;
+  data: string;
+  skills: string;
+}
+export interface McpSpec {
+  name: string;
+  enabled: boolean;
+  transport: "stdio" | "http" | "sse";
+  command: string;
+  argsJson: string;
+  envJson: string;
+  url: string;
+  headersJson: string;
+  allowedTools: string;
+}
+export interface SynapseConfig {
+  enabled: boolean;
+  profileDir: string;
+  homeDir: string;
+  httpUrl: string;
+  wsUrl: string;
+  httpToken: string;
+  wsToken: string;
+  chromePath: string;
+  botJson: string;
+  llmUrl: string;
+  llmKey: string;
+  model: string;
+  timeoutSec: number;
+  maxToolRounds: number;
+  externalHermes: boolean;
+  hermesUrl: string;
+  hermesKey: string;
+  githubEnabled: boolean;
+  githubToken: string;
+  webhookSecret: string;
+  repositories: string;
+  publishReviews: boolean;
+  maxDiffChars: number;
+  ragEnabled: boolean;
+  recallK: number;
+  memoryK: number;
+  reranker: boolean;
+  learnMemory: boolean;
+  learnSkills: boolean;
+  maxMemories: number;
+  features: { id: string; json: string }[];
+  mcp: McpSpec[];
+}
+export type ConfigSource = () => SynapseConfig;
+export type ErrorSink = (error: Error) => void;
+export interface SynapseContext extends CordisContext {
+  dshLoader: HostAPI;
+  baseUrl?: string;
+}
+export interface MemoryItem {
+  channel: Channel;
+  source: string;
+  text: string;
+}
+export interface MemoryRow extends MemoryItem {
+  id: number;
+  hash: string;
+  created: string;
+  score?: number;
+}
+export interface Embeddings {
+  embed(text: string, query?: boolean): Promise<number[]>;
+  rerank(query: string, documents: string[]): Promise<number[]>;
+}
+export interface Skill {
+  name: string;
+  content: string;
+  revision: string;
+  inherited: boolean;
+}
+export interface AvailableTool {
+  server: string;
+  rawName: string;
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+}
+export interface ChatMessage {
+  role: string;
+  content?: any;
+  tool_calls?: { id: string; function: { name: string; arguments: string } }[];
+  tool_call_id?: string;
+}
+export type AgentEvent = (
+  event: string,
+  payload: Record<string, unknown>,
+) => void;
+export interface Delivery {
+  id: string;
+  event: string;
+  payload: string;
+  state: string;
+  attempts: number;
+  error?: string;
+  result?: string;
+}

package/test/core.test.mjs

@@ -0,0 +1,279 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createHmac } from "node:crypto";
+import { createServer } from "node:http";
+import { defaultsFor } from "@dsh-plugin/dsh-loader/config";
+import { template, validateConfig } from "../lib/host/config.js";
+import { SkillStore, promptFor, pathsFor } from "../lib/host/files.js";
+import { Memory, parseHermes } from "../lib/host/memory.js";
+import {
+  verifySignature,
+  repositoryAllowed,
+  Reviews,
+} from "../lib/host/github.js";
+import { Agent } from "../lib/host/agent.js";
+import { Gateway } from "../lib/host/gateway.js";
+import { browserAuthorized } from "../lib/host/http.js";
+const config = () => defaultsFor(template.fields);
+const fixture = async () => {
+  const home = await mkdtemp(path.join(os.tmpdir(), "synapse-"));
+  const profile = path.join(home, "profiles", "test");
+  await mkdir(profile, { recursive: true });
+  return {
+    home,
+    profile,
+    skills: path.join(profile, "skills"),
+    data: path.join(profile, "data", "dsh-synapse"),
+  };
+};
+const inference = {
+  async embed(text) {
+    const v = Array(512).fill(0);
+    v[text.includes("猫") ? 0 : 1] = 1;
+    return v;
+  },
+  async rerank(q, docs) {
+    return docs.map((t) => (t.includes("重排") ? 1 : 0));
+  },
+};
+test("defaults form valid config and reject malformed JSON / duplicate MCP", () => {
+  const c = config();
+  assert.equal(validateConfig(c), c);
+  assert.throws(() => validateConfig({ ...c, botJson: "[]" }));
+  assert.throws(() => validateConfig({ ...c, githubEnabled: true }));
+  assert.throws(() => validateConfig({ ...c, recallK: 1.5 }));
+});
+test("profile prompt overrides home; chat and review use distinct files", async () => {
+  const p = await fixture();
+  await writeFile(path.join(p.home, "SOUL.md"), "home soul");
+  await writeFile(path.join(p.home, "AGENTS.md"), "home review");
+  assert.equal(await promptFor(p, "chat"), "home soul");
+  await writeFile(path.join(p.profile, "SOUL.md"), "profile soul");
+  assert.equal(await promptFor(p, "chat"), "profile soul");
+  assert.equal(await promptFor(p, "review"), "home review");
+  assert.equal(pathsFor({}, { profileDir: p.profile }).home, p.home);
+  assert.throws(() => pathsFor({}, {}));
+});
+test("skills import, edit conflicts, inheritance, retrieval, deletion and traversal", async () => {
+  const p = await fixture();
+  const skills = new SkillStore(p);
+  await mkdir(path.join(p.home, "skills"), { recursive: true });
+  await writeFile(path.join(p.home, "skills", "global.md"), "global reference");
+  const saved = await skills.save(
+    "testing",
+    "# Testing\nUse assert for tests.",
+  );
+  assert.equal((await skills.retrieve("assert", "chat")).length, 1);
+  await assert.rejects(skills.save("testing", "changed", null), /已变更/);
+  await assert.rejects(skills.save("../escape", "oops"), /名称无效/);
+  await skills.save("testing", "Updated procedure", saved.revision);
+  const now = (await skills.list()).find((s) => s.name === "testing");
+  await skills.remove("testing", now.revision);
+  assert.equal((await skills.list()).length, 1);
+  await assert.rejects(skills.remove("global", "anything"), /当前 profile/);
+});
+test("Hermes headings, frontmatter, fenced text, CRLF, and categories", () => {
+  const entries = parseHermes(
+    "---\r\nname: memory\r\n---\r\n# 用户\r\n喜欢猫\r\n## 项目\r\n```md\r\n# this is code\r\n```",
+    "review",
+  );
+  assert.equal(entries.length, 2);
+  assert.equal(entries[0].channel, "review");
+  assert.match(entries[1].text, /# this is code/);
+  assert.throws(() => parseHermes("test", "unknown"));
+  assert.equal(parseHermes("").length, 0);
+});
+test("actual sqlite-vec + FTS5 hybrid retrieval isolates channels and deduplicates", async () => {
+  const c = config();
+  const memory = new Memory(":memory:", inference, () => c);
+  try {
+    await memory.addMany([
+      { channel: "chat", source: "test", text: "猫喜欢鱼" },
+      { channel: "review", source: "test", text: "猫审查代码" },
+      { channel: "chat", source: "test", text: "代码重排" },
+    ]);
+    const result = await memory.addMany([
+      { channel: "chat", source: "hermes", text: "猫喜欢鱼" },
+    ]);
+    assert.equal(result.inserted, 0);
+    const found = await memory.search("猫", "chat");
+    assert.equal(found[0].text, "猫喜欢鱼");
+    assert(found.every((x) => x.channel === "chat"));
+    c.reranker = true;
+    assert.equal((await memory.search("代码", "chat"))[0].text, "代码重排");
+    assert.equal(memory.list("review").length, 1);
+  } finally {
+    memory.close();
+  }
+});
+test("embedding failure does not partially import a batch", async () => {
+  let i = 0;
+  const memory = new Memory(
+    ":memory:",
+    {
+      async embed() {
+        if (i++) throw new Error("download failed");
+        return Array(512).fill(0);
+      },
+    },
+    config,
+  );
+  try {
+    await assert.rejects(
+      memory.addMany(parseHermes("# A\none\n# B\ntwo")),
+      /download failed/,
+    );
+    assert.equal(memory.list("chat").length, 0);
+  } finally {
+    memory.close();
+  }
+});
+test("signature validation uses raw bytes and repository allowlists", () => {
+  const raw = Buffer.from('{ "a": 1 }'),
+    secret = "secret",
+    signature =
+      "sha256=" + createHmac("sha256", secret).update(raw).digest("hex");
+  assert(verifySignature(raw, secret, signature));
+  assert(!verifySignature(Buffer.from('{"a":1}'), secret, signature));
+  assert(!verifySignature(raw, "", signature));
+  assert(repositoryAllowed("Owner/Repo", "owner/*"));
+  assert(!repositoryAllowed("owner-evil/repo", "owner/*"));
+  assert(!repositoryAllowed("../repo", "owner/*"));
+});
+test("cross-site and unavailable browser authentication are denied", () => {
+  let status;
+  const res = {
+    writeHead(s) {
+      status = s;
+    },
+    end() {},
+  };
+  assert.equal(
+    browserAuthorized(
+      { dshLoader: { services: { get: () => undefined } } },
+      { headers: {} },
+      res,
+    ),
+    false,
+  );
+  assert.equal(status, 503);
+  assert.equal(
+    browserAuthorized({}, { headers: { "sec-fetch-site": "cross-site" } }, res),
+    false,
+  );
+  assert.equal(status, 403);
+});
+test("agent injects SOUL, retrieved skill and memory; tools execute only in chat", async () => {
+  const p = await fixture();
+  await writeFile(path.join(p.profile, "SOUL.md"), "shared soul");
+  const c = { ...config(), learnSkills: false, learnMemory: false };
+  let calls = 0;
+  const a = new Agent({
+    paths: p,
+    config: () => c,
+    memory: { search: async () => [{ text: "durable", source: "test" }] },
+    skills: { retrieve: async () => [{ content: "skill procedure" }] },
+    mcp: {
+      available: async () => [
+        {
+          name: "mcp_0",
+          server: "test",
+          rawName: "read",
+          parameters: { type: "object" },
+        },
+      ],
+      call: async () => {
+        calls++;
+        return { content: "ok" };
+      },
+    },
+  });
+  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);
+});
+test("Gateway authenticates, serves replayable completion events, and stops runs", async () => {
+  const g = new Gateway({ run: async () => "hello" }, config, () => {});
+  await g.start();
+  try {
+    assert.equal((await fetch(g.url + "/v1/runs")).status, 401);
+    const headers = {
+      Authorization: `Bearer ${g.token}`,
+      "Content-Type": "application/json",
+    };
+    const response = await fetch(g.url + "/v1/runs", {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ input: "hi" }),
+    });
+    const { run_id } = await response.json();
+    const events = await (
+      await fetch(g.url + `/v1/runs/${run_id}/events`, { headers })
+    ).text();
+    assert.match(events, /run.completed/);
+    assert.match(events, /hello/);
+  } 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 = {
+    ...config(),
+    githubEnabled: true,
+    publishReviews: true,
+    repositories: "owner/repo",
+  };
+  const r = new Reviews(
+    memory.db,
+    { run: async () => "Finding" },
+    () => c,
+    { notify() {} },
+    () => {},
+  );
+  const posted = [];
+  r.api = async (route, options) => {
+    if (options) {
+      posted.push(JSON.parse(options.body));
+      return {};
+    }
+    if (route.includes("/reviews?")) return [];
+    if (route.includes("/files?"))
+      return [{ filename: "a.js", patch: "+ bad()" }];
+    return { title: "PR", body: "body", head: { sha: "abc" } };
+  };
+  const job = {
+    id: "delivery",
+    event: "pull_request",
+    payload: JSON.stringify({
+      number: 1,
+      repository: { full_name: "owner/repo" },
+      pull_request: { head: { sha: "abc" } },
+    }),
+  };
+  assert.equal((await r.review(job)).published, true);
+  assert.equal(posted[0].commit_id, "abc");
+  assert.match(posted[0].body, /dsh-synapse:delivery/);
+  job.payload = job.payload.replace("abc", "old");
+  assert.equal((await r.review(job)).skipped, "superseded-head");
+  await r.close();
+  memory.close();
+});

package/test/fixtures/mcp-server.mjs

@@ -0,0 +1,14 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+const server = new McpServer({ name: "synapse-test", version: "1.0.0" });
+server.registerTool(
+  "read",
+  { description: "Test read", inputSchema: {} },
+  async () => ({ content: [{ type: "text", text: "fixture result" }] }),
+);
+server.registerTool(
+  "blocked",
+  { description: "Must not run", inputSchema: {} },
+  async () => ({ content: [{ type: "text", text: "blocked" }] }),
+);
+await server.connect(new StdioServerTransport());