opencode-qq-v2 0.0.0-stage → 0.2.0

package/index.js

@@ -0,0 +1,441 @@
+import fs from "node:fs";
+import lockfile from "proper-lockfile";
+import { Plugin } from "@opencode/plugin";
+import { Approver } from "./approver.js";
+import { loadConfig } from "./config.js";
+import { createGatewayUrlFetcher, QQGateway } from "./qq/gateway.js";
+import { QQApi } from "./qq/api.js";
+import { AuthManager } from "./qq/auth.js";
+import { StreamSender } from "./qq/stream.js";
+import {
+  SESSIONS_PATH,
+  LOCK_PATH,
+  REST_BASE_PROD,
+  REST_BASE_SANDBOX,
+  INTENT_GROUP_AND_C2C,
+  APPROVAL_TIMEOUT_MS,
+  PASSIVE_WINDOW_MS,
+  STREAM_FLUSH_INTERVAL_MS,
+} from "./constants.js";
+import { EventPusher } from "./event-pusher.js";
+import { toolExecuteAfterHook } from "./relay.js";
+import { AssistantTextBuffer } from "./stream-buffer.js";
+import { SessionManager } from "./session-manager.js";
+import { splitText } from "./util/chunk.js";
+import { guessImageMime, toImageDataUrl } from "./util/media.js";
+import { log } from "./logger.js";
+
+const REPLY_TIMEOUT_MS = 180_000; // 等待会话结束的超时兜底
+const LOCK_RETRY_MS = 5000; // 待命实例抢锁间隔
+const LOCK_STALE_MS = 30000; // 锁文件超过 30 秒无心跳视为僵尸锁
+const LOCK_UPDATE_MS = 10000; // 宿主每 10 秒心跳刷新锁
+
+// 幂等保护：opencode 启动时会分两个阶段加载本地插件，
+// 第二次加载的 setup 直接跳过，避免重复启动 QQ 网关导致报错。
+let started = false;
+
+// 抢文件锁：成功返回 release 函数；被占/异常返回 null
+async function tryAcquireFileLock(lockPath) {
+  try {
+    const release = await lockfile.lock(lockPath, {
+      retries: 0,
+      stale: LOCK_STALE_MS,
+      update: LOCK_UPDATE_MS,
+      realpath: false,
+    });
+    return release;
+  } catch {
+    return null;
+  }
+}
+
+export default Plugin.define({
+  id: "opencode-qq",
+  async setup(ctx) {
+    if (started) return;
+    started = true;
+    log("[setup] 插件启动，加载配置...");
+    const cfg = loadConfig();
+    if (!cfg) {
+      log("[setup] 缺少凭据，插件未启用");
+      console.warn("[opencode-qq] 缺少 QQ_BOT_APPID/QQ_BOT_APPSECRET 或配置文件，插件未启用");
+      started = false;
+      return;
+    }
+    log("[setup] 配置已加载 sandbox=", cfg.sandbox, "model=", cfg.model ?? "(默认)", "streaming=", cfg.streaming);
+
+    const allowSet = new Set(cfg.allowlist);
+    const restBase = cfg.sandbox ? REST_BASE_SANDBOX : REST_BASE_PROD;
+    const auth = new AuthManager(cfg.appId, cfg.appSecret);
+    const api = new QQApi({ restBase, getToken: () => auth.getToken() });
+    const approver = new Approver(APPROVAL_TIMEOUT_MS);
+
+    // ---- 事件收集器（V1 总线形状 {type, properties}）----
+    const listeners = [];
+    // sessionID → resolve(text)：session.prompt 排队后等会话 idle
+    const idleWaiters = new Map();
+
+    // ---- opencode 桥接（V2 Promise API）----
+    let cachedModel = null;
+    const resolveModel = async () => {
+      if (cachedModel) return cachedModel;
+      log("[bridge] 解析默认模型...");
+      if (cfg.model) {
+        const idx = cfg.model.indexOf("/");
+        if (idx > 0) {
+          cachedModel = { providerID: cfg.model.slice(0, idx), modelID: cfg.model.slice(idx + 1) };
+        } else {
+          cachedModel = { providerID: "unknown", modelID: cfg.model };
+        }
+      } else {
+        const def = await ctx.model.default();
+        const m = def?.data;
+        if (!m) {
+          throw new Error("未配置 model，请在 opencode-qq.json 中设置 model: 'providerID/modelID'");
+        }
+        cachedModel = { providerID: m.providerID, modelID: m.id };
+      }
+      log("[bridge] 模型:", cachedModel.providerID, "/", cachedModel.modelID);
+      return cachedModel;
+    };
+
+    const bridge = {
+      async sessionCreate(title) {
+        log("[bridge] 创建会话 title=", title);
+        const res = await ctx.session.create({ title });
+        log("[bridge] 会话已创建 id=", res?.id);
+        return { id: res.id };
+      },
+      async sessionPrompt(id, text, noReply, files) {
+        log("[bridge] sessionPrompt id=", id, "noReply=", noReply, "text=", text.slice(0, 40));
+        const model = await resolveModel();
+        try {
+          log("[bridge] 切换模型...");
+          await ctx.session.switchModel({
+            sessionID: id,
+            model: { id: model.modelID, providerID: model.providerID },
+          });
+          log("[bridge] 模型已切换");
+        } catch (e) {
+          log("[bridge] 切换模型失败(继续):", String(e?.message ?? e));
+        }
+        log("[bridge] 排队 prompt...");
+        await ctx.session.prompt({
+          sessionID: id,
+          text,
+          files: (files ?? []).map((f) => ({
+            uri: f.dataUrl,
+            name: `image.${(f.mime ?? "image/png").split("/")[1] ?? "png"}`,
+          })),
+          delivery: "steer",
+        });
+        log("[bridge] prompt 已排队");
+        if (noReply) return { parts: [] };
+        // V2 的 prompt 是 fire-and-forget，回复通过事件流返回：等待 session.idle
+        log("[bridge] 等待 session.idle...");
+        const out = await new Promise((resolve) => {
+          idleWaiters.set(id, resolve);
+          setTimeout(() => {
+            if (idleWaiters.get(id) === resolve) {
+              idleWaiters.delete(id);
+              log("[bridge] 等待超时，返回当前已累计文本");
+              resolve(assistantBuf.text(id) ?? "");
+            }
+          }, REPLY_TIMEOUT_MS);
+        });
+        log("[bridge] 收到回复:", out.slice(0, 80));
+        return { parts: out ? [{ type: "text", text: out }] : [] };
+      },
+      resolveModel,
+    };
+
+    const sessions = new SessionManager(bridge, SESSIONS_PATH(), fs, (sid) =>
+      approver.countBySession(sid),
+    );
+    bridge.onSessionReset = (sid) => approver.clearSession(sid);
+
+    // ---- 流式缓冲 / 事件推送 ----
+    const assistantBuf = new AssistantTextBuffer((sid) => sessions.isOurSession(sid));
+    const pusher = new EventPusher({
+      isOurSession: (sid) => sessions.isOurSession(sid),
+      openidOfSession: (sid) => {
+        for (const [openid, s] of Object.entries(sessions.snapshot())) if (s === sid) return openid;
+        return null;
+      },
+      send: async (openid, text) => {
+        for (const part of splitText(text)) await api.sendC2C(openid, part);
+      },
+      toolProgress: cfg.events.toolProgress,
+      lastAssistantText: (sid) => assistantBuf.text(sid),
+      subscribe: (h) => listeners.push(h),
+    });
+
+    // ---- 下行：QQ 消息处理 ----
+    const passiveRefs = new Map(); // openid → 最近一条
+    const pendingNotice = new Map(); // openid → 超窗未送达说明
+    const streams = new Map();
+
+    const beginStream = (openid) => {
+      if (!cfg.streaming) return null;
+      const ref = passiveRefs.get(openid);
+      if (!ref) return null;
+      const old = streams.get(openid);
+      if (old?.sender) old.sender.failed = true; // 重入保护：旧流作废
+      const sctx = { sender: null, msgId: ref.msgId, lastLen: 0 };
+      streams.set(openid, sctx);
+      return sctx;
+    };
+
+    const endStream = (openid, fullText, handle) => {
+      const sctx = streams.get(openid);
+      if (!handle || sctx !== handle) return false; // 已被更新消息覆盖
+      streams.delete(openid);
+      if (!handle.sender || handle.sender.failed) return false; // 无增量或失败 → 回落普通回复
+      void handle.sender.finish(fullText);
+      return true;
+    };
+
+    async function replyTo(openid, text, format = "text") {
+      const ref = passiveRefs.get(openid);
+      for (const chunk of splitText(text)) {
+        const usePassive = !!ref && Date.now() - ref.receivedAt < PASSIVE_WINDOW_MS;
+        try {
+          await api.sendC2C(openid, chunk, usePassive ? { msgId: ref.msgId, format } : { format });
+          log("[reply] 已发送 (passive=", usePassive, "):", chunk.slice(0, 50));
+        } catch (e) {
+          log("[reply] 发送失败:", String(e?.message ?? e));
+          if (!usePassive) pendingNotice.set(openid, "（此前有未能送达的消息）");
+        }
+      }
+    }
+
+    const gateway = new QQGateway({
+      getGatewayUrl: createGatewayUrlFetcher(restBase, () => auth.getToken()),
+      getToken: () => auth.getToken(),
+      intents: INTENT_GROUP_AND_C2C,
+      connected: () => pusher.setOnline(true),
+      disconnected: () => pusher.setOnline(false),
+      message: async (msg) => {
+        let stream = null;
+        try {
+          log("[msg] 收到消息 openid=", msg.openid, "content=", msg.content.slice(0, 100));
+          if (allowSet.size > 0 && !allowSet.has(msg.openid)) {
+            log("[msg] 被 allowlist 拦截");
+            return;
+          }
+          passiveRefs.set(msg.openid, { msgId: msg.msgId, receivedAt: Date.now() });
+          log("[msg] 发送 ack...");
+          await replyTo(msg.openid, "收到，正在处理");
+          log("[msg] ack 已发送");
+
+          // 远程审批回复优先
+          const parsed = approver.parseReply(msg.content.trim());
+          if (parsed) {
+            const item = approver.confirm(parsed.seq);
+            if (!item) {
+              await replyTo(msg.openid, `#${parsed.seq} 不存在或已超时。`);
+              return;
+            }
+            // V2：permission.reply 用 { sessionID, requestID, decision }
+            await ctx.permission.reply({
+              sessionID: item.sessionId,
+              requestID: item.permissionId,
+              decision: parsed.reply, // "once" | "reject"
+            });
+            await replyTo(msg.openid, `已${parsed.reply === "once" ? "批准" : "拒绝"} #${parsed.seq}`);
+            return;
+          }
+
+          const notice = pendingNotice.get(msg.openid);
+          pendingNotice.delete(msg.openid);
+
+          // 附件下载为 data URL，失败降级为纯文字
+          const files = [];
+          for (const att of msg.attachments ?? []) {
+            try {
+              files.push({ mime: guessImageMime(att.url), dataUrl: await toImageDataUrl(att.url) });
+            } catch {
+              await replyTo(msg.openid, "⚠️ 图片下载失败，仅处理文字部分").catch(() => {});
+            }
+          }
+          const promptText =
+            (msg.quotedText ? `[引用消息] ${msg.quotedText}\n` : "") +
+            (files.length ? `[图片 x${files.length}] ` : "") +
+            msg.content;
+
+          stream = beginStream(msg.openid);
+          log("[msg] 开始 dispatch...");
+          const answer = await sessions.dispatch(msg.openid, promptText, files);
+          log("[msg] dispatch 结果:", answer.slice(0, 120));
+          const deliveredByStream = endStream(msg.openid, answer, stream);
+          if (!deliveredByStream) {
+            log("[msg] 发送回复...");
+            await replyTo(
+              msg.openid,
+              (notice ? `${notice}\n` : "") + answer,
+              cfg.markdownReply ? "markdown" : "text",
+            );
+          }
+        } catch (e) {
+          log("[msg] 处理失败:", String(e).slice(0, 300));
+          if (stream && streams.get(msg.openid) === stream) streams.delete(msg.openid);
+          await replyTo(msg.openid, `处理失败: ${String(e).slice(0, 200)}`).catch(() => {});
+        }
+      },
+    });
+
+    // ---- 权限请求监听 ----
+    listeners.push((e) => {
+      if (e.type !== "permission.asked" && e.type !== "permission.updated") return;
+      const p = e.properties ?? {};
+      const sessionId = String(p.sessionID ?? "");
+      const permissionId = String(p.id ?? "");
+      if (!sessions.isOurSession(sessionId) || !permissionId) return;
+      const summary = String(p.action ?? p.title ?? p.type ?? "需要授权");
+      const seq = approver.register(sessionId, permissionId, summary);
+      const openid = (() => {
+        for (const [o, s] of Object.entries(sessions.snapshot())) if (s === sessionId) return o;
+        return null;
+      })();
+      if (openid) void replyTo(openid, approver.render(seq));
+    });
+
+    // ---- V2 事件循环：把 V2 事件映射成 V1 总线形状分发给 listeners ----
+    function dispatchEvent(ev) {
+      const props = ev.data ?? {};
+      switch (ev.type) {
+        case "session.text.delta":
+          assistantBuf.handle({ type: "session.text.delta", properties: props });
+          break;
+        case "session.idle": {
+          const sid = String(props.sessionID ?? "");
+          // 先唤醒等待者拿全文，再清缓冲并通知
+          const w = idleWaiters.get(sid);
+          if (w) {
+            idleWaiters.delete(sid);
+            w(assistantBuf.text(sid) ?? "");
+          }
+          assistantBuf.clear(sid);
+          for (const h of listeners) h({ type: "session.idle", properties: props });
+          break;
+        }
+        case "session.execution.succeeded": {
+          // V2 实际完成事件是 execution.succeeded（不是 session.idle）
+          const sid = String(props.sessionID ?? "");
+          log("[event] 执行成功，唤醒等待者 sid=", sid, "text=", (assistantBuf.text(sid) ?? "").slice(0, 60));
+          const w = idleWaiters.get(sid);
+          if (w) {
+            idleWaiters.delete(sid);
+            w(assistantBuf.text(sid) ?? "");
+          }
+          assistantBuf.clear(sid);
+          for (const h of listeners) h({ type: "session.idle", properties: props });
+          break;
+        }
+        case "session.execution.failed": {
+          const sid = String(props.sessionID ?? "");
+          const w = idleWaiters.get(sid);
+          if (w) {
+            idleWaiters.delete(sid);
+            w(assistantBuf.text(sid) ?? "");
+          }
+          for (const h of listeners)
+            h({ type: "session.error", properties: { sessionID: sid, error: props.error ?? props } });
+          break;
+        }
+        case "permission.asked":
+          for (const h of listeners) h({ type: "permission.asked", properties: props });
+          break;
+        default:
+          for (const h of listeners) h({ type: ev.type, properties: props });
+      }
+    }
+
+    const eventTask = (async () => {
+      log("[event] 开始订阅事件流...");
+      for await (const ev of ctx.event.subscribe()) {
+        log("[event] 收到事件:", ev.type);
+        dispatchEvent(ev);
+      }
+    })().catch((err) => {
+      log("[event] 订阅结束/错误:", String(err));
+      console.warn("[opencode-qq] 事件订阅结束:", String(err));
+    });
+
+    // ---- 工具钩子（V2）----
+    const toolReg = await ctx.tool.hook(
+      "execute.after",
+      toolExecuteAfterHook((e) => {
+        for (const h of listeners) h(e);
+      }),
+    );
+
+    // ---- 流式增量：session.text.delta 累计 → 节流推送 stream_messages ----
+    const flushTimer = setInterval(() => {
+      const snapshot = sessions.snapshot();
+      for (const [openid, sid] of Object.entries(snapshot)) {
+        const bufText = assistantBuf.text(sid);
+        if (!bufText) continue;
+        const sctx = streams.get(openid);
+        if (!sctx || sctx.sender?.failed) continue;
+        if (!sctx.sender) {
+          sctx.sender = new StreamSender(
+            { restBase, getToken: () => auth.getToken() },
+            { openid, msgId: sctx.msgId, msgSeq: 2 },
+          );
+        }
+        if (bufText.length <= sctx.lastLen) continue; // 无新增内容不重发
+        sctx.lastLen = bufText.length;
+        void sctx.sender.update(bufText);
+      }
+    }, STREAM_FLUSH_INTERVAL_MS);
+
+    // ---- 单实例锁：多个 opencode 实例时，只有一个会连接 QQ 网关 ----
+    const lockPath = LOCK_PATH(cfg.appId);
+    let releaseLock = await tryAcquireFileLock(lockPath);
+    let lockTimer = null;
+
+    const startGateway = () => {
+      log("[lock] 启动 QQ 网关");
+      gateway.start();
+    };
+
+    if (releaseLock) {
+      log("[lock] 抢锁成功，本实例为 QQ bot 宿主");
+      startGateway();
+    } else {
+      log("[lock] 锁被占用，本实例进入待命，每", LOCK_RETRY_MS, "ms 重试抢锁");
+      lockTimer = setInterval(async () => {
+        releaseLock = await tryAcquireFileLock(lockPath);
+        if (releaseLock) {
+          clearInterval(lockTimer);
+          lockTimer = null;
+          log("[lock] 抢锁成功，接管 QQ bot");
+          startGateway();
+        }
+      }, LOCK_RETRY_MS);
+    }
+
+    return async () => {
+      clearInterval(flushTimer);
+      if (lockTimer) clearInterval(lockTimer);
+      assistantBuf.clearAll();
+      gateway.stop();
+      pusher.dispose();
+      if (releaseLock) {
+        try {
+          await releaseLock();
+        } catch {
+          /* ignore */
+        }
+      }
+      try {
+        await toolReg.dispose();
+      } catch {
+        /* ignore */
+      }
+      started = false;
+      // eventTask 无法主动取消，随插件生命周期结束
+    };
+  },
+});

