qqbot-opencode 1.0.0

package/src/opencode/client.ts

@@ -0,0 +1,204 @@
+import { createOpencode } from "@opencode-ai/sdk";
+import type { OpencodeConfig } from "../types.js";
+
+interface OpencodeClientInstance {
+  client: Awaited<ReturnType<typeof createOpencode>>["client"];
+  server: Awaited<ReturnType<typeof createOpencode>>["server"];
+  currentSessionId: string | null;
+}
+
+interface SessionInfo {
+  id: string;
+  title?: string;
+}
+
+let instance: OpencodeClientInstance | null = null;
+
+export async function initOpencodeClient(
+  config: OpencodeConfig,
+): Promise<OpencodeClientInstance> {
+  const opencodeConfig = config.config || {};
+
+  const { client, server } = await createOpencode({
+    hostname: config.hostname,
+    port: config.port,
+    config: opencodeConfig,
+  });
+
+  instance = {
+    client,
+    server,
+    currentSessionId: null,
+  };
+
+  const sessionsResponse = await client.session.list();
+  const sessions = sessionsResponse.data;
+  if (sessions && sessions.length > 0) {
+    instance.currentSessionId = sessions[0].id;
+    console.log(`[Opencode] Resumed session: ${sessions[0].id}`);
+  }
+
+  return instance;
+}
+
+export async function createSession(): Promise<SessionInfo> {
+  if (!instance) {
+    throw new Error("Opencode client not initialized");
+  }
+
+  const sessionResponse = await instance.client.session.create({
+    body: {},
+  });
+
+  const session = sessionResponse.data;
+  if (!session) {
+    throw new Error("Failed to create session");
+  }
+
+  instance.currentSessionId = session.id;
+  console.log(`[Opencode] Created new session: ${session.id}`);
+
+  return {
+    id: session.id,
+    title: session.title,
+  };
+}
+
+export async function switchSession(sessionId: string): Promise<SessionInfo> {
+  if (!instance) {
+    throw new Error("Opencode client not initialized");
+  }
+
+  const sessionResponse = await instance.client.session.get({
+    path: { id: sessionId },
+  });
+
+  const session = sessionResponse.data;
+  if (!session) {
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+
+  instance.currentSessionId = sessionId;
+  console.log(`[Opencode] Switched to session: ${sessionId}`);
+
+  return {
+    id: session.id,
+    title: session.title,
+  };
+}
+
+export async function listSessions(): Promise<SessionInfo[]> {
+  if (!instance) {
+    throw new Error("Opencode client not initialized");
+  }
+
+  const sessionsResponse = await instance.client.session.list();
+  const sessions = sessionsResponse.data;
+
+  if (!sessions) {
+    return [];
+  }
+
+  return sessions.map((s) => ({
+    id: s.id,
+    title: s.title,
+  }));
+}
+
+export async function getCurrentSession(): Promise<SessionInfo | null> {
+  if (!instance || !instance.currentSessionId) {
+    return null;
+  }
+
+  const sessionResponse = await instance.client.session.get({
+    path: { id: instance.currentSessionId },
+  });
+
+  const session = sessionResponse.data;
+  if (!session) {
+    return null;
+  }
+
+  return {
+    id: session.id,
+    title: session.title,
+  };
+}
+
+export interface PromptResult {
+  text: string;
+}
+
+export async function sendPrompt(
+  message: string,
+  imageUrls: string[] = [],
+): Promise<PromptResult> {
+  if (!instance || !instance.currentSessionId) {
+    throw new Error("Opencode client not initialized or no active session");
+  }
+
+  console.log(
+    `[Opencode] Sending prompt to session ${instance.currentSessionId}: "${message.slice(0, 50)}..."`,
+  );
+
+  const parts: Array<
+    { type: "text"; text: string } | { type: "image_url"; url: string }
+  > = [{ type: "text", text: message }];
+
+  for (const imageUrl of imageUrls) {
+    if (imageUrl.startsWith("http://") || imageUrl.startsWith("https://")) {
+      parts.push({ type: "image_url", url: imageUrl });
+    }
+  }
+
+  try {
+    const resultResponse = await instance.client.session.prompt({
+      path: { id: instance.currentSessionId },
+      body: {
+        parts: parts as any,
+      },
+    });
+
+    console.log(
+      `[Opencode] Prompt response:`,
+      JSON.stringify(resultResponse, null, 2).slice(0, 500),
+    );
+
+    const result = resultResponse.data;
+    let text = "";
+
+    if (result?.parts && Array.isArray(result.parts)) {
+      for (const part of result.parts) {
+        console.log(`[Opencode] Part type: ${part.type}`, part);
+        if (part.type === "text" && part.text) {
+          text += part.text;
+        }
+      }
+    } else {
+      console.log(`[Opencode] No parts in response or unexpected format`);
+    }
+
+    if (!text) {
+      console.log(`[Opencode] Empty response text, checking info...`);
+      if (result?.info) {
+        console.log(
+          `[Opencode] Response info:`,
+          JSON.stringify(result.info).slice(0, 500),
+        );
+      }
+    }
+
+    return { text };
+  } catch (err) {
+    console.error(`[Opencode] Prompt error:`, err);
+    throw err;
+  }
+}
+
+export async function closeOpencodeClient(): Promise<void> {
+  if (instance) {
+    instance.server.close();
+    instance = null;
+    console.log("[Opencode] Client closed");
+  }
+}

package/src/opencode/index.ts

@@ -0,0 +1 @@
+export * from "./client.js";

package/src/qq/connection.ts

@@ -0,0 +1,252 @@
+import WebSocket from "ws";
+import type { QQConfig } from "../types.js";
+
+interface WSPayload {
+  op: number;
+  d: unknown;
+  s?: number;
+  t?: string;
+}
+
+interface C2CMessageEvent {
+  id: string;
+  content: string;
+  timestamp: number;
+  author: {
+    user_openid: string;
+    username?: string;
+  };
+  message_scene?: {
+    ext?: string;
+  };
+}
+
+interface ConnectionOptions {
+  qq: QQConfig;
+  onMessage: (event: C2CMessageEvent) => void;
+  onReady?: () => void;
+  onError?: (error: Error) => void;
+  onDisconnect?: () => void;
+}
+
+const INTENTS = {
+  GUILDS: 1 << 0,
+  GUILD_MEMBERS: 1 << 1,
+  PUBLIC_GUILD_MESSAGES: 1 << 30,
+  DIRECT_MESSAGE: 1 << 12,
+  GROUP_AND_C2C: 1 << 25,
+};
+
+const FULL_INTENTS =
+  INTENTS.PUBLIC_GUILD_MESSAGES |
+  INTENTS.DIRECT_MESSAGE |
+  INTENTS.GROUP_AND_C2C;
+const API_BASE = "https://api.sgroup.qq.com";
+const TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
+
+let accessToken: string | null = null;
+let sessionId: string | null = null;
+let lastSeq: number | null = null;
+let reconnectAttempts = 0;
+const MAX_RECONNECT_ATTEMPTS = 10;
+const RECONNECT_DELAY = 5000;
+
+async function getAccessToken(
+  appId: string,
+  clientSecret: string,
+): Promise<string> {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ appId, clientSecret }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to get access token: ${response.status} - ${errorText}`,
+    );
+  }
+
+  const data = (await response.json()) as {
+    access_token?: string;
+    expires_in?: number;
+  };
+
+  if (!data.access_token) {
+    throw new Error(`Failed to get access token: ${JSON.stringify(data)}`);
+  }
+
+  return data.access_token;
+}
+
+async function getGatewayUrl(token: string): Promise<string> {
+  const response = await fetch(`${API_BASE}/gateway`, {
+    method: "GET",
+    headers: {
+      Authorization: `QQBot ${token}`,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to get gateway URL: ${response.status}`);
+  }
+
+  const data = (await response.json()) as { url: string };
+  return data.url;
+}
+
+export async function startQQConnection(
+  options: ConnectionOptions,
+): Promise<void> {
+  const { qq, onMessage, onReady, onError, onDisconnect } = options;
+
+  accessToken = await getAccessToken(qq.appId, qq.clientSecret);
+
+  return new Promise((resolve, reject) => {
+    let ws: WebSocket | null = null;
+    let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+    let isReconnecting = false;
+
+    async function connect(): Promise<void> {
+      const gatewayUrl = await getGatewayUrl(accessToken!);
+      console.log(`[QQ] Connecting to gateway: ${gatewayUrl}`);
+      ws = new WebSocket(gatewayUrl);
+
+      ws.on("open", () => {
+        console.log("[QQ] WebSocket connected");
+        reconnectAttempts = 0;
+      });
+
+      ws.on("message", async (data) => {
+        try {
+          const rawData = data.toString();
+          const payload = JSON.parse(rawData) as WSPayload;
+          const { op, d, s, t } = payload;
+
+          if (s) {
+            lastSeq = s;
+          }
+
+          if (op === 10) {
+            console.log("[QQ] Hello received");
+
+            if (sessionId && lastSeq !== null) {
+              console.log("[QQ] Attempting to resume session");
+              ws?.send(
+                JSON.stringify({
+                  op: 6,
+                  d: {
+                    token: `QQBot ${accessToken}`,
+                    session_id: sessionId,
+                    seq: lastSeq,
+                  },
+                }),
+              );
+            } else {
+              console.log("[QQ] Sending identify with intents:", FULL_INTENTS);
+              ws?.send(
+                JSON.stringify({
+                  op: 2,
+                  d: {
+                    token: `QQBot ${accessToken}`,
+                    intents: FULL_INTENTS,
+                    shard: [0, 1],
+                  },
+                }),
+              );
+            }
+
+            const interval = (d as { heartbeat_interval: number })
+              .heartbeat_interval;
+            if (heartbeatInterval) clearInterval(heartbeatInterval);
+            heartbeatInterval = setInterval(() => {
+              if (ws?.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ op: 1, d: lastSeq }));
+              }
+            }, interval);
+          } else if (op === 0) {
+            if (t === "READY") {
+              const readyData = d as { session_id: string };
+              sessionId = readyData.session_id;
+              console.log("[QQ] Ready, session:", sessionId);
+              onReady?.();
+            } else if (t === "C2C_MESSAGE_CREATE") {
+              const event = d as C2CMessageEvent;
+              if (event.author?.user_openid) {
+                onMessage(event);
+              }
+            }
+          } else if (op === 7) {
+            console.log("[QQ] Server requested reconnect");
+            cleanup();
+            scheduleReconnect();
+          } else if (op === 9) {
+            const canResume = d as boolean;
+            console.log("[QQ] Invalid session, can resume:", canResume);
+            if (!canResume) {
+              sessionId = null;
+              lastSeq = null;
+            }
+            cleanup();
+            scheduleReconnect();
+          }
+        } catch (err) {
+          console.error("[QQ] Message parse error:", err);
+        }
+      });
+
+      ws.on("close", (code, reason) => {
+        console.log(`[QQ] WebSocket closed: ${code} ${reason.toString()}`);
+        cleanup();
+        if (!isReconnecting) {
+          onDisconnect?.();
+          scheduleReconnect();
+        }
+      });
+
+      ws.on("error", (err) => {
+        console.error("[QQ] WebSocket error:", err.message);
+        onError?.(new Error(err.message));
+      });
+    }
+
+    function cleanup(): void {
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+      }
+    }
+
+    function scheduleReconnect(): void {
+      if (isReconnecting) return;
+      if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        console.error("[QQ] Max reconnect attempts reached");
+        reject(new Error("Max reconnect attempts reached"));
+        return;
+      }
+
+      isReconnecting = true;
+      reconnectAttempts++;
+      const delay = RECONNECT_DELAY * reconnectAttempts;
+      console.log(
+        `[QQ] Reconnecting in ${delay}ms (attempt ${reconnectAttempts})`,
+      );
+
+      setTimeout(async () => {
+        isReconnecting = false;
+        try {
+          accessToken = await getAccessToken(qq.appId, qq.clientSecret);
+          await connect();
+        } catch (err) {
+          console.error("[QQ] Reconnect failed:", err);
+          scheduleReconnect();
+        }
+      }, delay);
+    }
+
+    connect().catch(reject);
+  });
+}

