@gakr-gakr/qqbot 0.1.0

package/src/engine/approval/index.ts

@@ -0,0 +1,224 @@
+/**
+ * Approval helpers — pure functions, zero framework dependencies.
+ *
+ * - Build approval message text + inline keyboard
+ * - Resolve delivery target from session metadata
+ * - Parse INTERACTION_CREATE button data
+ */
+
+import type { ChatScope, InlineKeyboard, KeyboardButton } from "../types.js";
+
+// ============ Types ============
+
+export interface ExecApprovalRequest {
+  id: string;
+  expiresAtMs: number;
+  request: {
+    commandPreview?: string;
+    command?: string;
+    cwd?: string;
+    agentId?: string;
+    turnSourceAccountId?: string;
+    sessionKey?: string;
+    turnSourceTo?: string;
+    [key: string]: unknown;
+  };
+}
+
+export interface PluginApprovalRequest {
+  id: string;
+  request: {
+    timeoutMs?: number;
+    severity?: string;
+    title: string;
+    description?: string;
+    toolName?: string;
+    pluginId?: string;
+    agentId?: string;
+    turnSourceAccountId?: string;
+    sessionKey?: string;
+    turnSourceTo?: string;
+    [key: string]: unknown;
+  };
+}
+
+type ApprovalDecision = "allow-once" | "allow-always" | "deny";
+
+interface ApprovalTarget {
+  type: ChatScope;
+  id: string;
+}
+
+interface ParsedApprovalAction {
+  approvalId: string;
+  decision: ApprovalDecision;
+}
+
+// ============ Text Builders ============
+
+export function buildExecApprovalText(request: ExecApprovalRequest): string {
+  const expiresIn = Math.max(0, Math.round((request.expiresAtMs - Date.now()) / 1000));
+  const lines: string[] = ["\u{1f510} \u547d\u4ee4\u6267\u884c\u5ba1\u6279", ""];
+  const cmd = request.request.commandPreview ?? request.request.command ?? "";
+  if (cmd) {
+    lines.push(`\`\`\`\n${cmd.slice(0, 300)}\n\`\`\``);
+  }
+  if (request.request.cwd) {
+    lines.push(`\u{1f4c1} \u76ee\u5f55: ${request.request.cwd}`);
+  }
+  if (request.request.agentId) {
+    lines.push(`\u{1f916} Agent: ${request.request.agentId}`);
+  }
+  lines.push("", `\u23f1\ufe0f \u8d85\u65f6: ${expiresIn} \u79d2`);
+  return lines.join("\n");
+}
+
+export function buildPluginApprovalText(request: PluginApprovalRequest): string {
+  const timeoutSec = Math.round((request.request.timeoutMs ?? 120_000) / 1000);
+  const severityIcon =
+    request.request.severity === "critical"
+      ? "\u{1f534}"
+      : request.request.severity === "info"
+        ? "\u{1f535}"
+        : "\u{1f7e1}";
+
+  const lines: string[] = [`${severityIcon} \u5ba1\u6279\u8bf7\u6c42`, ""];
+  lines.push(`\u{1f4cb} ${request.request.title}`);
+  if (request.request.description) {
+    lines.push(`\u{1f4dd} ${request.request.description}`);
+  }
+  if (request.request.toolName) {
+    lines.push(`\u{1f527} \u5de5\u5177: ${request.request.toolName}`);
+  }
+  if (request.request.pluginId) {
+    lines.push(`\u{1f50c} \u63d2\u4ef6: ${request.request.pluginId}`);
+  }
+  if (request.request.agentId) {
+    lines.push(`\u{1f916} Agent: ${request.request.agentId}`);
+  }
+  lines.push("", `\u23f1\ufe0f \u8d85\u65f6: ${timeoutSec} \u79d2`);
+  return lines.join("\n");
+}
+
+// ============ Keyboard Builder ============
+
+/**
+ * Build the three-button inline keyboard for approval messages.
+ *
+ * type=1 (Callback): click triggers INTERACTION_CREATE, button_data = data field.
+ * group_id "approval": clicking one button grays out the others (mutual exclusion).
+ * click_limit=1: each user can only click once.
+ * permission.type=2: all users can interact.
+ */
+export function buildApprovalKeyboard(
+  approvalId: string,
+  allowedDecisions: readonly ApprovalDecision[] = ["allow-once", "allow-always", "deny"],
+): InlineKeyboard {
+  const makeBtn = (
+    id: string,
+    label: string,
+    visitedLabel: string,
+    data: string,
+    style: 0 | 1,
+  ): KeyboardButton => ({
+    id,
+    render_data: { label, visited_label: visitedLabel, style },
+    action: {
+      type: 1,
+      data,
+      permission: { type: 2 },
+      click_limit: 1,
+    },
+    group_id: "approval",
+  });
+
+  const buttons: KeyboardButton[] = [];
+  if (allowedDecisions.includes("allow-once")) {
+    buttons.push(
+      makeBtn(
+        "allow",
+        "\u2705 \u5141\u8bb8\u4e00\u6b21",
+        "\u5df2\u5141\u8bb8",
+        `approve:${approvalId}:allow-once`,
+        1,
+      ),
+    );
+  }
+  if (allowedDecisions.includes("allow-always")) {
+    buttons.push(
+      makeBtn(
+        "always",
+        "\u2b50 \u59cb\u7ec8\u5141\u8bb8",
+        "\u5df2\u59cb\u7ec8\u5141\u8bb8",
+        `approve:${approvalId}:allow-always`,
+        1,
+      ),
+    );
+  }
+  if (allowedDecisions.includes("deny")) {
+    buttons.push(
+      makeBtn("deny", "\u274c \u62d2\u7edd", "\u5df2\u62d2\u7edd", `approve:${approvalId}:deny`, 0),
+    );
+  }
+
+  return {
+    content: {
+      rows: [
+        {
+          buttons,
+        },
+      ],
+    },
+  };
+}
+
+// ============ Target Resolver ============
+
+/**
+ * Extract the delivery target from a sessionKey or turnSourceTo string.
+ *
+ * Expected formats:
+ *   agent:main:qqbot:direct:OPENID  -> { type: "c2c", id: "OPENID" }
+ *   agent:main:qqbot:c2c:OPENID     -> { type: "c2c", id: "OPENID" }
+ *   agent:main:qqbot:group:GROUPID  -> { type: "group", id: "GROUPID" }
+ *
+ * Returns null if neither field matches the expected pattern.
+ */
+export function resolveApprovalTarget(
+  sessionKey: string | null | undefined,
+  turnSourceTo: string | null | undefined,
+): ApprovalTarget | null {
+  const sk = sessionKey ?? turnSourceTo;
+  if (!sk) {
+    return null;
+  }
+  const m = sk.match(/qqbot:(c2c|direct|group):([A-F0-9]+)/i);
+  if (!m) {
+    return null;
+  }
+  const type: ChatScope = m[1].toLowerCase() === "group" ? "group" : "c2c";
+  return { type, id: m[2] };
+}
+
+// ============ Interaction Parser ============
+
+/**
+ * Parse the button_data string from an INTERACTION_CREATE event.
+ *
+ * Expected format: `approve:<approvalId>:<decision>`
+ * where approvalId may be prefixed with "exec:" or "plugin:".
+ *
+ * Returns null if the data does not match the approval button format.
+ */
+export function parseApprovalButtonData(buttonData: string): ParsedApprovalAction | null {
+  const m = buttonData.match(
+    /^approve:((?:(?:exec|plugin):)?[0-9a-f-]+):(allow-once|allow-always|deny)$/i,
+  );
+  if (!m) {
+    return null;
+  }
+  return {
+    approvalId: m[1],
+    decision: m[2] as ApprovalDecision,
+  };
+}

