opencode-qq-v2 0.0.0-stage → 0.2.0

package/qq/gateway.js

@@ -0,0 +1,213 @@
+import WebSocket from "ws";
+import { GATEWAY_PATH } from "../constants";
+import { extractQuotedText } from "../util/quote";
+import { log } from "../logger";
+const OP_DISPATCH = 0;
+const OP_HEARTBEAT = 1;
+const OP_IDENTIFY = 2;
+const OP_RESUME = 6;
+const OP_HELLO = 10;
+const OP_HEARTBEAT_ACK = 11;
+export class QQGateway {
+    opts;
+    ws = null;
+    sessionId = null;
+    lastSeq = null;
+    resumeAttempted = false;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    reconnectAttempt = 0;
+    stopped = false;
+    seenIds = new Set();
+    seenOrder = [];
+    isDuplicate(key) {
+        if (!key)
+            return false;
+        if (this.seenIds.has(key))
+            return true;
+        this.seenIds.add(key);
+        this.seenOrder.push(key);
+        const cap = this.opts.maxSeen ?? 1000;
+        if (this.seenOrder.length > cap) {
+            const oldest = this.seenOrder.shift();
+            if (oldest !== undefined)
+                this.seenIds.delete(oldest);
+        }
+        return false;
+    }
+    constructor(opts) {
+        this.opts = opts;
+    }
+    start() {
+        this.stopped = false;
+        this.connect().catch(() => this.scheduleReconnect());
+    }
+    stop() {
+        this.stopped = true;
+        this.cleanup();
+    }
+    cleanup() {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            try {
+                this.ws.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.ws = null;
+    }
+    scheduleReconnect() {
+        if (this.stopped)
+            return;
+        if (this.resumeAttempted) {
+            this.resumeAttempted = false;
+            this.sessionId = null;
+            this.lastSeq = null;
+        }
+        const base = this.opts.reconnectBaseMs ?? 1000;
+        const delay = Math.min(base * 2 ** this.reconnectAttempt, 60_000);
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => {
+            if (this.stopped)
+                return;
+            this.connect().catch(() => this.scheduleReconnect());
+        }, delay);
+    }
+    async connect() {
+        log("[gateway] 开始连接...");
+        const url = await this.opts.getGatewayUrl();
+        log("[gateway] 网关地址:", url);
+        const ws = new WebSocket(url);
+        this.ws = ws;
+        ws.on("open", () => {
+            log("[gateway] WebSocket 已连接，等待 HELLO...");
+        });
+        ws.on("message", (raw) => {
+            // 终审 I3：非 JSON 帧直接 JSON.parse 会抛异常击穿 opencode 进程，守卫后丢弃
+            let pkt;
+            try {
+                pkt = JSON.parse(raw.toString());
+            }
+            catch (e) {
+                console.warn(`[opencode-qq] 丢弃非 JSON 网关帧: ${String(e).slice(0, 120)}`);
+                return;
+            }
+            this.handlePacket(pkt);
+        });
+        ws.on("close", (code) => {
+            log("[gateway] WebSocket 关闭 code=", code);
+            this.opts.disconnected();
+            this.scheduleReconnect();
+        });
+        ws.on("error", (e) => {
+            log("[gateway] WebSocket 错误:", String(e?.message ?? e));
+            ws.terminate();
+        });
+    }
+    handlePacket(pkt) {
+        switch (pkt.op) {
+            case OP_HELLO: {
+                const interval = pkt.d.heartbeat_interval;
+                this.startHeartbeat(interval);
+                if (this.sessionId !== null && this.lastSeq !== null) {
+                    this.resumeAttempted = true;
+                    void this.sendResume().catch(() => this.ws?.terminate());
+                }
+                else {
+                    this.resumeAttempted = false;
+                    void this.sendIdentify().catch(() => this.ws?.terminate());
+                }
+                break;
+            }
+            case OP_HEARTBEAT_ACK:
+                break;
+            case OP_DISPATCH: {
+                this.lastSeq = pkt.s ?? this.lastSeq;
+                const d = (pkt.d ?? {});
+                if (this.isDuplicate(pkt.id ?? String(d.msg_id ?? "")))
+                    return;
+                this.handleDispatch(pkt.t ?? "", d);
+                break;
+            }
+        }
+    }
+    async sendIdentify() {
+        const token = await this.opts.getToken();
+        log("[gateway] 发送 identify...");
+        this.ws?.send(JSON.stringify({
+            op: OP_IDENTIFY,
+            d: { token: `QQBot ${token}`, intents: this.opts.intents, shard: [0, 1] },
+        }));
+    }
+    async sendResume() {
+        const token = await this.opts.getToken();
+        this.ws?.send(JSON.stringify({
+            op: OP_RESUME,
+            d: { token: `QQBot ${token}`, session_id: this.sessionId, seq: this.lastSeq },
+        }));
+    }
+    startHeartbeat(intervalMs) {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = setInterval(() => {
+            this.ws?.send(JSON.stringify({ op: OP_HEARTBEAT, d: this.lastSeq }));
+        }, intervalMs);
+    }
+    handleDispatch(t, d) {
+        if (t === "READY") {
+            this.sessionId = String(d.session_id);
+            this.resumeAttempted = false;
+            this.reconnectAttempt = 0;
+            log("[gateway] ✅ READY，bot 已上线 session=", this.sessionId);
+            this.opts.connected();
+            return;
+        }
+        if (t === "RESUMED") {
+            this.resumeAttempted = false;
+            this.reconnectAttempt = 0;
+            log("[gateway] RESUMED 会话恢复");
+            this.opts.connected();
+            return;
+        }
+        if (t === "C2C_MESSAGE_CREATE") {
+            log("[gateway] C2C 原始数据:", JSON.stringify(d).slice(0, 600));
+            log("[gateway] 收到单聊消息 openid=", String(d.author?.user_openid ?? d.openid ?? ""), "content=", String(d.content ?? "").slice(0, 80));
+            const rawAttachments = Array.isArray(d.attachments) ? d.attachments : [];
+            this.opts.message({
+                openid: String(d.author?.user_openid ?? d.author?.id ?? d.openid ?? ""),
+                content: String(d.content ?? ""),
+                msgId: String(d.id ?? d.msg_id ?? ""),
+                timestamp: Date.parse(String(d.timestamp ?? "")) || Date.now(),
+                attachments: rawAttachments
+                    .filter((a) => !!a && typeof a === "object")
+                    .filter((a) => String(a.content_type ?? a.contentType ?? "") === "image" || String(a.url ?? "").match(/\.(png|jpe?g|gif|webp)/i))
+                    .map((a) => ({
+                    contentType: "image",
+                    url: String(a.url ?? ""),
+                    filename: a.filename === undefined ? undefined : String(a.filename),
+                }))
+                    .filter((a) => a.url),
+                quotedText: extractQuotedText(d),
+            });
+        }
+    }
+}
+export function createGatewayUrlFetcher(restBase, getToken, fetchFn = fetch) {
+    return async () => {
+        const token = await getToken();
+        const res = await fetchFn(`${restBase}${GATEWAY_PATH}`, {
+            headers: { Authorization: `QQBot ${token}` },
+        });
+        if (!res.ok)
+            throw new Error(`get gateway failed: HTTP ${res.status}`);
+        return (await res.json()).url;
+    };
+}

