qqbot-opencode 1.0.0

package/dist/bundle.js

@@ -0,0 +1,826 @@
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+function loadConfig(configPath) {
+  const absolutePath = path.resolve(configPath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  const rawContent = fs.readFileSync(absolutePath, "utf-8");
+  const config = yaml.load(rawContent);
+  validateConfig(config);
+  return config;
+}
+function validateConfig(config) {
+  if (!config.qq?.appId) {
+    throw new Error("Missing required field: qq.appId");
+  }
+  if (!config.qq?.clientSecret) {
+    throw new Error("Missing required field: qq.clientSecret");
+  }
+  if (!config.opencode?.port) {
+    config.opencode.port = 4096;
+  }
+  if (!config.opencode?.hostname) {
+    config.opencode.hostname = "127.0.0.1";
+  }
+  if (!config.app?.workingDir) {
+    config.app.workingDir = process.cwd();
+  }
+}
+function expandEnvVariables(obj) {
+  if (typeof obj === "string") {
+    const envVarPattern = /\$\{([^}]+)\}/g;
+    return obj.replace(envVarPattern, (_, envName) => {
+      return process.env[envName] || "";
+    });
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(expandEnvVariables);
+  }
+  if (obj && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = expandEnvVariables(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/qq/connection.ts
+import WebSocket from "ws";
+var INTENTS = {
+  GUILDS: 1 << 0,
+  GUILD_MEMBERS: 1 << 1,
+  PUBLIC_GUILD_MESSAGES: 1 << 30,
+  DIRECT_MESSAGE: 1 << 12,
+  GROUP_AND_C2C: 1 << 25
+};
+var FULL_INTENTS = INTENTS.PUBLIC_GUILD_MESSAGES | INTENTS.DIRECT_MESSAGE | INTENTS.GROUP_AND_C2C;
+var API_BASE = "https://api.sgroup.qq.com";
+var TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
+var accessToken = null;
+var sessionId = null;
+var lastSeq = null;
+var reconnectAttempts = 0;
+var MAX_RECONNECT_ATTEMPTS = 10;
+var RECONNECT_DELAY = 5e3;
+async function getAccessToken(appId, clientSecret) {
+  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();
+  if (!data.access_token) {
+    throw new Error(`Failed to get access token: ${JSON.stringify(data)}`);
+  }
+  return data.access_token;
+}
+async function getGatewayUrl(token) {
+  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();
+  return data.url;
+}
+async function startQQConnection(options) {
+  const { qq, onMessage, onReady, onError, onDisconnect } = options;
+  accessToken = await getAccessToken(qq.appId, qq.clientSecret);
+  return new Promise((resolve, reject) => {
+    let ws = null;
+    let heartbeatInterval = null;
+    let isReconnecting = false;
+    async function connect() {
+      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);
+          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.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;
+              sessionId = readyData.session_id;
+              console.log("[QQ] Ready, session:", sessionId);
+              onReady?.();
+            } else if (t === "C2C_MESSAGE_CREATE") {
+              const event = d;
+              if (event.author?.user_openid) {
+                onMessage(event);
+              }
+            }
+          } else if (op === 11) {
+          } else if (op === 7) {
+            console.log("[QQ] Server requested reconnect");
+            cleanup();
+            scheduleReconnect();
+          } else if (op === 9) {
+            const canResume = d;
+            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() {
+      if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+      }
+    }
+    function scheduleReconnect() {
+      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);
+  });
+}
+
+// src/qq/sender.ts
+import crypto from "crypto";
+var API_BASE2 = "https://api.sgroup.qq.com";
+var TOKEN_URL2 = "https://bots.qq.com/app/getAppAccessToken";
+var tokenCache = null;
+async function getAccessToken2(appId, clientSecret) {
+  if (tokenCache && Date.now() < tokenCache.expiresAt - 6e4) {
+    return tokenCache.token;
+  }
+  const response = await fetch(TOKEN_URL2, {
+    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();
+  if (!data.access_token) {
+    throw new Error(`Failed to get access token: ${JSON.stringify(data)}`);
+  }
+  tokenCache = {
+    token: data.access_token,
+    expiresAt: Date.now() + (data.expires_in ?? 7200) * 1e3
+  };
+  return tokenCache.token;
+}
+function getNextMsgSeq(msgId) {
+  const hash = crypto.createHash("md5").update(msgId).digest("hex");
+  return parseInt(hash.substring(0, 8), 16) % 9007199254740990 + 1;
+}
+async function apiRequest(accessToken2, method, path2, body) {
+  const url = `${API_BASE2}${path2}`;
+  const response = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `QQBot ${accessToken2}`,
+      "Content-Type": "application/json"
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API Error [${path2}]: ${response.status} - ${errorText}`);
+  }
+  return response.json();
+}
+async function sendC2CMessage(account, options) {
+  const token = await getAccessToken2(account.appId, account.clientSecret);
+  const msgSeq = getNextMsgSeq(options.messageId);
+  const useMarkdown = options.markdown ?? account.markdownSupport ?? false;
+  let body;
+  if (useMarkdown) {
+    body = {
+      markdown: { content: options.content },
+      msg_type: 2,
+      msg_seq: msgSeq,
+      msg_id: options.messageId
+    };
+  } else {
+    body = {
+      content: options.content,
+      msg_type: 0,
+      msg_seq: msgSeq,
+      msg_id: options.messageId
+    };
+  }
+  if (options.quoteRef && !useMarkdown) {
+    body.message_reference = { message_id: options.quoteRef };
+  }
+  await apiRequest(token, "POST", `/v2/users/${options.toOpenid}/messages`, body);
+}
+function clearTokenCache() {
+  tokenCache = null;
+}
+
+// src/qq/parser.ts
+var FACE_TAG_REGEX = /<face name="([^"]+)"[^/]*\/>/gi;
+function parseMessage(event) {
+  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) {
+  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], `[\u8868\u60C5:${faceName}]`);
+  }
+  return result;
+}
+function extractImageUrls(content) {
+  const urls = [];
+  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) {
+  return content.replace(/https?:\/\/[^\s"'<>]+\.(?:png|jpg|jpeg|gif|webp)(?:\?[^\s"'<>]*)?/gi, "").trim();
+}
+function parseQuoteRef(event) {
+  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 {
+  }
+  return {};
+}
+function chunkText(text, limit) {
+  if (!text || text.length === 0) {
+    return [];
+  }
+  if (text.length <= limit) {
+    return [text];
+  }
+  const chunks = [];
+  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, limit) {
+  const chunks = [];
+  for (let i = 0; i < line.length; i += limit) {
+    chunks.push(line.slice(i, i + limit));
+  }
+  return chunks;
+}
+
+// src/opencode/client.ts
+import { createOpencode } from "@opencode-ai/sdk";
+var instance = null;
+async function initOpencodeClient(config) {
+  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;
+}
+async function createSession() {
+  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
+  };
+}
+async function switchSession(sessionId2) {
+  if (!instance) {
+    throw new Error("Opencode client not initialized");
+  }
+  const sessionResponse = await instance.client.session.get({
+    path: { id: sessionId2 }
+  });
+  const session = sessionResponse.data;
+  if (!session) {
+    throw new Error(`Session not found: ${sessionId2}`);
+  }
+  instance.currentSessionId = sessionId2;
+  console.log(`[Opencode] Switched to session: ${sessionId2}`);
+  return {
+    id: session.id,
+    title: session.title
+  };
+}
+async function listSessions() {
+  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
+  }));
+}
+async function getCurrentSession() {
+  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
+  };
+}
+async function sendPrompt(message, imageUrls = []) {
+  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 = [
+    { 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
+      }
+    });
+    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;
+  }
+}
+async function closeOpencodeClient() {
+  if (instance) {
+    instance.server.close();
+    instance = null;
+    console.log("[Opencode] Client closed");
+  }
+}
+
+// src/handlers/session.ts
+async function handleSessionNew() {
+  try {
+    const session = await createSession();
+    return {
+      text: `\u5DF2\u521B\u5EFA\u65B0\u4F1A\u8BDD: ${session.id}
+\u6807\u9898: ${session.title || "\u65E0"}`,
+      success: true
+    };
+  } catch (err) {
+    return {
+      text: `\u521B\u5EFA\u4F1A\u8BDD\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+      success: false
+    };
+  }
+}
+async function handleSessionSwitch(sessionId2) {
+  if (!sessionId2 || sessionId2.trim() === "") {
+    return {
+      text: "\u8BF7\u63D0\u4F9B\u4F1A\u8BDD ID\uFF0C\u4F8B\u5982: /session-switch <id>",
+      success: false
+    };
+  }
+  try {
+    const session = await switchSession(sessionId2.trim());
+    return {
+      text: `\u5DF2\u5207\u6362\u5230\u4F1A\u8BDD: ${session.id}
+\u6807\u9898: ${session.title || "\u65E0"}`,
+      success: true
+    };
+  } catch (err) {
+    return {
+      text: `\u5207\u6362\u4F1A\u8BDD\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+      success: false
+    };
+  }
+}
+async function handleSessionList() {
+  try {
+    const sessions = await listSessions();
+    if (sessions.length === 0) {
+      return {
+        text: "\u6682\u65E0\u4F1A\u8BDD",
+        success: true
+      };
+    }
+    const currentSession = await getCurrentSession();
+    const currentId = currentSession?.id;
+    const lines = sessions.map((s, i) => {
+      const marker = s.id === currentId ? " [\u5F53\u524D]" : "";
+      const title = s.title ? ` - ${s.title}` : "";
+      return `${i + 1}. ${s.id}${title}${marker}`;
+    });
+    return {
+      text: `\u4F1A\u8BDD\u5217\u8868:
+${lines.join("\n")}`,
+      success: true
+    };
+  } catch (err) {
+    return {
+      text: `\u83B7\u53D6\u4F1A\u8BDD\u5217\u8868\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+      success: false
+    };
+  }
+}
+async function handleSessionCurrent() {
+  try {
+    const session = await getCurrentSession();
+    if (!session) {
+      return {
+        text: "\u5F53\u524D\u6CA1\u6709\u6D3B\u8DC3\u7684\u4F1A\u8BDD",
+        success: true
+      };
+    }
+    return {
+      text: `\u5F53\u524D\u4F1A\u8BDD:
+ID: ${session.id}
+\u6807\u9898: ${session.title || "\u65E0"}`,
+      success: true
+    };
+  } catch (err) {
+    return {
+      text: `\u83B7\u53D6\u5F53\u524D\u4F1A\u8BDD\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+      success: false
+    };
+  }
+}
+function parseSessionCommand(content) {
+  const trimmed = content.trim();
+  if (trimmed === "/session-new") {
+    return { command: "new", args: "" };
+  }
+  if (trimmed.startsWith("/session-switch ")) {
+    const args = trimmed.slice("/session-switch ".length).trim();
+    return { command: "switch", args };
+  }
+  if (trimmed === "/session-list") {
+    return { command: "list", args: "" };
+  }
+  if (trimmed === "/session-current") {
+    return { command: "current", args: "" };
+  }
+  return null;
+}
+
+// src/handlers/message.ts
+async function handleMessage(content, parsedMessage) {
+  const sessionCmd = parseSessionCommand(content);
+  if (sessionCmd) {
+    return handleSessionCommand(sessionCmd.command, sessionCmd.args);
+  }
+  return handleAIMessage(content, parsedMessage);
+}
+async function handleSessionCommand(command, args) {
+  let result;
+  switch (command) {
+    case "new":
+      result = await handleSessionNew();
+      break;
+    case "switch":
+      result = await handleSessionSwitch(args);
+      break;
+    case "list":
+      result = await handleSessionList();
+      break;
+    case "current":
+      result = await handleSessionCurrent();
+      break;
+    default:
+      result = {
+        text: "\u672A\u77E5\u7684 session \u547D\u4EE4",
+        success: false
+      };
+  }
+  return {
+    ...result,
+    isSessionCommand: true
+  };
+}
+async function handleAIMessage(content, parsedMessage) {
+  try {
+    const result = await sendPrompt(content, parsedMessage.imageUrls);
+    if (!result.text || result.text.trim() === "") {
+      return {
+        text: "AI \u8FD4\u56DE\u4E86\u7A7A\u54CD\u5E94",
+        success: true
+      };
+    }
+    return {
+      text: result.text,
+      success: true
+    };
+  } catch (err) {
+    return {
+      text: `\u5904\u7406\u6D88\u606F\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`,
+      success: false
+    };
+  }
+}
+
+// src/app.ts
+var TEXT_CHUNK_LIMIT = 500;
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--config" && i + 1 < args.length) {
+      result.config = args[i + 1];
+      i++;
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return result;
+}
+function printHelp() {
+  console.log(`
+QQ Bot with OpenCode SDK
+
+Usage:
+  npx tsx src/app.ts --config <config.yaml>
+
+Options:
+  --config <path>  Path to config.yaml file (required)
+  --help, -h       Show this help message
+
+Example:
+  npx tsx src/app.ts --config ./config.yaml
+  `);
+}
+async function main() {
+  const args = parseArgs();
+  if (!args.config) {
+    console.error("Error: --config option is required");
+    printHelp();
+    process.exit(1);
+  }
+  console.log("[App] Loading configuration...");
+  let config;
+  try {
+    config = loadConfig(args.config);
+  } catch (err) {
+    console.error(`[App] Failed to load config: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const expandedConfig = expandEnvVariables(config);
+  console.log("[App] Initializing OpenCode client...");
+  try {
+    await initOpencodeClient(expandedConfig.opencode);
+    console.log("[App] OpenCode client initialized");
+  } catch (err) {
+    console.error(`[App] Failed to initialize OpenCode: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  try {
+    await createSession();
+  } catch (err) {
+    console.error(`[App] Failed to create initial session: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  console.log("[App] Starting QQ connection...");
+  try {
+    await startQQConnection({
+      qq: expandedConfig.qq,
+      onMessage: async (event) => {
+        console.log(`[App] Received message from ${event.author.user_openid}: ${event.content.slice(0, 50)}...`);
+        try {
+          const parsed = parseMessage(event);
+          const result = await handleMessage(parsed.content, parsed);
+          const chunks = chunkText(result.text, TEXT_CHUNK_LIMIT);
+          for (const chunk of chunks) {
+            await sendC2CMessage(expandedConfig.qq, {
+              toOpenid: event.author.user_openid,
+              content: chunk,
+              messageId: event.id
+            });
+          }
+          console.log(`[App] Sent response to ${event.author.user_openid}`);
+        } catch (err) {
+          console.error(`[App] Error handling message: ${err instanceof Error ? err.message : String(err)}`);
+          const errorText = `\u5904\u7406\u6D88\u606F\u65F6\u51FA\u9519: ${err instanceof Error ? err.message : String(err)}`;
+          try {
+            await sendC2CMessage(expandedConfig.qq, {
+              toOpenid: event.author.user_openid,
+              content: errorText,
+              messageId: event.id
+            });
+          } catch (sendErr) {
+            console.error(`[App] Failed to send error message: ${sendErr}`);
+          }
+        }
+      },
+      onReady: () => {
+        console.log("[App] QQ Bot is ready!");
+      },
+      onError: (err) => {
+        console.error(`[App] QQ connection error: ${err.message}`);
+      },
+      onDisconnect: () => {
+        console.log("[App] QQ disconnected, will attempt to reconnect...");
+      }
+    });
+  } catch (err) {
+    console.error(`[App] Failed to start QQ connection: ${err instanceof Error ? err.message : String(err)}`);
+    await closeOpencodeClient();
+    process.exit(1);
+  }
+  console.log("[App] Bot is running. Press Ctrl+C to stop.");
+  const shutdown = async () => {
+    console.log("\n[App] Shutting down...");
+    clearTokenCache();
+    await closeOpencodeClient();
+    console.log("[App] Goodbye!");
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  console.error(`[App] Fatal error: ${err}`);
+  process.exit(1);
+});