ework-qq-bridge 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-qq-bridge",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "QQ group <-> ework issue bridge (OneBot 11 reverse WebSocket)",
   "type": "module",
   "main": "src/index.ts",

package/src/bindings.ts

@@ -0,0 +1,69 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { dirname } from "node:path";
+import type { GroupBinding } from "./config";
+
+// Runtime issue pins: group -> issue number, persisted across restarts.
+// owner/repo always come from the static GROUP_MAP entry; the pin only
+// narrows which single issue the group is bound to.
+type PinFile = Record<string, number>;
+
+export class BindingStore {
+  private pins = new Map<number, number>();
+
+  constructor(private base: GroupBinding[], private file: string) {
+    try {
+      if (existsSync(file)) {
+        const raw = JSON.parse(readFileSync(file, "utf8")) as PinFile;
+        for (const [k, v] of Object.entries(raw)) {
+          if (Number.isInteger(Number(k)) && Number.isInteger(v)) {
+            this.pins.set(Number(k), v);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn(`[qq-bridge] bindings file unreadable, starting clean: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  private persist(): void {
+    const out: PinFile = {};
+    for (const [g, n] of this.pins) out[String(g)] = n;
+    try {
+      mkdirSync(dirname(this.file), { recursive: true });
+      writeFileSync(this.file, JSON.stringify(out, null, 2) + "\n");
+    } catch (err) {
+      console.error(`[qq-bridge] failed to persist bindings: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  resolve(groupId: number): GroupBinding | null {
+    const base = this.base.find((b) => b.groupId === groupId);
+    if (!base) return null;
+    const pinned = this.pins.get(groupId);
+    if (pinned === undefined) return base;
+    return { ...base, issue: pinned };
+  }
+
+  all(): GroupBinding[] {
+    return this.base.map((b) => this.resolve(b.groupId)!);
+  }
+
+  groupsFor(owner: string, repo: string, issueNumber: number): number[] {
+    return this.all()
+      .filter((b) => b.owner === owner && b.repo === repo && (b.issue === undefined || b.issue === issueNumber))
+      .map((b) => b.groupId);
+  }
+
+  pin(groupId: number, issue: number): GroupBinding | null {
+    if (!this.base.some((b) => b.groupId === groupId)) return null;
+    this.pins.set(groupId, issue);
+    this.persist();
+    return this.resolve(groupId);
+  }
+
+  unpin(groupId: number): boolean {
+    if (!this.pins.delete(groupId)) return false;
+    this.persist();
+    return true;
+  }
+}

package/src/config.ts

@@ -16,10 +16,15 @@ const Schema = z.object({
   // comment events here so agent replies can be pushed back to the group.
   EWORK_WEBHOOK_SECRET: z.string().default(""),
 
-  // group_id -> owner/repo mapping. Comma-separated:
-  //   "123456789:ranxianglei/billion-context,987654321:dog/test1"
+  // group_id -> owner/repo mapping, optionally pinned to one issue:
+  //   "123456789:ranxianglei/billion-context#7,987654321:dog/test1"
+  // A `#N` suffix binds the group to that single issue (long-memory mode);
+  // without it the group gets all agent replies from the whole repo.
   GROUP_MAP: z.string().min(1),
 
+  // Runtime pin overrides written by the 绑定/解绑 commands (JSON, group -> issue).
+  WORK_BINDINGS_FILE: z.string().default(""),
+
   // QQ user_ids allowed to dispatch AI work (comma-separated). Messages from
   // other members are logged and ignored — same trust model as the GitHub
   // side (WORK_WAKE_LOGINS): strangers never wake the AI.
@@ -58,6 +63,7 @@ export interface GroupBinding {
   groupId: number;
   owner: string;
   repo: string;
+  issue?: number;
 }
 
 export function parseGroupMap(raw: string): GroupBinding[] {
@@ -65,11 +71,11 @@ export function parseGroupMap(raw: string): GroupBinding[] {
   for (const part of raw.split(",")) {
     const item = part.trim();
     if (!item) continue;
-    const m = /^(\d+):([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(item);
+    const m = /^(\d+):([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:#(\d+))?$/.exec(item);
     if (!m?.[1] || !m[2] || !m[3]) {
       throw new Error(`invalid GROUP_MAP entry: ${item}`);
     }
-    out.push({ groupId: Number(m[1]), owner: m[2], repo: m[3] });
+    out.push(m[4] ? { groupId: Number(m[1]), owner: m[2], repo: m[3], issue: Number(m[4]) } : { groupId: Number(m[1]), owner: m[2], repo: m[3] });
   }
   if (out.length === 0) throw new Error("GROUP_MAP must define at least one group");
   return out;
@@ -92,5 +98,8 @@ export function loadConfig(): Config {
   if (!cfg.DB_PATH) {
     cfg.DB_PATH = `${process.env.HOME ?? "/tmp"}/.ework-qq-bridge/qq-bridge.db`;
   }
+  if (!cfg.WORK_BINDINGS_FILE) {
+    cfg.WORK_BINDINGS_FILE = `${process.env.HOME ?? "/tmp"}/.ework-qq-bridge/bindings.json`;
+  }
   return cfg;
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 import { loadConfig, parseGroupMap, parseList } from "./config";
 import { BridgeStore } from "./db";
+import { BindingStore } from "./bindings";
 import { createOneBotServer, type OneBotApi, type GroupMessageEvent } from "./onebot";
 import { createRouter } from "./router";
 import { createIngest } from "./ingest";
@@ -14,9 +15,7 @@ async function main() {
 }
 const store = new BridgeStore(cfg.DB_PATH || "/tmp/ework-qq-bridge.db");
 
-  const bindings = parseGroupMap(cfg.GROUP_MAP);
-  const groupIdOfProject = new Map<string, number>();
-  for (const b of bindings) groupIdOfProject.set(`${b.owner}/${b.repo}`, b.groupId);
+  const bindings = new BindingStore(parseGroupMap(cfg.GROUP_MAP), cfg.WORK_BINDINGS_FILE);
 
   let api: OneBotApi | null = null;
   const send = async (groupId: number, text: string) => {
@@ -40,7 +39,7 @@ const store = new BridgeStore(cfg.DB_PATH || "/tmp/ework-qq-bridge.db");
     bridgeLogin: cfg.BRIDGE_LOGIN,
     agentLogins: new Set(parseList(cfg.AGENT_LOGINS)),
     scrub,
-    projectOf: (owner, repo) => groupIdOfProject.get(`${owner}/${repo}`) ?? null,
+    groupsFor: (owner, repo, number) => bindings.groupsFor(owner, repo, number),
     commentForwarded: (id) => store.commentForwarded(id),
     send,
   });

package/src/ingest.ts

@@ -14,7 +14,7 @@ interface IngestDeps {
   bridgeLogin: string;
   agentLogins: Set<string>;
   scrub: (text: string) => string;
-  projectOf(owner: string, repo: string): number | null;
+  groupsFor(owner: string, repo: string, number: number): number[];
   commentForwarded(commentId: number): boolean;
   send(groupId: number, text: string): Promise<void>;
 }
@@ -85,8 +85,8 @@ export function createIngest(deps: IngestDeps) {
     if (body.startsWith("[system]") || body.startsWith("[SYSTEM ")) return new Response("skipped:system", { status: 200 });
     if (!deps.agentLogins.has(author)) return new Response("skipped:non-agent", { status: 200 });
 
-    const groupId = deps.projectOf(owner, String(repo.name));
-    if (groupId === null) return new Response("skipped:unmapped", { status: 200 });
+    const groups = deps.groupsFor(owner, String(repo.name), number);
+    if (groups.length === 0) return new Response("skipped:unmapped", { status: 200 });
     if (!Number.isInteger(commentId) || deps.commentForwarded(commentId)) {
       return new Response("skipped:dup", { status: 200 });
     }
@@ -97,7 +97,7 @@ export function createIngest(deps: IngestDeps) {
     }
     const text = deps.scrub(`[#${number}] ${body}`);
     try {
-      await deps.send(groupId, text);
+      for (const groupId of groups) await deps.send(groupId, text);
     } catch (err) {
       console.error(`[qq-bridge] send_group_msg failed: ${err instanceof Error ? err.message : err}`);
       return new Response("send failed", { status: 502 });

package/src/onebot.ts

@@ -59,11 +59,15 @@ export function createOneBotServer(opts: OneBotServerOptions) {
   const pending = new Map<string, PendingEntry>();
   let ws: ServerWebSocket<unknown> | null = null;
 
-  function rejectAll(reason: string) {
+  function drainPending(reason: string) {
     for (const [, entry] of pending) {
       entry.reject(new Error(reason));
     }
     pending.clear();
+  }
+
+  function rejectAll(reason: string) {
+    drainPending(reason);
     ws = null;
   }
 
@@ -75,11 +79,12 @@ export function createOneBotServer(opts: OneBotServerOptions) {
     // Bun handlers: wire these into Bun.serve({websocket:{...}})
     handlers: {
       open(client: ServerWebSocket<unknown>) {
-        if (ws) {
-          client.close(4000, "duplicate connection");
-          return;
-        }
+        // A fresh connect means the peer restarted: the old socket is dead or
+        // dying (TCP may not have noticed yet). Supersede it, never reject
+        // the newcomer, or reconnects stall behind zombie sockets.
+        if (ws) ws.close(4001, "superseded by new connection");
         ws = client;
+        drainPending("superseded by new connection");
         const api: OneBotApi = {
           call(action, params) {
             const echo = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;

package/src/router.ts

@@ -1,20 +1,23 @@
-import type { GroupBinding, Config } from "./config";
+import type { Config } from "./config";
 import type { EworkClient } from "./ework";
 import type { GroupMessageEvent } from "./onebot";
 import type { BridgeStore } from "./db";
+import type { BindingStore } from "./bindings";
 import { buildChatMessages, chatComplete, splitForQQ, type ChatTurn } from "./chat";
 
 const HELP_TEXT = [
   "用法：",
-  "  任务 <标题> —— 新建 issue，AI 自动接单",
+  "  任务 <标题> —— 新建 issue 并接单（本群已绑定时：新建并换绑到新 issue）",
   "  #<编号> <内容> —— 给指定 issue 追加内容",
+  "  绑定 #<编号> —— 把本群绑定到该 issue（长记忆模式：此后发言都进这个 issue）",
+  "  解绑 —— 恢复为项目模式（接收整个项目的回复）",
   "  查询 —— 列出最近 issue",
-  "  @我 + 任意问题 —— 即时问答（不建 issue）",
+  "  @我 + 任意问题 —— 即时问答（不建 issue、不留痕）",
 ].join("\n");
 
 export interface RouterDeps {
   cfg: Config;
-  bindings: GroupBinding[];
+  bindings: BindingStore;
   wakeList: Set<string>;
   ework: EworkClient;
   store: BridgeStore;
@@ -22,7 +25,7 @@ export interface RouterDeps {
 }
 
 interface ParsedCommand {
-  kind: "create" | "comment" | "help";
+  kind: "create" | "comment" | "bind" | "unbind" | "help";
   title?: string;
   number?: number;
   body?: string;
@@ -32,6 +35,9 @@ export function parseCommand(raw: string): ParsedCommand | null {
   const text = raw.trim();
   const stripped = text.replace(/^\[CQ:at,qq=\d+\]\s*/, "").trim();
   if (stripped === "帮助" || stripped === "help" || stripped === "查询") return { kind: "help" };
+  const bind = /^绑定\s*#(\d{1,6})$/.exec(stripped) ?? /^绑定\s*#(\d{1,6})$/.exec(text);
+  if (bind?.[1]) return { kind: "bind", number: Number(bind[1]) };
+  if (stripped === "解绑" || stripped === "unbind") return { kind: "unbind" };
   const create = /^(?:任务|task|新任务)\s+(.+)$/i.exec(stripped) ?? /^(?:任务|task|新任务)\s+(.+)$/i.exec(text);
   if (create?.[1]) return { kind: "create", title: create[1].trim() };
   const comment = /^#(\d{1,6})\s+([\s\S]+)$/.exec(stripped) ?? /^#(\d{1,6})\s+([\s\S]+)$/.exec(text);
@@ -61,7 +67,7 @@ export function createRouter(deps: RouterDeps) {
 
   async function handleGroupMessage(ev: GroupMessageEvent): Promise<void> {
     if (store.seenPost(ev.postId)) return;
-    const binding = bindings.find((b) => b.groupId === ev.groupId);
+    const binding = bindings.resolve(ev.groupId);
     if (!binding) return;
 
     if (!wakeList.has(String(ev.userId))) {
@@ -69,14 +75,18 @@ export function createRouter(deps: RouterDeps) {
       return;
     }
 
-    const atBot = ev.rawMessage.includes("[CQ:at,qq=") || /^\s*(任务|task|新任务|#|帮助|help|查询)/.test(ev.rawMessage);
+    const atBot = ev.rawMessage.includes("[CQ:at,qq=") || /^\s*(任务|task|新任务|#|绑定|解绑|帮助|help|查询)/.test(ev.rawMessage);
     const cmd = parseCommand(ev.rawMessage);
-    if (!cmd && !atBot) {
+    if (!cmd && !atBot && binding.issue === undefined) {
       if (cfg.VERBOSE) console.log(`[qq-bridge] unrecognized message from ${ev.userId}: ${ev.rawMessage.slice(0, 80)}`);
       return;
     }
     if (!cmd) {
       const question = ev.rawMessage.replace(/\[CQ:[^\]]*\]/g, "").trim();
+      if (binding.issue !== undefined && !atBot) {
+        await ework.addComment(binding.owner, binding.repo, binding.issue, `> 来自 QQ 群用户 **${ev.nickname}** (${ev.userId})\n\n${question}`);
+        return;
+      }
       if (cfg.WORK_CHAT_API && question) {
         try {
           await answerChat(ev, question);
@@ -97,9 +107,25 @@ export function createRouter(deps: RouterDeps) {
     const attribution = `> 来自 QQ 群用户 **${ev.nickname}** (${ev.userId})`;
 
     try {
+      if (cmd.kind === "bind" && cmd.number !== undefined) {
+        const pinned = bindings.pin(ev.groupId, cmd.number);
+        if (!pinned) {
+          await deps.reply(ev.groupId, "❌ 本群没有配置项目映射，无法绑定");
+          return;
+        }
+        await deps.reply(ev.groupId, `📌 本群已绑定 ${pinned.owner}/${pinned.repo}#${cmd.number}，之后的发言都会进这个 issue`);
+        return;
+      }
+      if (cmd.kind === "unbind") {
+        const ok = bindings.unpin(ev.groupId);
+        await deps.reply(ev.groupId, ok ? "↩️ 已解绑，恢复项目模式（接收整个项目的回复）" : "本群本来就没有绑定 issue");
+        return;
+      }
       if (cmd.kind === "create") {
         const n = await ework.createIssue(binding.owner, binding.repo, cmd.title ?? "", `${attribution}\n\n${cmd.title ?? ""}`);
-        await deps.reply(ev.groupId, `✅ 已创建 issue #${n}，AI 已接单：${cmd.title ?? ""}`);
+        bindings.pin(ev.groupId, n);
+        const swap = binding.issue !== undefined ? `（原 #${binding.issue} 已解绑）` : "（本群已绑定，长记忆模式）";
+        await deps.reply(ev.groupId, `✅ 已创建 issue #${n}，AI 已接单 ${swap}`);
         return;
       }
       if (cmd.kind === "comment" && cmd.number !== undefined) {

package/tests/bridge.test.ts

@@ -1,5 +1,9 @@
 import { describe, test, expect } from "bun:test";
 import { parseCommand } from "../src/router";
+import { BindingStore } from "../src/bindings";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+const pinFile = () => `${tmpdir()}/qqb-test-${randomUUID()}.json`;
 import { parseGroupMap, parseList } from "../src/config";
 import { buildScrubber } from "../src/scrub";
 import { verifySignature } from "../src/ingest";
@@ -96,7 +100,7 @@ describe("chat mode", () => {
     const parts = splitForQQ(long);
     expect(parts.length).toBeGreaterThan(1);
     for (const p of parts) expect(p.length).toBeLessThanOrEqual(1500);
-    expect(parts.join("\n")).toBe(long.replace(/\n$/, ""));
+    expect(parts.join("\n")).toBe(long);
   });
 
   test("router: @bot + question hits chat when configured, help when not", async () => {
@@ -112,7 +116,7 @@ describe("chat mode", () => {
         WORK_CHAT_TIMEOUT_MS: 1000,
         WORK_CHAT_MAX_HISTORY: 20,
       },
-      bindings: [{ groupId: 1, owner: "o", repo: "r" }],
+      bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile()),
       wakeList: new Set(["1403558951"]),
       ework: { createIssue: async () => 1, addComment: async () => {} },
       store: { seenPost: () => false },
@@ -134,7 +138,7 @@ describe("chat mode", () => {
     const replies: string[] = [];
     const router = createRouter({
       cfg: { VERBOSE: false, WORK_CHAT_API: "http://x/v1", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20 },
-      bindings: [{ groupId: 1, owner: "o", repo: "r" }],
+      bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile()),
       wakeList: new Set(["1"]),
       ework: { createIssue: async () => 1, addComment: async () => {} },
       store: { seenPost: () => false },
@@ -154,10 +158,94 @@ test("onebot close ignores non-active client (reconnect race)", () => {
   srv.handlers.open(a);
   expect(ready).toBe(1);
   srv.handlers.open(b);
-  expect(ready).toBe(1);
+  expect(ready).toBe(2);
   srv.handlers.close(a);
   expect(srv.connected).toBe(true);
   srv.handlers.close(b);
   expect(srv.connected).toBe(false);
 });
 
+
+describe("issue pinning", () => {
+  test("parseGroupMap accepts #N suffix and bare form", () => {
+    const [pinned, bare] = parseGroupMap("111:o/r#7,222:o/r");
+    expect(pinned.issue).toBe(7);
+    expect(bare.issue).toBeUndefined();
+  });
+
+  test("parseCommand: 绑定/解绑", () => {
+    expect(parseCommand("绑定 #7")).toEqual({ kind: "bind", number: 7 });
+    expect(parseCommand("解绑")).toEqual({ kind: "unbind" });
+  });
+
+  test("BindingStore pin/unpin persist + groupsFor filter", () => {
+    const f = pinFile();
+    const bs = new BindingStore([{ groupId: 111, owner: "o", repo: "r" }, { groupId: 222, owner: "o", repo: "r" }], f);
+    expect(bs.groupsFor("o", "r", 7)).toEqual([111, 222]);
+    bs.pin(111, 7);
+    expect(bs.groupsFor("o", "r", 7)).toEqual([111, 222]);
+    expect(bs.groupsFor("o", "r", 8)).toEqual([222]);
+    expect(bs.pin(999, 1)).toBeNull();
+    const reloaded = new BindingStore([{ groupId: 111, owner: "o", repo: "r" }], f);
+    expect(reloaded.resolve(111)?.issue).toBe(7);
+    expect(reloaded.groupsFor("o", "r", 8)).toEqual([]);
+    expect(reloaded.unpin(111)).toBe(true);
+    expect(reloaded.groupsFor("o", "r", 8)).toEqual([111]);
+  });
+
+  test("router: pinned plain message comments bound issue silently", async () => {
+    const { createRouter } = require("../src/router");
+    const replies: string[] = [];
+    const comments: Array<[string, string, number, string]> = [];
+    const router = createRouter({
+      cfg: { VERBOSE: false, WORK_CHAT_API: "http://x/v1", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20 },
+      bindings: new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 7 }], pinFile()),
+      wakeList: new Set(["1"]),
+      ework: { createIssue: async () => 9, addComment: async (o: string, r: string, n: number, b: string) => { comments.push([o, r, n, b]); } },
+      store: { seenPost: () => false },
+      reply: async (_g: number, t: string) => { replies.push(t); },
+    });
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p1", rawMessage: "帮我看下这个报错" });
+    expect(comments.length).toBe(1);
+    expect(comments[0][2]).toBe(7);
+    expect(comments[0][3]).toContain("帮我看下这个报错");
+    expect(replies).toEqual([]);
+  });
+
+  test("router: 绑定 #5 pins group, then plain message targets #5", async () => {
+    const { createRouter } = require("../src/router");
+    const replies: string[] = [];
+    const comments: Array<number, any> = [];
+    const bs = new BindingStore([{ groupId: 1, owner: "o", repo: "r" }], pinFile());
+    const router = createRouter({
+      cfg: { VERBOSE: false, WORK_CHAT_API: "", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20 },
+      bindings: bs,
+      wakeList: new Set(["1"]),
+      ework: { createIssue: async () => 9, addComment: async (_o: any, _r: any, n: number) => { comments.push(n); } },
+      store: { seenPost: () => false },
+      reply: async (_g: number, t: string) => { replies.push(t); },
+    });
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p1", rawMessage: "绑定 #5" });
+    expect(replies[0]).toContain("#5");
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p2", rawMessage: "第二条消息" });
+    expect(comments).toEqual([5]);
+  });
+
+  test("router: 任务 in pinned group creates AND rebinds", async () => {
+    const { createRouter } = require("../src/router");
+    const replies: string[] = [];
+    const bs = new BindingStore([{ groupId: 1, owner: "o", repo: "r", issue: 3 }], pinFile());
+    const router = createRouter({
+      cfg: { VERBOSE: false, WORK_CHAT_API: "", WORK_CHAT_API_KEY: "k", WORK_CHAT_MODEL: "m", WORK_CHAT_TIMEOUT_MS: 1000, WORK_CHAT_MAX_HISTORY: 20 },
+      bindings: bs,
+      wakeList: new Set(["1"]),
+      ework: { createIssue: async () => 12, addComment: async () => {} },
+      store: { seenPost: () => false },
+      reply: async (_g: number, t: string) => { replies.push(t); },
+    });
+    await router.handleGroupMessage({ groupId: 1, userId: 1, nickname: "u", postId: "p1", rawMessage: "任务 新主题" });
+    expect(replies[0]).toContain("#12");
+    expect(replies[0]).toContain("#3");
+    expect(bs.resolve(1)?.issue).toBe(12);
+  });
+});