package/qq/stream.js

@@ -0,0 +1,99 @@
+/**
+ * stream_messages 打字机发送器。
+ *
+ * 延迟 begin：首次 update() 即为首片（input_state=1,index=0，content_raw=首批文本），
+ * 其后 update 为全量 replace 续片——正文天然以首片为前缀，保证 replace 前缀链一致
+ * （协议要求续片全量正文以上游已下发前缀开头，否则 40007）。
+ * 内部串行队列保证报文按序发出、index 有序，允许调用方 fire-and-forget。
+ */
+export class StreamSender {
+    opts;
+    ref;
+    streamMsgId = null;
+    index = 0;
+    begun = false;
+    finished = false;
+    failed = false;
+    queue = Promise.resolve();
+    constructor(opts, ref) {
+        this.opts = opts;
+        this.ref = ref;
+    }
+    /** 推送当前累计全文；首次调用自动作为首片 */
+    update(fullText) {
+        if (this.failed || this.finished || !fullText)
+            return Promise.resolve();
+        if (!this.begun) {
+            this.begun = true;
+            return this.enqueue(() => ({
+                input_mode: "replace",
+                input_state: 1,
+                index: 0,
+                content_type: "markdown",
+                content_raw: fullText,
+                msg_id: this.ref.msgId,
+                msg_seq: this.ref.msgSeq,
+            }));
+        }
+        return this.enqueue(() => this.pieceBody(1, fullText));
+    }
+    /** 收尾片；从未发过片时先补首片再收尾 */
+    finish(fullText) {
+        if (this.failed || this.finished || !fullText)
+            return Promise.resolve();
+        if (!this.begun) {
+            const first = this.update(fullText);
+            this.finished = true;
+            return first.then(() => {
+                if (this.failed)
+                    return;
+                return this.enqueue(() => this.pieceBody(10, fullText));
+            });
+        }
+        this.finished = true;
+        return this.enqueue(() => this.pieceBody(10, fullText));
+    }
+    /** 续片/收尾通用报文；index 与 stream_msg_id 在实际发送时取最新值 */
+    pieceBody(inputState, fullText) {
+        return {
+            input_mode: "replace",
+            input_state: inputState,
+            index: this.index,
+            content_type: "markdown",
+            content_raw: fullText,
+            ...(this.streamMsgId ? { stream_msg_id: this.streamMsgId } : {}),
+            msg_seq: this.ref.msgSeq,
+        };
+    }
+    /** FIFO 串行队列：body 延迟到执行时构造，确保拿到最新 index/stream_msg_id */
+    enqueue(makeBody) {
+        const task = this.queue.then(async () => {
+            await this.post(makeBody());
+        });
+        this.queue = task.catch(() => { });
+        return task;
+    }
+    async post(body) {
+        if (this.failed)
+            return; // 排队期间被置败（如重入作废）则放弃执行
+        try {
+            const token = await this.opts.getToken();
+            const res = await (this.opts.fetchFn ?? fetch)(`${this.opts.restBase}/v2/users/${this.ref.openid}/stream_messages`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: `QQBot ${token}` },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                this.failed = true; // 含 40007 前缀冲突 / 50002 限频 / 其他
+                return;
+            }
+            const data = (await res.json());
+            if (!this.streamMsgId && data.id)
+                this.streamMsgId = data.id;
+            this.index++;
+        }
+        catch {
+            this.failed = true;
+        }
+    }
+}