package/logger.js

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const LOG_PATH = path.join(
+  process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"),
+  "opencode",
+  "opencode-qq.log",
+);
+
+function ts() {
+  return new Date().toISOString();
+}
+
+export function log(...args) {
+  const line = `[${ts()}] ${args
+    .map((a) => (typeof a === "string" ? a : JSON.stringify(a)))
+    .join(" ")}\n`;
+  try {
+    fs.appendFileSync(LOG_PATH, line, "utf8");
+  } catch {
+    /* ignore */
+  }
+}

package/package.json

@@ -1,6 +1,18 @@
 {
   "name": "opencode-qq-v2",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "QQ bot (C2C) <-> opencode bridge plugin (V2 port)",
+  "type": "module",
+  "main": "index.js",
+  "license": "MIT",
+  "keywords": ["opencode", "opencode-plugin", "qq", "bot"],
+  "files": ["*.js", "qq", "util", "README.md", "LICENSE"],
+  "dependencies": {
+    "proper-lockfile": "^4.1.2",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "@opencode/plugin": "^2.0.0",
+    "effect": "^4.0.0"
+  }
+}

package/qq/api.js

@@ -0,0 +1,75 @@
+import { MAX_REPLIES_PER_MSG_ID } from "../constants";
+export class QQApi {
+    opts;
+    fetchFn;
+    queue = Promise.resolve();
+    seqCounters = new Map();
+    constructor(opts) {
+        this.opts = opts;
+        this.fetchFn = opts.fetchFn ?? fetch;
+    }
+    /** 串行化所有发送，避免打爆频控 */
+    sendC2C(openid, content, options = {}) {
+        const task = this.queue.then(() => this.doSend(openid, content, options));
+        this.queue = task.catch(() => { }); // 吞掉错误保持队列继续
+        return task;
+    }
+    nextSeq(msgId) {
+        if (!msgId)
+            return undefined;
+        const used = this.seqCounters.get(msgId) ?? 0;
+        if (used >= MAX_REPLIES_PER_MSG_ID)
+            return undefined; // 额度用尽 → 调用方降级主动消息
+        const seq = used + 1;
+        this.seqCounters.set(msgId, seq);
+        if (this.seqCounters.size > 500)
+            this.seqCounters.clear();
+        return seq;
+    }
+    async postWithRetry(openid, body) {
+        for (let attempt = 0; attempt <= 3; attempt++) {
+            const token = await this.opts.getToken();
+            const res = await this.fetchFn(`${this.opts.restBase}/v2/users/${openid}/messages`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: `QQBot ${token}` },
+                body: JSON.stringify(body),
+            });
+            if (res.status === 429 && attempt < 3) {
+                const retryAfter = Number(res.headers.get("Retry-After") ?? "1");
+                await new Promise((r) => setTimeout(r, Math.min(retryAfter, 30) * 1000));
+                continue;
+            }
+            if (!res.ok)
+                throw new Error(`sendC2C failed: HTTP ${res.status} ${await res.text()}`);
+            return;
+        }
+    }
+    async doSend(openid, content, options) {
+        const format = options.format ?? "text";
+        let msgId = options.msgId;
+        let seqReserved;
+        if (msgId) {
+            seqReserved = this.nextSeq(msgId);
+            if (seqReserved === undefined)
+                msgId = undefined; // 被动额度用尽 → 主动消息
+        }
+        const makeBody = (fmt) => {
+            const body = fmt === "markdown" ? { msg_type: 2, markdown: { content } } : { msg_type: 0, content };
+            if (msgId && seqReserved !== undefined) {
+                body.msg_id = msgId;
+                body.msg_seq = seqReserved;
+            }
+            return body;
+        };
+        try {
+            await this.postWithRetry(openid, makeBody(format));
+        }
+        catch (e) {
+            if (format === "markdown") {
+                await this.postWithRetry(openid, makeBody("text")); // 降级复用同一 msg_seq
+                return;
+            }
+            throw e;
+        }
+    }
+}

package/qq/auth.js

@@ -0,0 +1,29 @@
+import { TOKEN_URL } from "../constants";
+export class AuthManager {
+    appId;
+    appSecret;
+    fetchFn;
+    token = null;
+    expireAt = 0;
+    constructor(appId, appSecret, fetchFn = fetch) {
+        this.appId = appId;
+        this.appSecret = appSecret;
+        this.fetchFn = fetchFn;
+    }
+    async getToken() {
+        const now = Date.now();
+        if (this.token && now < this.expireAt - 60_000)
+            return this.token;
+        const res = await this.fetchFn(TOKEN_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ appId: this.appId, clientSecret: this.appSecret }),
+        });
+        if (!res.ok)
+            throw new Error(`getAppAccessToken failed: HTTP ${res.status}`);
+        const data = (await res.json());
+        this.token = data.access_token;
+        this.expireAt = Date.now() + Number(data.expires_in) * 1000;
+        return this.token;
+    }
+}