chatccc 0.2.252 → 0.2.254

package/dist/src/agent-delegate-task-rpc.js

@@ -0,0 +1,129 @@
+import { resolve } from "node:path";
+import { resolveDefaultAgentTool } from "./config.js";
+import { readUtf8JsonBody } from "./agent-rpc-body.js";
+import { delegateAgentTask } from "./agent-delegate-task.js";
+import { applySharedPrefix } from "./shared-prefix.js";
+export const AGENT_DELEGATE_TASK_PATH = "/api/agent/delegate-task";
+const MAX_REQUEST_BYTES = 128 * 1024;
+const VALID_TOOLS = new Set(["claude", "cursor", "codex"]);
+function jsonReply(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(data));
+}
+function stringValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function normalizeOpenIds(payload) {
+    const explicitOpenId = stringValue(payload.open_id);
+    if (explicitOpenId)
+        return [explicitOpenId];
+    const rawOpenIds = Array.isArray(payload.open_ids) ? payload.open_ids : payload.openIds;
+    if (!Array.isArray(rawOpenIds))
+        return [];
+    return rawOpenIds
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function promptFromPayload(payload) {
+    return stringValue(payload.prompt) || stringValue(payload.text) || stringValue(payload.message);
+}
+function validateTool(rawTool) {
+    const tool = stringValue(rawTool).toLowerCase() || resolveDefaultAgentTool();
+    if (!VALID_TOOLS.has(tool))
+        throw new Error(`unsupported tool: ${tool}`);
+    return tool;
+}
+function validateCwd(rawCwd) {
+    const cwd = stringValue(rawCwd);
+    if (!cwd)
+        throw new Error("cwd must be a non-empty string");
+    return resolve(cwd);
+}
+export async function handleAgentDelegateTaskRequest(req, res, platform) {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== AGENT_DELEGATE_TASK_PATH)
+        return false;
+    if (req.method !== "POST") {
+        jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+        return true;
+    }
+    if (platform.kind !== "feishu") {
+        jsonReply(res, 409, { ok: false, error: "This endpoint currently only supports Feishu." });
+        return true;
+    }
+    let payload;
+    try {
+        payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+    }
+    catch (err) {
+        jsonReply(res, 400, { ok: false, error: err.message || "Invalid JSON" });
+        return true;
+    }
+    let tool;
+    let cwd;
+    let promptText;
+    let promptNamePrefix;
+    let openIds;
+    try {
+        tool = validateTool(payload.tool);
+        cwd = validateCwd(payload.cwd);
+        const rawPrompt = promptFromPayload(payload);
+        if (!rawPrompt)
+            throw new Error("prompt must be a non-empty string");
+        const sharedPrefix = applySharedPrefix(rawPrompt);
+        promptText = sharedPrefix.text;
+        promptNamePrefix = sharedPrefix.body || rawPrompt;
+        openIds = normalizeOpenIds(payload);
+        if (openIds.length === 0)
+            throw new Error("open_id or openIds must include at least one user");
+    }
+    catch (err) {
+        jsonReply(res, 400, { ok: false, error: err.message });
+        return true;
+    }
+    try {
+        const result = await delegateAgentTask({
+            platform,
+            tool,
+            cwd,
+            promptText,
+            openIds,
+            chatNamePrefix: stringValue(payload.chat_name) || promptNamePrefix.slice(0, 10),
+        });
+        jsonReply(res, 200, {
+            ok: true,
+            chat_id: result.chatId,
+            session_id: result.sessionId,
+            tool: result.tool,
+            cwd: result.cwd,
+        });
+    }
+    catch (err) {
+        jsonReply(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+}
+export function buildAgentDelegateTaskCapabilityPrompt(input) {
+    const lines = [
+        "[ChatCCC local capability: delegate task]",
+        "You can create a separate Feishu ChatCCC agent session and assign its first task by calling this local endpoint.",
+        "",
+        `POST ${input.url}`,
+        "Content-Type: application/json; charset=utf-8",
+        "",
+        'Body: {"tool":"codex|claude|cursor","cwd":"absolute working directory","open_id":"Feishu open_id to invite","prompt":"first task text"}',
+        "",
+        "Rules:",
+        "- Use this only when the user asks you to start a separate delegated conversation/session.",
+        "- Pass cwd explicitly as an absolute local path.",
+        "- Pass tool explicitly when the user specified a target agent.",
+        "- Use open_id for one user or open_ids/openIds for multiple users.",
+        "- The prompt is sent through the normal ChatCCC prompt path, so project prompt injection and IM skills still apply.",
+        "- Request body must be UTF-8 encoded JSON bytes. Do not call Feishu Open Platform directly.",
+        "[/ChatCCC local capability: delegate task]",
+    ];
+    if (input.cwd)
+        lines.splice(2, 0, `Current working directory: ${input.cwd}`);
+    return lines.join("\n");
+}

package/dist/src/agent-delegate-task.js

@@ -0,0 +1,48 @@
+import { resolve } from "node:path";
+import { sessionPrefixForTool, toolDisplayName, ts } from "./config.js";
+import { setDefaultCwd } from "./config.js";
+import { getEffectiveFastModeForTool, initClaudeSession, recordSessionRegistry, resumeAndPrompt, saveSessionTool, } from "./session.js";
+import { bindChatToSession } from "./session-chat-binding.js";
+import { sessionChatName } from "./session-name.js";
+export async function delegateAgentTask(input) {
+    const cwd = resolve(input.cwd);
+    const toolLabel = toolDisplayName(input.tool);
+    const init = await initClaudeSession(input.tool, cwd);
+    const sessionId = init.sessionId;
+    const chatNamePrefix = input.chatNamePrefix?.trim() || input.promptText.slice(0, 10) || "新会话";
+    const chatName = sessionChatName(chatNamePrefix, cwd);
+    let chatId;
+    try {
+        chatId = await input.platform.createGroup(chatName, input.openIds);
+        await input.platform.updateChatInfo(chatId, chatName, `${sessionPrefixForTool(input.tool)} ${sessionId}`);
+        await setDefaultCwd(cwd, chatId);
+        bindChatToSession(sessionId, chatId);
+        await recordSessionRegistry({
+            chatId,
+            sessionId,
+            tool: input.tool,
+            chatType: "group",
+            chatName,
+            turnCount: 0,
+            startTime: Date.now(),
+            running: false,
+        });
+        await saveSessionTool(sessionId, input.tool, chatName);
+    }
+    catch (err) {
+        console.error(`[${ts()}] [AGENT-DELEGATE-TASK] create group failed: ${err.message}`);
+        throw err;
+    }
+    await input.platform.sendCard(chatId, `${toolLabel} Session Ready`, `已创建 **${toolLabel}** 会话群。\n\n` +
+        `**Session ID:** ${sessionId}\n` +
+        `**工作目录:** \`${cwd}\`\n\n` +
+        `下面会自动把任务作为第一句话发送给 ${toolLabel}。`, "green").catch(() => { });
+    const fastMode = getEffectiveFastModeForTool(input.tool, sessionId);
+    const avatarUpdate = fastMode
+        ? input.platform.setChatAvatar(chatId, input.tool, "new", { fastMode: true })
+        : input.platform.setChatAvatar(chatId, input.tool, "new");
+    avatarUpdate.catch(() => { });
+    await resumeAndPrompt(sessionId, input.promptText, input.platform, chatId, input.msgTimestamp ?? Date.now(), input.tool, input.traceId);
+    console.log(`[${ts()}] [AGENT-DELEGATE-TASK] created ${toolLabel} session=${sessionId} chat=${chatId} cwd=${cwd}`);
+    return { chatId, sessionId, tool: input.tool, cwd };
+}

package/dist/src/agent-file-rpc.js

@@ -0,0 +1,152 @@
+import { extname, isAbsolute, resolve } from "node:path";
+import { stat } from "node:fs/promises";
+import { getTenantAccessToken, sendFileReply, sendTextReply } from "./feishu-platform.js";
+import { ts, resolveDefaultAgentTool } from "./config.js";
+import { readUtf8JsonBody } from "./agent-rpc-body.js";
+import { getAdapterForTool } from "./session.js";
+import { getChatsForSession } from "./session-chat-binding.js";
+import { splitFeishuTargetChats } from "./agent-platform-routing.js";
+export const AGENT_SEND_FILE_PATH = "/api/agent/send-file";
+const MAX_REQUEST_BYTES = 64 * 1024;
+const MAX_FILE_BYTES = 100 * 1024 * 1024;
+const ALLOWED_FILE_EXTS = new Set([
+    ".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv",
+    ".mp3", ".wav", ".ogg", ".aac", ".m4a",
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".csv", ".ppt", ".pptx",
+    ".txt", ".zip", ".tar", ".gz",
+]);
+function jsonReply(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(data));
+}
+async function resolveAndValidateFilePath(cwd, rawPath) {
+    if (typeof rawPath !== "string" || rawPath.trim() === "") {
+        throw new Error("path must be a non-empty string");
+    }
+    const sessionRoot = resolve(cwd);
+    const filePath = isAbsolute(rawPath)
+        ? resolve(rawPath)
+        : resolve(sessionRoot, rawPath);
+    const ext = extname(filePath).toLowerCase();
+    if (!ALLOWED_FILE_EXTS.has(ext)) {
+        throw new Error(`unsupported file extension: ${ext || "(none)"}`);
+    }
+    const st = await stat(filePath);
+    if (!st.isFile())
+        throw new Error("file path is not a file");
+    if (st.size <= 0)
+        throw new Error("file is empty");
+    if (st.size > MAX_FILE_BYTES)
+        throw new Error("file is larger than 100MB");
+    return filePath;
+}
+export async function handleAgentFileRequest(req, res) {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== AGENT_SEND_FILE_PATH)
+        return false;
+    if (req.method !== "POST") {
+        jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+        return true;
+    }
+    let payload;
+    try {
+        payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+    }
+    catch (err) {
+        jsonReply(res, 400, { ok: false, error: err.message || "Invalid JSON" });
+        return true;
+    }
+    const sessionId = typeof payload.session_id === "string" ? payload.session_id : "";
+    if (!sessionId) {
+        jsonReply(res, 400, { ok: false, error: "Missing session_id" });
+        return true;
+    }
+    let cwd;
+    try {
+        const { getSessionTool } = await import("./session.js");
+        const tool = await getSessionTool(sessionId);
+        const adapter = getAdapterForTool(tool ?? resolveDefaultAgentTool());
+        const info = await adapter.getSessionInfo(sessionId);
+        if (!info?.cwd) {
+            jsonReply(res, 400, { ok: false, error: "Cannot determine cwd for session" });
+            return true;
+        }
+        cwd = info.cwd;
+    }
+    catch (err) {
+        jsonReply(res, 500, { ok: false, error: `Failed to get session info: ${err.message}` });
+        return true;
+    }
+    let filePath;
+    try {
+        filePath = await resolveAndValidateFilePath(cwd, payload.path);
+    }
+    catch (err) {
+        jsonReply(res, 400, { ok: false, error: err.message });
+        return true;
+    }
+    const chatIds = getChatsForSession(sessionId);
+    if (chatIds.length === 0) {
+        jsonReply(res, 404, { ok: false, error: "No chats bound to this session" });
+        return true;
+    }
+    const { getPlatformForChat } = await import("./session.js");
+    const { targetChatIds, skippedUnsupported } = splitFeishuTargetChats(chatIds, (cid) => getPlatformForChat(cid)?.kind);
+    if (targetChatIds.length === 0) {
+        jsonReply(res, 409, {
+            ok: false,
+            error: "This endpoint only sends to Feishu chats. The bound chats are WeChat chats; use the WeChat file or video helper script instead.",
+            skippedUnsupported,
+        });
+        return true;
+    }
+    try {
+        const token = await getTenantAccessToken();
+        const caption = typeof payload.caption === "string" ? payload.caption.trim() : "";
+        let sentCount = 0;
+        for (const cid of targetChatIds) {
+            try {
+                await sendFileReply(token, cid, filePath);
+                if (caption)
+                    await sendTextReply(token, cid, caption);
+                sentCount++;
+            }
+            catch (err) {
+                console.error(`[${ts()}] [AGENT-FILE] send to ${cid} failed: ${err.message}`);
+            }
+        }
+        console.log(`[${ts()}] [AGENT-FILE] sent file to ${sentCount}/${targetChatIds.length} Feishu chats, session=${sessionId} path=${filePath} skippedUnsupported=${skippedUnsupported.length}`);
+        jsonReply(res, 200, { ok: true, sentTo: sentCount, total: targetChatIds.length, skippedUnsupported });
+    }
+    catch (err) {
+        console.error(`[${ts()}] [AGENT-FILE] send failed: ${err.message}`);
+        jsonReply(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// 兼容旧版 buildAgentFileCapabilityPrompt（供 im-skills 使用）
+// ---------------------------------------------------------------------------
+export function buildAgentFileCapabilityPrompt(input) {
+    const lines = [
+        "[ChatCCC local capability: send file]",
+        "You can send a file (video, audio, document, etc.) to all chats bound to this session by calling this local endpoint.",
+        "",
+        `POST ${input.url}`,
+        "Content-Type: application/json; charset=utf-8",
+        "",
+        `Body: {"session_id":"${input.sessionId ?? "YOUR_SESSION_ID"}","path":"absolute file path","caption":"optional caption"}`,
+        "",
+        "Rules:",
+        "- Save or choose a local file first, then call the endpoint.",
+        "- Use an absolute local file path. Do not call Feishu Open Platform directly.",
+        "- Request body must be UTF-8 encoded JSON bytes; caption supports Unicode text, including Chinese.",
+        "- Only call this endpoint when the user asked for a file/video or when a file is useful to the answer.",
+        "- Max file size: 100MB.",
+        "[/ChatCCC local capability: send file]",
+    ];
+    if (input.cwd) {
+        lines.splice(2, 0, `Current working directory: ${input.cwd}`);
+    }
+    return lines.join("\n");
+}

package/dist/src/agent-image-rpc.js

@@ -0,0 +1,148 @@
+import { extname, isAbsolute, resolve } from "node:path";
+import { stat } from "node:fs/promises";
+import { getTenantAccessToken, sendImageReply, sendTextReply } from "./feishu-platform.js";
+import { ts, resolveDefaultAgentTool } from "./config.js";
+import { readUtf8JsonBody } from "./agent-rpc-body.js";
+import { getAdapterForTool } from "./session.js";
+import { getChatsForSession } from "./session-chat-binding.js";
+import { splitFeishuTargetChats } from "./agent-platform-routing.js";
+export const AGENT_SEND_IMAGE_PATH = "/api/agent/send-image";
+const MAX_REQUEST_BYTES = 64 * 1024;
+const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+const ALLOWED_IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".bmp"]);
+function jsonReply(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(data));
+}
+async function resolveAndValidateImagePath(cwd, rawPath) {
+    if (typeof rawPath !== "string" || rawPath.trim() === "") {
+        throw new Error("path must be a non-empty string");
+    }
+    const sessionRoot = resolve(cwd);
+    const imagePath = isAbsolute(rawPath)
+        ? resolve(rawPath)
+        : resolve(sessionRoot, rawPath);
+    const ext = extname(imagePath).toLowerCase();
+    if (!ALLOWED_IMAGE_EXTS.has(ext)) {
+        throw new Error(`unsupported image extension: ${ext || "(none)"}`);
+    }
+    const st = await stat(imagePath);
+    if (!st.isFile())
+        throw new Error("image path is not a file");
+    if (st.size <= 0)
+        throw new Error("image file is empty");
+    if (st.size > MAX_IMAGE_BYTES)
+        throw new Error("image file is larger than 10MB");
+    return imagePath;
+}
+export async function handleAgentImageRequest(req, res) {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== AGENT_SEND_IMAGE_PATH)
+        return false;
+    if (req.method !== "POST") {
+        jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+        return true;
+    }
+    let payload;
+    try {
+        payload = await readUtf8JsonBody(req, MAX_REQUEST_BYTES);
+    }
+    catch (err) {
+        jsonReply(res, 400, { ok: false, error: err.message || "Invalid JSON" });
+        return true;
+    }
+    const sessionId = typeof payload.session_id === "string" ? payload.session_id : "";
+    if (!sessionId) {
+        jsonReply(res, 400, { ok: false, error: "Missing session_id" });
+        return true;
+    }
+    // 获取 cwd 以校验路径
+    let cwd;
+    try {
+        const { getSessionTool } = await import("./session.js");
+        const tool = await getSessionTool(sessionId);
+        const adapter = getAdapterForTool(tool ?? resolveDefaultAgentTool());
+        const info = await adapter.getSessionInfo(sessionId);
+        if (!info?.cwd) {
+            jsonReply(res, 400, { ok: false, error: "Cannot determine cwd for session" });
+            return true;
+        }
+        cwd = info.cwd;
+    }
+    catch (err) {
+        jsonReply(res, 500, { ok: false, error: `Failed to get session info: ${err.message}` });
+        return true;
+    }
+    let imagePath;
+    try {
+        imagePath = await resolveAndValidateImagePath(cwd, payload.path);
+    }
+    catch (err) {
+        jsonReply(res, 400, { ok: false, error: err.message });
+        return true;
+    }
+    // 发送到所有绑定该 session 的群
+    const chatIds = getChatsForSession(sessionId);
+    if (chatIds.length === 0) {
+        jsonReply(res, 404, { ok: false, error: "No chats bound to this session" });
+        return true;
+    }
+    const { getPlatformForChat } = await import("./session.js");
+    const { targetChatIds, skippedUnsupported } = splitFeishuTargetChats(chatIds, (cid) => getPlatformForChat(cid)?.kind);
+    if (targetChatIds.length === 0) {
+        jsonReply(res, 409, {
+            ok: false,
+            error: "This endpoint only sends to Feishu chats. The bound chats are WeChat chats; use the WeChat image helper script instead.",
+            skippedUnsupported,
+        });
+        return true;
+    }
+    try {
+        const token = await getTenantAccessToken();
+        const caption = typeof payload.caption === "string" ? payload.caption.trim() : "";
+        let sentCount = 0;
+        for (const cid of targetChatIds) {
+            try {
+                await sendImageReply(token, cid, imagePath);
+                if (caption)
+                    await sendTextReply(token, cid, caption);
+                sentCount++;
+            }
+            catch (err) {
+                console.error(`[${ts()}] [AGENT-IMAGE] send to ${cid} failed: ${err.message}`);
+            }
+        }
+        console.log(`[${ts()}] [AGENT-IMAGE] sent image to ${sentCount}/${targetChatIds.length} Feishu chats, session=${sessionId} path=${imagePath} skippedUnsupported=${skippedUnsupported.length}`);
+        jsonReply(res, 200, { ok: true, sentTo: sentCount, total: targetChatIds.length, skippedUnsupported });
+    }
+    catch (err) {
+        console.error(`[${ts()}] [AGENT-IMAGE] send failed: ${err.message}`);
+        jsonReply(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// 兼容旧版 buildAgentImageCapabilityPrompt（供 im-skills 使用）
+// ---------------------------------------------------------------------------
+export function buildAgentImageCapabilityPrompt(input) {
+    const lines = [
+        "[ChatCCC local capability: send image]",
+        "You can send an image to all chats bound to this session by calling this local endpoint.",
+        "",
+        `POST ${input.url}`,
+        "Content-Type: application/json; charset=utf-8",
+        "",
+        `Body: {"session_id":"${input.sessionId ?? "YOUR_SESSION_ID"}","path":"absolute image file path","caption":"optional caption"}`,
+        "",
+        "Rules:",
+        "- Save or choose a local image file first, then call the endpoint.",
+        "- Use an absolute local file path. Do not call Feishu Open Platform directly.",
+        "- Request body must be UTF-8 encoded JSON bytes; caption supports Unicode text, including Chinese.",
+        "- Only call this endpoint when the user asked for an image or when an image is useful to the answer.",
+        "[/ChatCCC local capability: send image]",
+    ];
+    if (input.cwd) {
+        lines.splice(2, 0, `Current working directory: ${input.cwd}`);
+    }
+    return lines.join("\n");
+}

package/dist/src/agent-platform-routing.js

@@ -0,0 +1,13 @@
+export function splitFeishuTargetChats(chatIds, getPlatformKind) {
+    const targetChatIds = [];
+    const skippedUnsupported = [];
+    for (const chatId of chatIds) {
+        const platformKind = getPlatformKind(chatId);
+        if (platformKind === "wechat") {
+            skippedUnsupported.push({ chatId, platformKind });
+            continue;
+        }
+        targetChatIds.push(chatId);
+    }
+    return { targetChatIds, skippedUnsupported };
+}

package/dist/src/agent-reload-config-rpc.js

@@ -0,0 +1,23 @@
+import { reloadRuntimeConfig } from "./runtime-reload.js";
+export const AGENT_RELOAD_CONFIG_PATH = "/api/agent/reload-config";
+function jsonReply(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(data));
+}
+export async function handleAgentReloadConfigRequest(req, res, reload = reloadRuntimeConfig) {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== AGENT_RELOAD_CONFIG_PATH)
+        return false;
+    if (req.method !== "POST") {
+        jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+        return true;
+    }
+    try {
+        const result = await reload("agent-reload-api");
+        jsonReply(res, 200, { ok: true, ...result });
+    }
+    catch (err) {
+        jsonReply(res, 500, { ok: false, error: err.message });
+    }
+    return true;
+}