package/relay.js

@@ -0,0 +1,26 @@
+/**
+ * V2 版工具钩子：`ctx.tool.hook("execute.after", cb)` 的回调只接收一个 input 参数，
+ * 结构为 { tool, sessionID, status, result?, error?, ... }。
+ * 这里合成总线形状事件 {type:"tool.execute.after", properties:{sessionID, tool, title}}
+ * 交给 index.js 的 listeners 分发。
+ */
+export function toolExecuteAfterHook(emit) {
+  return async (input) => {
+    let title = "";
+    if (input.status === "completed") {
+      const r = input.result ?? {};
+      title = r.title ?? r.description ?? (typeof r.output === "string" ? r.output : "") ?? "";
+    } else {
+      const e = input.error ?? {};
+      title = e.message ?? String(e.name ?? "error");
+    }
+    emit({
+      type: "tool.execute.after",
+      properties: {
+        sessionID: input.sessionID,
+        tool: input.tool,
+        title: typeof title === "string" ? title : String(title ?? ""),
+      },
+    });
+  };
+}

package/session-manager.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import { parseCommand } from "./commands";
+export class SessionManager {
+    bridge;
+    persistPath;
+    fsMod;
+    pendingCount;
+    map = new Map();
+    constructor(bridge, persistPath, fsMod = fs, 
+    /** 终审 I4a：可选，返回某会话当前待审批数（/status 展示） */
+    pendingCount) {
+        this.bridge = bridge;
+        this.persistPath = persistPath;
+        this.fsMod = fsMod;
+        this.pendingCount = pendingCount;
+        try {
+            const raw = JSON.parse(this.fsMod.readFileSync(persistPath, "utf8"));
+            for (const [k, v] of Object.entries(raw))
+                this.map.set(k, v);
+        }
+        catch {
+            /* 首次运行无文件 */
+        }
+    }
+    async getSessionId(openid) {
+        return this.map.get(openid) ?? null;
+    }
+    isOurSession(sessionId) {
+        for (const sid of this.map.values())
+            if (sid === sessionId)
+                return true;
+        return false;
+    }
+    snapshot() {
+        return Object.fromEntries(this.map);
+    }
+    reset(openid) {
+        const sid = this.map.get(openid);
+        this.map.delete(openid);
+        this.persist();
+        if (sid)
+            this.bridge.onSessionReset?.(sid);
+    }
+    /** 返回要发回 QQ 的文本 */
+    async dispatch(openid, text, files = []) {
+        const cmd = parseCommand(text);
+        if (cmd) {
+            switch (cmd.type) {
+                case "new":
+                    this.reset(openid);
+                    return "已重置会话，下次消息将开启新对话。";
+                case "status":
+                    return this.statusReply(openid);
+                case "help":
+                    return [
+                        "opencode-qq 指令:",
+                        "/new — 重置当前会话",
+                        "/status — 查看会话状态",
+                        "/help — 本帮助",
+                        "其余文本将直接交给 opencode 处理。",
+                    ].join("\n");
+            }
+        }
+        let sessionId = await this.getSessionId(openid);
+        if (!sessionId) {
+            const title = text.slice(0, 20);
+            const created = await this.bridge.sessionCreate(title);
+            sessionId = created.id;
+            this.map.set(openid, sessionId);
+            this.persist();
+            await this.bridge.sessionPrompt(sessionId, "以下用户将通过 QQ 单聊与你对话，回答请精炼。", true);
+        }
+        const result = await this.bridge.sessionPrompt(sessionId, text, false, files);
+        const out = result.parts
+            .filter((p) => p.type === "text" && typeof p.text === "string")
+            .map((p) => p.text)
+            .join("");
+        return out || "(无文本回复)";
+    }
+    async statusReply(openid) {
+        const sid = await this.getSessionId(openid);
+        if (!sid)
+            return "暂无会话，发任意消息即可开始。";
+        let reply = `当前会话: ${sid}\n状态: 已就绪`;
+        const pending = this.pendingCount?.(sid);
+        if (pending !== undefined)
+            reply += `\n待审批: ${pending} 条`;
+        return reply;
+    }
+    persist() {
+        try {
+            this.fsMod.writeFileSync(this.persistPath, JSON.stringify(Object.fromEntries(this.map)));
+        }
+        catch {
+            /* 写失败不影响主流程 */
+        }
+    }
+}