package/src/qq/index.ts

@@ -0,0 +1,9 @@
+export { startQQConnection } from "./connection.js";
+export {
+  sendC2CMessage,
+  sendC2CImageMessage,
+  sendC2CFileMessage,
+  clearTokenCache,
+} from "./sender.js";
+export { parseMessage, chunkText } from "./parser.js";
+export type { QQMessageEvent, ParsedMessage } from "../types.js";

package/src/qq/parser.ts

@@ -0,0 +1,126 @@
+import type { QQMessageEvent, ParsedMessage } from "../types.js";
+
+const FACE_TAG_REGEX = /<face name="([^"]+)"[^/]*\/>/gi;
+
+export function parseMessage(event: QQMessageEvent): ParsedMessage {
+  let content = event.content;
+
+  content = parseFaceTags(content);
+  content = content.trim();
+
+  const imageUrls = extractImageUrls(content);
+  content = removeImageUrls(content);
+
+  const { quoteRef, quoteId } = parseQuoteRef(event);
+
+  return {
+    content,
+    imageUrls,
+    quoteRef,
+    quoteId,
+  };
+}
+
+function parseFaceTags(content: string): string {
+  let result = content;
+  let match;
+
+  FACE_TAG_REGEX.lastIndex = 0;
+  while ((match = FACE_TAG_REGEX.exec(content)) !== null) {
+    const faceName = match[1];
+    result = result.replace(match[0], `[表情:${faceName}]`);
+  }
+
+  return result;
+}
+
+function extractImageUrls(content: string): string[] {
+  const urls: string[] = [];
+  let match;
+
+  const regex =
+    /https?:\/\/[^\s"'<>]+\.(?:png|jpg|jpeg|gif|webp)(?:\?[^\s"'<>]*)?/gi;
+  while ((match = regex.exec(content)) !== null) {
+    urls.push(match[0]);
+  }
+
+  return urls;
+}
+
+function removeImageUrls(content: string): string {
+  return content
+    .replace(
+      /https?:\/\/[^\s"'<>]+\.(?:png|jpg|jpeg|gif|webp)(?:\?[^\s"'<>]*)?/gi,
+      "",
+    )
+    .trim();
+}
+
+function parseQuoteRef(event: QQMessageEvent): {
+  quoteRef?: string;
+  quoteId?: string;
+} {
+  const ext = event.message_scene?.ext;
+  if (!ext) {
+    return {};
+  }
+
+  try {
+    const scene = JSON.parse(ext);
+    if (scene?.refMsgIdx) {
+      return {
+        quoteRef: String(scene.refMsgIdx),
+        quoteId: scene.refMsgIdx,
+      };
+    }
+  } catch {
+    // ignore parse errors
+  }
+
+  return {};
+}
+
+export function chunkText(text: string, limit: number): string[] {
+  if (!text || text.length === 0) {
+    return [];
+  }
+
+  if (text.length <= limit) {
+    return [text];
+  }
+
+  const chunks: string[] = [];
+  const lines = text.split("\n");
+  let currentChunk = "";
+
+  for (const line of lines) {
+    if (currentChunk.length + line.length + 1 <= limit) {
+      currentChunk += (currentChunk ? "\n" : "") + line;
+    } else {
+      if (currentChunk) {
+        chunks.push(currentChunk);
+      }
+      if (line.length <= limit) {
+        currentChunk = line;
+      } else {
+        const subChunks = splitLongLine(line, limit);
+        chunks.push(...subChunks.slice(0, -1));
+        currentChunk = subChunks[subChunks.length - 1] || "";
+      }
+    }
+  }
+
+  if (currentChunk) {
+    chunks.push(currentChunk);
+  }
+
+  return chunks;
+}
+
+function splitLongLine(line: string, limit: number): string[] {
+  const chunks: string[] = [];
+  for (let i = 0; i < line.length; i += limit) {
+    chunks.push(line.slice(i, i + limit));
+  }
+  return chunks;
+}