package/dist/src/agent-rpc-body.js

@@ -0,0 +1,87 @@
+import { TextDecoder } from "node:util";
+// Windows 下 curl 传中文可能用 GBK 编码而非 UTF-8，按顺序尝试解码
+const FALLBACK_ENCODINGS = ["gbk", "gb2312", "latin1"];
+/**
+ * 检测 UTF-8 解码结果是否看起来像乱码（GBK 字节被误当 UTF-8 解析）。
+ * 典型特征：有 Latin-1 补充字符（U+0080-U+00FF）但没有 CJK 字符。
+ */
+function hasGarbledPattern(text) {
+    let latin1Count = 0;
+    let cjkCount = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0) ?? 0;
+        if (code >= 0x4E00 && code <= 0x9FFF)
+            cjkCount++;
+        if (code >= 0x0080 && code <= 0x00FF)
+            latin1Count++;
+    }
+    return latin1Count > 0 && cjkCount === 0;
+}
+function normalizeHeaderValue(value) {
+    if (Array.isArray(value))
+        return value.join("; ");
+    return value ?? "";
+}
+export function getRequestCharset(req) {
+    const contentType = normalizeHeaderValue(req.headers["content-type"]);
+    const match = contentType.match(/(?:^|;)\s*charset\s*=\s*("?)([^";\s]+)\1/i);
+    return (match?.[2] ?? "utf-8").toLowerCase();
+}
+async function readLimitedBodyBuffer(req, maxBytes) {
+    const chunks = [];
+    let size = 0;
+    return new Promise((resolve, reject) => {
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > maxBytes) {
+                reject(new Error("Request body too large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks, size)));
+        req.on("error", reject);
+    });
+}
+export async function readUtf8JsonBody(req, maxBytes) {
+    const charset = getRequestCharset(req);
+    if (charset !== "utf-8" && charset !== "utf8") {
+        throw new Error(`Unsupported charset: ${charset}. Use UTF-8 JSON.`);
+    }
+    const body = await readLimitedBodyBuffer(req, maxBytes);
+    // 首选 UTF-8；若 JSON 解析失败则尝试常见中文编码
+    // 注意：UTF-8 解码可能"成功"但实际是 GBK 字节被误当 UTF-8 解析，
+    // 此时 JSON 也能解析通过但中文变成乱码。通过 hasGarbledPattern 检测
+    // 这种"假成功"并回退到 GBK。
+    try {
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(body);
+        const parsed = JSON.parse(text);
+        if (hasGarbledPattern(text)) {
+            // UTF-8 解码出的文本看起来像乱码，尝试 GBK
+            try {
+                const gbkText = new TextDecoder("gbk", { fatal: true }).decode(body);
+                return JSON.parse(gbkText);
+            }
+            catch {
+                // GBK 也不行，用 UTF-8 结果
+            }
+        }
+        return parsed;
+    }
+    catch {
+        // UTF-8 解码失败，尝试其他编码
+    }
+    for (const enc of FALLBACK_ENCODINGS) {
+        try {
+            const text = new TextDecoder(enc, { fatal: true }).decode(body);
+            return JSON.parse(text);
+        }
+        catch {
+            // 解码或 JSON 解析失败，尝试下一个编码
+        }
+    }
+    const err = new Error("Request body must be valid UTF-8 JSON");
+    err.rawBody = body;
+    throw err;
+}