package/stream-buffer.js

@@ -0,0 +1,36 @@
+/**
+ * V2 版流式文本缓冲：
+ * V2 事件模型里 assistant 文本以 `session.text.delta` 增量推送，
+ * 无需 V1 的 message.updated 角色映射，直接按 sessionID 累计即可。
+ */
+export class AssistantTextBuffer {
+  isOurSession;
+  /** sessionID → 累计文本 */
+  parts = new Map();
+
+  constructor(isOurSession) {
+    this.isOurSession = isOurSession;
+  }
+
+  handle(evt) {
+    if (evt.type !== "session.text.delta") return;
+    const props = evt.properties ?? {};
+    const sid = String(props.sessionID ?? "");
+    const delta = typeof props.delta === "string" ? props.delta : "";
+    if (!sid || !delta || !this.isOurSession(sid)) return;
+    this.parts.set(sid, (this.parts.get(sid) ?? "") + delta);
+  }
+
+  text(sessionId) {
+    const t = this.parts.get(sessionId);
+    return t && t.length > 0 ? t : null;
+  }
+
+  clear(sessionId) {
+    this.parts.delete(sessionId);
+  }
+
+  clearAll() {
+    this.parts.clear();
+  }
+}

package/util/chunk.js

@@ -0,0 +1,46 @@
+export function splitText(text, maxBytes = 1900) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes)
+        return text ? [text] : [];
+    const parts = [];
+    let current = "";
+    let currentBytes = 0;
+    for (const seg of text.split(/(?<=\n)/)) {
+        const segBytes = Buffer.byteLength(seg, "utf8");
+        if (segBytes > maxBytes) {
+            if (current) {
+                parts.push(current);
+                current = "";
+                currentBytes = 0;
+            }
+            let buf = "";
+            let bufBytes = 0;
+            for (const ch of seg) {
+                const chBytes = Buffer.byteLength(ch, "utf8");
+                if (bufBytes + chBytes > maxBytes) {
+                    parts.push(buf);
+                    buf = ch;
+                    bufBytes = chBytes;
+                }
+                else {
+                    buf += ch;
+                    bufBytes += chBytes;
+                }
+            }
+            current = buf;
+            currentBytes = bufBytes;
+            continue;
+        }
+        if (currentBytes + segBytes > maxBytes) {
+            parts.push(current);
+            current = seg;
+            currentBytes = segBytes;
+        }
+        else {
+            current += seg;
+            currentBytes += segBytes;
+        }
+    }
+    if (current)
+        parts.push(current);
+    return parts;
+}