package/src/engine/commands/builtin/log-helpers.ts

@@ -0,0 +1,341 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadJsonFile } from "autobot/plugin-sdk/json-store";
+import { getHomeDir, getQQBotDataDir, isWindows } from "../../utils/platform.js";
+import type { SlashCommandResult } from "../slash-commands.js";
+
+/** Read user-configured log file paths from local config files. */
+function getConfiguredLogFiles(): string[] {
+  const homeDir = getHomeDir();
+  const files: string[] = [];
+  for (const cli of ["autobot", "clawdbot", "moltbot"]) {
+    try {
+      const cfgPath = path.join(homeDir, `.${cli}`, `${cli}.json`);
+      const cfg = loadJsonFile<{ logging?: { file?: unknown } }>(cfgPath);
+      const logFile = cfg?.logging?.file;
+      if (logFile && typeof logFile === "string") {
+        files.push(path.resolve(logFile));
+      }
+      break;
+    } catch {
+      // ignore
+    }
+  }
+  return files;
+}
+
+/** Collect directories that may contain runtime logs across common install layouts. */
+function collectCandidateLogDirs(): string[] {
+  const homeDir = getHomeDir();
+  const dirs = new Set<string>();
+
+  const pushDir = (p?: string) => {
+    if (!p) {
+      return;
+    }
+    const normalized = path.resolve(p);
+    dirs.add(normalized);
+  };
+
+  const pushStateDir = (stateDir?: string) => {
+    if (!stateDir) {
+      return;
+    }
+    pushDir(stateDir);
+    pushDir(path.join(stateDir, "logs"));
+  };
+
+  for (const logFile of getConfiguredLogFiles()) {
+    pushDir(path.dirname(logFile));
+  }
+
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!value) {
+      continue;
+    }
+    if (/STATE_DIR$/i.test(key) && /(AUTOBOT|CLAWDBOT|MOLTBOT)/i.test(key)) {
+      pushStateDir(value);
+    }
+  }
+
+  for (const name of [".autobot", ".clawdbot", ".moltbot", "autobot", "clawdbot", "moltbot"]) {
+    pushDir(path.join(homeDir, name));
+    pushDir(path.join(homeDir, name, "logs"));
+  }
+
+  const searchRoots = new Set<string>([homeDir, process.cwd(), path.dirname(process.cwd())]);
+  if (process.env.APPDATA) {
+    searchRoots.add(process.env.APPDATA);
+  }
+  if (process.env.LOCALAPPDATA) {
+    searchRoots.add(process.env.LOCALAPPDATA);
+  }
+
+  for (const root of searchRoots) {
+    try {
+      const entries = fs.readdirSync(root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+        if (!/(autobot|clawdbot|moltbot)/i.test(entry.name)) {
+          continue;
+        }
+        const base = path.join(root, entry.name);
+        pushDir(base);
+        pushDir(path.join(base, "logs"));
+      }
+    } catch {
+      // Ignore missing or inaccessible directories.
+    }
+  }
+
+  if (!isWindows()) {
+    for (const name of ["autobot", "clawdbot", "moltbot"]) {
+      pushDir(path.join("/var/log", name));
+    }
+  }
+
+  const tmpRoots = new Set<string>();
+  if (isWindows()) {
+    tmpRoots.add("C:\\tmp");
+    if (process.env.TEMP) {
+      tmpRoots.add(process.env.TEMP);
+    }
+    if (process.env.TMP) {
+      tmpRoots.add(process.env.TMP);
+    }
+    if (process.env.LOCALAPPDATA) {
+      tmpRoots.add(path.join(process.env.LOCALAPPDATA, "Temp"));
+    }
+  } else {
+    tmpRoots.add("/tmp");
+  }
+  for (const tmpRoot of tmpRoots) {
+    for (const name of ["autobot", "clawdbot", "moltbot"]) {
+      pushDir(path.join(tmpRoot, name));
+    }
+  }
+
+  return Array.from(dirs);
+}
+
+type LogCandidate = {
+  filePath: string;
+  sourceDir: string;
+  mtimeMs: number;
+};
+
+function addCollisionSuffix(filePath: string, suffix: number): string {
+  const ext = path.extname(filePath);
+  const baseName = path.basename(filePath, ext);
+  return path.join(path.dirname(filePath), `${baseName}-${suffix}${ext}`);
+}
+
+function writeNewTextFileSync(filePath: string, contents: string): string {
+  for (let suffix = 1; suffix <= 100; suffix++) {
+    const candidate = suffix === 1 ? filePath : addCollisionSuffix(filePath, suffix);
+    try {
+      fs.writeFileSync(candidate, contents, { encoding: "utf8", flag: "wx" });
+      return candidate;
+    } catch (error) {
+      if (typeof error === "object" && error && "code" in error && error.code === "EEXIST") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(`Could not find an unused log export filename near ${filePath}`);
+}
+
+function collectRecentLogFiles(logDirs: string[]): LogCandidate[] {
+  const candidates: LogCandidate[] = [];
+  const dedupe = new Set<string>();
+
+  const pushFile = (filePath: string, sourceDir: string) => {
+    const normalized = path.resolve(filePath);
+    if (dedupe.has(normalized)) {
+      return;
+    }
+    try {
+      const stat = fs.statSync(normalized);
+      if (!stat.isFile()) {
+        return;
+      }
+      dedupe.add(normalized);
+      candidates.push({ filePath: normalized, sourceDir, mtimeMs: stat.mtimeMs });
+    } catch {
+      // Ignore missing or inaccessible files.
+    }
+  };
+
+  for (const logFile of getConfiguredLogFiles()) {
+    pushFile(logFile, path.dirname(logFile));
+  }
+
+  for (const dir of logDirs) {
+    pushFile(path.join(dir, "gateway.log"), dir);
+    pushFile(path.join(dir, "gateway.err.log"), dir);
+    pushFile(path.join(dir, "autobot.log"), dir);
+    pushFile(path.join(dir, "clawdbot.log"), dir);
+    pushFile(path.join(dir, "moltbot.log"), dir);
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile()) {
+          continue;
+        }
+        if (!/\.(log|txt)$/i.test(entry.name)) {
+          continue;
+        }
+        if (!/(gateway|autobot|clawdbot|moltbot)/i.test(entry.name)) {
+          continue;
+        }
+        pushFile(path.join(dir, entry.name), dir);
+      }
+    } catch {
+      // Ignore missing or inaccessible directories.
+    }
+  }
+
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return candidates;
+}
+
+/**
+ * Read the last N lines of a file without loading the entire file into memory.
+ */
+function tailFileLines(
+  filePath: string,
+  maxLines: number,
+): { tail: string[]; totalFileLines: number } {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const stat = fs.fstatSync(fd);
+    const fileSize = stat.size;
+    if (fileSize === 0) {
+      return { tail: [], totalFileLines: 0 };
+    }
+
+    const CHUNK_SIZE = 64 * 1024;
+    const chunks: Buffer[] = [];
+    let bytesRead = 0;
+    let position = fileSize;
+    let newlineCount = 0;
+
+    while (position > 0 && newlineCount <= maxLines) {
+      const readSize = Math.min(CHUNK_SIZE, position);
+      position -= readSize;
+      const buf = Buffer.alloc(readSize);
+      fs.readSync(fd, buf, 0, readSize, position);
+      chunks.unshift(buf);
+      bytesRead += readSize;
+
+      for (let i = 0; i < readSize; i++) {
+        if (buf[i] === 0x0a) {
+          newlineCount++;
+        }
+      }
+    }
+
+    const tailContent = Buffer.concat(chunks).toString("utf8");
+    const allLines = tailContent.split("\n");
+
+    const tail = allLines.slice(-maxLines);
+
+    let totalFileLines: number;
+    if (bytesRead >= fileSize) {
+      totalFileLines = allLines.length;
+    } else {
+      const avgBytesPerLine = bytesRead / Math.max(allLines.length, 1);
+      totalFileLines = Math.round(fileSize / avgBytesPerLine);
+    }
+
+    return { tail, totalFileLines };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/**
+ * Build the /bot-logs result: collect recent log files, write them to a temp file.
+ */
+export function buildBotLogsResult(): SlashCommandResult {
+  const logDirs = collectCandidateLogDirs();
+  const recentFiles = collectRecentLogFiles(logDirs).slice(0, 4);
+
+  if (recentFiles.length === 0) {
+    const existingDirs = logDirs.filter((d) => {
+      try {
+        return fs.existsSync(d);
+      } catch {
+        return false;
+      }
+    });
+    const searched =
+      existingDirs.length > 0
+        ? existingDirs.map((d) => `  • ${d}`).join("\n")
+        : logDirs
+            .slice(0, 6)
+            .map((d) => `  • ${d}`)
+            .join("\n") + (logDirs.length > 6 ? `\n  …以及另外 ${logDirs.length - 6} 个路径` : "");
+    return [
+      `⚠️ 未找到日志文件`,
+      ``,
+      `已搜索以下${existingDirs.length > 0 ? "存在的" : ""}路径：`,
+      searched,
+      ``,
+      `💡 如果日志存放在自定义路径，请在配置中添加：`,
+      `  "logging": { "file": "/path/to/your/logfile.log" }`,
+    ].join("\n");
+  }
+
+  const lines: string[] = [];
+  let totalIncluded = 0;
+  let totalOriginal = 0;
+  let truncatedCount = 0;
+  const MAX_LINES_PER_FILE = 1000;
+  for (const logFile of recentFiles) {
+    try {
+      const { tail, totalFileLines } = tailFileLines(logFile.filePath, MAX_LINES_PER_FILE);
+      if (tail.length > 0) {
+        const fileName = path.basename(logFile.filePath);
+        lines.push(
+          `\n========== ${fileName} (last ${tail.length} of ${totalFileLines} lines) ==========`,
+        );
+        lines.push(`from: ${logFile.sourceDir}`);
+        lines.push(...tail);
+        totalIncluded += tail.length;
+        totalOriginal += totalFileLines;
+        if (totalFileLines > MAX_LINES_PER_FILE) {
+          truncatedCount++;
+        }
+      }
+    } catch {
+      lines.push(`[Failed to read ${path.basename(logFile.filePath)}]`);
+    }
+  }
+
+  if (lines.length === 0) {
+    return `⚠️ 找到了日志文件，但无法读取。请检查文件权限。`;
+  }
+
+  const tmpDir = getQQBotDataDir("downloads");
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const tmpFile = writeNewTextFileSync(
+    path.join(tmpDir, `bot-logs-${timestamp}.txt`),
+    lines.join("\n"),
+  );
+
+  const fileCount = recentFiles.length;
+  const topSources = Array.from(new Set(recentFiles.map((item) => item.sourceDir))).slice(0, 3);
+  let summaryText = `共 ${fileCount} 个日志文件，包含 ${totalIncluded} 行内容`;
+  if (truncatedCount > 0) {
+    summaryText += `（其中 ${truncatedCount} 个文件已截断为最后 ${MAX_LINES_PER_FILE} 行，总计原始 ${totalOriginal} 行）`;
+  }
+  return {
+    text: `📋 ${summaryText}\n📂 来源：${topSources.join(" | ")}`,
+    filePath: tmpFile,
+  };
+}

package/src/engine/commands/builtin/register-all.ts

@@ -0,0 +1,17 @@
+import type { SlashCommandRegistry } from "../slash-commands.js";
+import { registerApproveCommands } from "./register-approve.js";
+import { registerBasicBotCommands } from "./register-basic.js";
+import { registerClearStorageCommands } from "./register-clear-storage.js";
+import { registerLogCommands } from "./register-logs.js";
+import { registerStreamingCommands } from "./register-streaming.js";
+
+/**
+ * Register all built-in slash commands on the shared registry instance.
+ */
+export function registerBuiltinSlashCommands(registry: SlashCommandRegistry): void {
+  registerBasicBotCommands(registry);
+  registerLogCommands(registry);
+  registerClearStorageCommands(registry);
+  registerStreamingCommands(registry);
+  registerApproveCommands(registry);
+}