package/util/media.js

@@ -0,0 +1,19 @@
+const MIME_BY_EXT = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+};
+export function guessImageMime(url) {
+    const clean = url.split("?")[0] ?? "";
+    const ext = clean.split(".").pop()?.toLowerCase() ?? "";
+    return MIME_BY_EXT[ext] ?? "image/png";
+}
+export async function toImageDataUrl(url, fetchFn = fetch) {
+    const res = await fetchFn(url);
+    if (!res.ok)
+        throw new Error(`download attachment failed: HTTP ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    return `data:${guessImageMime(url)};base64,${buf.toString("base64")}`;
+}

package/util/quote.js

@@ -0,0 +1,25 @@
+/** 官方未完全文档化 message_type=103 的 msg_elements 结构，做防御性递归提取 */
+export function extractQuotedText(d) {
+    if (Number(d.message_type) !== 103)
+        return "";
+    const out = [];
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(walk);
+            return;
+        }
+        if (node && typeof node === "object") {
+            const obj = node;
+            if (typeof obj.content === "string" && obj.content.trim())
+                out.push(obj.content);
+            if (obj.text_element)
+                walk(obj.text_element);
+            for (const key of Object.keys(obj)) {
+                if (key !== "content" && key !== "text_element")
+                    walk(obj[key]);
+            }
+        }
+    };
+    walk(d.msg_elements);
+    return out.join("\n").slice(0, 2000);
+}

package/util/throttle.js

@@ -0,0 +1,33 @@
+export class Throttler {
+    intervalMs;
+    flush;
+    buffers = new Map();
+    timers = new Map();
+    constructor(intervalMs, flush) {
+        this.intervalMs = intervalMs;
+        this.flush = flush;
+    }
+    push(key, line) {
+        let buf = this.buffers.get(key);
+        if (!buf) {
+            buf = [];
+            this.buffers.set(key, buf);
+            this.timers.set(key, setTimeout(() => this.flushKey(key), this.intervalMs));
+        }
+        buf.push(line);
+    }
+    flushKey(key) {
+        const timer = this.timers.get(key);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(key);
+        const buf = this.buffers.get(key);
+        this.buffers.delete(key);
+        if (buf && buf.length > 0)
+            this.flush(key, buf);
+    }
+    dispose() {
+        for (const key of [...this.buffers.keys()])
+            this.flushKey(key);
+    }
+}