@xgjktech/xg_cwork_im 1.17.39 → 1.17.41

package/dist/src/workspace-event.js

@@ -0,0 +1,674 @@
+/**
+ * 会话工作区目录浏览与文本文件读取。
+ *
+ * 该信令与 robotMention/groupMessage 完全分流，不创建 Agent 轮次、不写会话记录。
+ * LOCAL 工作区以 IM 计算的 localRoot 为授权根；NAS 工作区只访问 nasVolumes 明确授权的
+ * dockerDir，并通过当前机器 nasVolumeRootMappings 映射到宿主目录。
+ */
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { TextDecoder } from "node:util";
+import { resolveAgentWorkspaceDir } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
+import { normalizeNasDockerDir, resolveNasVolumeHostDirectoryForRead, } from "./nas-volumes.js";
+import { resolveNasSiteCode } from "./nas-site.js";
+import { resolveWorkspaceEventConcurrencyLimits, workspaceEventScheduler, } from "./workspace-event-scheduler.js";
+import { LOCAL_ROOT_KINDS, resolveLocalAbsolutePath, } from "./project-path-normalize.js";
+import { OPENCLAW_WORKSPACE_EVENT_CMD } from "./workspace-event-protocol.js";
+export { OPENCLAW_WORKSPACE_EVENT_CMD } from "./workspace-event-protocol.js";
+const DEFAULT_TREE_LIMIT = 200;
+const MAX_TREE_LIMIT = 500;
+const MAX_FILE_BYTES = 1024 * 1024;
+const MAX_CURSOR_CHARS = 4096;
+const MAX_REQUEST_PATH_CHARS = 4096;
+/** ws-notify 文本帧上限为 2 MiB；保留 64 KiB 给信封和实现差异。 */
+const MAX_WS_RESPONSE_BYTES = 2 * 1024 * 1024 - 64 * 1024;
+class WorkspaceEventError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function asRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function requiredString(record, key, maxLength = 1024) {
+    const value = record[key];
+    if (typeof value !== "string" || !value.trim() || value.length > maxLength) {
+        throw new WorkspaceEventError("INVALID_REQUEST", `${key} 缺失或格式错误`);
+    }
+    return value.trim();
+}
+function parseWorkspaceDescriptor(raw) {
+    const record = asRecord(raw);
+    if (!record)
+        throw new WorkspaceEventError("INVALID_REQUEST", "workspace 缺失或格式错误");
+    const sourceType = typeof record.sourceType === "string" ? record.sourceType.trim().toUpperCase() : "";
+    const rootPath = typeof record.rootPath === "string" ? record.rootPath.trim() : "";
+    if (rootPath.length > MAX_REQUEST_PATH_CHARS) {
+        throw new WorkspaceEventError("INVALID_REQUEST", "workspace.rootPath 过长");
+    }
+    if (sourceType === "LOCAL") {
+        const local = asRecord(record.localRoot);
+        if (!local)
+            throw new WorkspaceEventError("INVALID_REQUEST", "workspace.localRoot 缺失");
+        const kind = requiredString(local, "kind", 64);
+        const localPath = requiredString(local, "path", MAX_REQUEST_PATH_CHARS);
+        if (!LOCAL_ROOT_KINDS.includes(kind)) {
+            throw new WorkspaceEventError("INVALID_REQUEST", "workspace.localRoot.kind 不支持");
+        }
+        return {
+            sourceType: "LOCAL",
+            rootPath,
+            localRoot: { kind: kind, path: localPath },
+        };
+    }
+    if (sourceType === "NAS") {
+        if (!Array.isArray(record.nasVolumes) || record.nasVolumes.length === 0) {
+            throw new WorkspaceEventError("INVALID_REQUEST", "workspace.nasVolumes 缺失");
+        }
+        const nasVolumes = [];
+        for (const value of record.nasVolumes) {
+            if (nasVolumes.length >= 16)
+                break;
+            const item = asRecord(value);
+            if (!item)
+                continue;
+            try {
+                const rawMode = typeof item.mode === "string" ? item.mode.trim().toLowerCase() : "";
+                const mode = rawMode === "ro" || rawMode === "rw" ? rawMode : undefined;
+                nasVolumes.push({
+                    realDir: requiredString(item, "realDir", 1024),
+                    dockerDir: requiredString(item, "dockerDir", 1024),
+                    ...(mode ? { mode } : {}),
+                });
+            }
+            catch {
+                // 单个旧格式或损坏声明不应阻断同一请求中的其他有效 NAS 目录。
+            }
+        }
+        if (nasVolumes.length === 0) {
+            throw new WorkspaceEventError("INVALID_REQUEST", "workspace.nasVolumes 没有可用的授权目录");
+        }
+        return { sourceType: "NAS", rootPath, nasVolumes };
+    }
+    throw new WorkspaceEventError("INVALID_REQUEST", "workspace.sourceType 不支持");
+}
+function parseWorkspaceRequest(raw) {
+    const record = asRecord(raw);
+    if (!record)
+        throw new WorkspaceEventError("INVALID_REQUEST", "params 缺失或格式错误");
+    const event = requiredString(record, "event", 32);
+    if (event !== "TREE_REQUEST" && event !== "FILE_REQUEST") {
+        throw new WorkspaceEventError("INVALID_REQUEST", "event 不支持");
+    }
+    const fullPath = typeof record.path === "string" ? record.path.trim() : "";
+    if (fullPath.length > MAX_REQUEST_PATH_CHARS) {
+        throw new WorkspaceEventError("INVALID_REQUEST", "path 过长");
+    }
+    const rawLimit = record.limit;
+    const limit = rawLimit == null ? DEFAULT_TREE_LIMIT : Number(rawLimit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_TREE_LIMIT) {
+        throw new WorkspaceEventError("INVALID_REQUEST", "limit 必须在 1 到 500 之间");
+    }
+    const cursor = record.cursor == null ? undefined : String(record.cursor);
+    if (cursor != null && (!cursor || cursor.length > MAX_CURSOR_CHARS)) {
+        throw new WorkspaceEventError("INVALID_REQUEST", "cursor 格式错误");
+    }
+    return {
+        relayId: requiredString(record, "_wsRelayId", 256),
+        event,
+        groupId: requiredString(record, "groupId", 128),
+        workspace: parseWorkspaceDescriptor(record.workspace),
+        fullPath,
+        limit,
+        ...(cursor ? { cursor } : {}),
+    };
+}
+function normalizeLogicalPath(raw, allowEmpty) {
+    let value = raw.trim().replace(/\\/g, "/");
+    value = value.replace(/\/{2,}/g, "/");
+    while (value.startsWith("./"))
+        value = value.slice(2);
+    while (value.endsWith("/") && value.length > 1)
+        value = value.slice(0, -1);
+    if (!value) {
+        if (allowEmpty)
+            return "";
+        throw new WorkspaceEventError("INVALID_REQUEST", "path 不能为空");
+    }
+    const segments = value.split("/");
+    if (segments.some((segment) => segment === "." || segment === "..")) {
+        throw new WorkspaceEventError("PATH_OUTSIDE_WORKSPACE", "路径超出工作区范围");
+    }
+    return value;
+}
+function equalsPath(left, right) {
+    return process.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
+}
+function startsWithPath(target, root) {
+    if (!root)
+        return !target.startsWith("/") && !/^[A-Za-z]:\//.test(target);
+    const left = process.platform === "win32" ? target.toLowerCase() : target;
+    const right = process.platform === "win32" ? root.toLowerCase() : root;
+    return left.startsWith(`${right}/`);
+}
+function resolveRequestPath(rootRaw, fullRaw) {
+    const rootPath = normalizeLogicalPath(rootRaw, true);
+    const fullPath = normalizeLogicalPath(fullRaw, true);
+    if (!rootPath) {
+        if (fullPath.startsWith("/") || /^[A-Za-z]:\//.test(fullPath)) {
+            throw new WorkspaceEventError("PATH_OUTSIDE_WORKSPACE", "路径超出工作区范围");
+        }
+        return { displayPath: fullPath, logicalPath: fullPath };
+    }
+    if (equalsPath(fullPath, rootPath)) {
+        return { displayPath: "", logicalPath: fullPath };
+    }
+    if (rootPath === "/" && fullPath.startsWith("/")) {
+        return { displayPath: fullPath.slice(1), logicalPath: fullPath };
+    }
+    if (!startsWithPath(fullPath, rootPath)) {
+        throw new WorkspaceEventError("PATH_OUTSIDE_WORKSPACE", "路径超出工作区范围");
+    }
+    return {
+        displayPath: fullPath.slice(rootPath.length + 1),
+        logicalPath: fullPath,
+    };
+}
+function isInsideOrEqual(root, target) {
+    const relative = path.relative(root, target);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+async function existingRealRoot(root) {
+    try {
+        const resolved = await realpath(root);
+        const info = await stat(resolved);
+        if (!info.isDirectory())
+            throw new WorkspaceEventError("NOT_A_DIRECTORY", "工作区根目录不是目录");
+        return resolved;
+    }
+    catch (error) {
+        if (error instanceof WorkspaceEventError)
+            throw error;
+        if (isFsCode(error, "ENOENT"))
+            throw new WorkspaceEventError("NOT_FOUND", "工作区目录不存在");
+        throw new WorkspaceEventError("READ_FAILED", "无法访问工作区目录");
+    }
+}
+async function resolveExistingTarget(realRoot, relativePath) {
+    const lexicalTarget = relativePath
+        ? path.resolve(realRoot, ...relativePath.split("/"))
+        : realRoot;
+    if (!isInsideOrEqual(realRoot, lexicalTarget)) {
+        throw new WorkspaceEventError("PATH_OUTSIDE_WORKSPACE", "路径超出工作区范围");
+    }
+    try {
+        const target = await realpath(lexicalTarget);
+        if (!isInsideOrEqual(realRoot, target)) {
+            throw new WorkspaceEventError("PATH_OUTSIDE_WORKSPACE", "符号链接指向工作区外部");
+        }
+        return target;
+    }
+    catch (error) {
+        if (error instanceof WorkspaceEventError)
+            throw error;
+        if (isFsCode(error, "ENOENT"))
+            throw new WorkspaceEventError("NOT_FOUND", "目录或文件不存在");
+        throw new WorkspaceEventError("READ_FAILED", "无法解析目录或文件路径");
+    }
+}
+function isFsCode(error, code) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === code);
+}
+function joinDisplayPath(parent, name) {
+    return parent ? `${parent}/${name}` : name;
+}
+function entrySortKey(entry) {
+    return `${entry.type === "DIRECTORY" ? "0" : "1"}\0${entry.name}`;
+}
+function compareEntries(left, right) {
+    const a = entrySortKey(left);
+    const b = entrySortKey(right);
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function encodeCursor(displayPath, entry) {
+    return Buffer.from(JSON.stringify({ v: 1, path: displayPath, key: entrySortKey(entry) }), "utf8").toString("base64url");
+}
+function decodeCursor(cursor, displayPath) {
+    if (!cursor)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+        if (value.v !== 1 || value.path !== displayPath || typeof value.key !== "string")
+            throw new Error("bad cursor");
+        return value.key;
+    }
+    catch {
+        throw new WorkspaceEventError("INVALID_REQUEST", "cursor 无效或不属于当前目录");
+    }
+}
+function paginateEntries(entries, displayPath, limit, cursor) {
+    const after = decodeCursor(cursor, displayPath);
+    const sorted = [...entries].sort(compareEntries);
+    const eligible = after == null ? sorted : sorted.filter((entry) => entrySortKey(entry) > after);
+    const page = eligible.slice(0, limit);
+    return {
+        entries: page,
+        nextCursor: eligible.length > page.length && page.length > 0
+            ? encodeCursor(displayPath, page[page.length - 1])
+            : null,
+    };
+}
+async function listPhysicalDirectory(realRoot, target, displayPath) {
+    let targetInfo;
+    try {
+        targetInfo = await stat(target);
+    }
+    catch (error) {
+        if (isFsCode(error, "ENOENT"))
+            throw new WorkspaceEventError("NOT_FOUND", "目录不存在");
+        throw new WorkspaceEventError("READ_FAILED", "无法读取目录信息");
+    }
+    if (!targetInfo.isDirectory())
+        throw new WorkspaceEventError("NOT_A_DIRECTORY", "请求路径不是目录");
+    let dirents;
+    try {
+        dirents = await readdir(target, { withFileTypes: true });
+    }
+    catch {
+        throw new WorkspaceEventError("READ_FAILED", "无法读取目录");
+    }
+    const entries = [];
+    for (const dirent of dirents) {
+        try {
+            const child = await realpath(path.join(target, dirent.name));
+            if (!isInsideOrEqual(realRoot, child))
+                continue;
+            const info = await stat(child);
+            if (!info.isDirectory() && !info.isFile())
+                continue;
+            entries.push({
+                name: dirent.name,
+                path: joinDisplayPath(displayPath, dirent.name),
+                type: info.isDirectory() ? "DIRECTORY" : "FILE",
+                modifiedAt: Math.trunc(info.mtimeMs),
+                ...(info.isFile() ? { size: info.size } : {}),
+            });
+        }
+        catch {
+            // 文件可能正在被删除、权限刚变化或符号链接不可用；跳过该项，不阻断整个目录。
+        }
+    }
+    return entries;
+}
+async function resolveLocalTarget(ctx, request, resolvedPath) {
+    const workspace = request.workspace;
+    let workspaceHostRoot = ctx.workspaceHostRoot;
+    if (workspace.localRoot.kind === "workspace_relative" && !workspaceHostRoot?.trim()) {
+        try {
+            workspaceHostRoot = resolveAgentWorkspaceDir(ctx.cfg, ctx.config.agentId || "main");
+        }
+        catch {
+            throw new WorkspaceEventError("READ_FAILED", "无法解析 Agent 工作区目录");
+        }
+    }
+    let localRoot;
+    try {
+        localRoot = resolveLocalAbsolutePath(workspace.localRoot, workspaceHostRoot);
+    }
+    catch {
+        throw new WorkspaceEventError("INVALID_REQUEST", "本地工作区配置无效");
+    }
+    const realRoot = await existingRealRoot(localRoot);
+    const target = await resolveExistingTarget(realRoot, resolvedPath.displayPath);
+    return { realRoot, target };
+}
+function normalizeNasDeclarations(request) {
+    const workspace = request.workspace;
+    const declarations = workspace.nasVolumes
+        .map((volume) => {
+        try {
+            return {
+                dockerDir: normalizeNasDockerDir(volume.dockerDir),
+                realDir: volume.realDir,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((volume) => Boolean(volume));
+    if (declarations.length === 0) {
+        throw new WorkspaceEventError("INVALID_REQUEST", "NAS 授权目录声明无效");
+    }
+    return declarations;
+}
+async function resolveNasDeclaration(volume, ctx) {
+    try {
+        return {
+            ...volume,
+            hostDir: await resolveNasVolumeHostDirectoryForRead(volume.realDir, ctx.config),
+        };
+    }
+    catch {
+        throw new WorkspaceEventError("READ_FAILED", "NAS 授权目录当前不可访问");
+    }
+}
+function pathContains(root, target) {
+    return target === root || target.startsWith(`${root}/`);
+}
+function selectContainingNasVolume(volumes, logicalPath) {
+    return volumes
+        .filter((volume) => pathContains(volume.dockerDir, logicalPath))
+        .sort((left, right) => right.dockerDir.length - left.dockerDir.length)[0];
+}
+async function listNasDirectory(request, resolvedPath, ctx) {
+    const declarations = normalizeNasDeclarations(request);
+    const entries = new Map();
+    const containing = selectContainingNasVolume(declarations, resolvedPath.logicalPath);
+    let resolvedAny = false;
+    let resolvedContaining;
+    if (containing) {
+        try {
+            resolvedContaining = await resolveNasDeclaration(containing, ctx);
+        }
+        catch {
+            ctx.log.warn?.(`${ctx.logPrefix} [workspace] unavailable NAS mount skipped: dockerDir=${clipPath(containing.dockerDir)}`);
+        }
+    }
+    if (resolvedContaining) {
+        const suffix = resolvedPath.logicalPath === resolvedContaining.dockerDir
+            ? ""
+            : resolvedPath.logicalPath.slice(resolvedContaining.dockerDir.length + 1);
+        const realRoot = await existingRealRoot(resolvedContaining.hostDir);
+        const target = await resolveExistingTarget(realRoot, suffix);
+        for (const entry of await listPhysicalDirectory(realRoot, target, resolvedPath.displayPath)) {
+            entries.set(entry.name, entry);
+        }
+        resolvedAny = true;
+    }
+    const prefix = resolvedPath.logicalPath ? `${resolvedPath.logicalPath}/` : "";
+    const descendants = declarations.filter((volume) => resolvedPath.logicalPath ? volume.dockerDir.startsWith(prefix) : true);
+    const resolvedDescendants = await Promise.all(descendants.map(async (volume) => {
+        try {
+            return await resolveNasDeclaration(volume, ctx);
+        }
+        catch {
+            ctx.log.warn?.(`${ctx.logPrefix} [workspace] unavailable NAS mount skipped: dockerDir=${clipPath(volume.dockerDir)}`);
+            return undefined;
+        }
+    }));
+    for (const volume of resolvedDescendants) {
+        if (!volume)
+            continue;
+        resolvedAny = true;
+        const suffix = resolvedPath.logicalPath
+            ? volume.dockerDir.slice(prefix.length)
+            : volume.dockerDir;
+        if (!suffix)
+            continue;
+        const name = suffix.split("/")[0];
+        const info = await stat(volume.hostDir);
+        const existing = entries.get(name);
+        const modifiedAt = Math.max(existing?.modifiedAt ?? 0, Math.trunc(info.mtimeMs));
+        entries.set(name, {
+            name,
+            path: joinDisplayPath(resolvedPath.displayPath, name),
+            type: "DIRECTORY",
+            modifiedAt,
+        });
+    }
+    if (!containing && descendants.length === 0) {
+        throw new WorkspaceEventError("PATH_OUTSIDE_WORKSPACE", "路径不在任何 NAS 授权目录内");
+    }
+    if (!resolvedAny) {
+        throw new WorkspaceEventError("READ_FAILED", "NAS 授权目录当前均不可访问");
+    }
+    return [...entries.values()];
+}
+async function resolveNasFileTarget(request, resolvedPath, ctx) {
+    const declarations = normalizeNasDeclarations(request);
+    const containing = selectContainingNasVolume(declarations, resolvedPath.logicalPath);
+    if (!containing) {
+        throw new WorkspaceEventError("PATH_OUTSIDE_WORKSPACE", "文件不在任何 NAS 授权目录内");
+    }
+    const resolved = await resolveNasDeclaration(containing, ctx);
+    const suffix = resolvedPath.logicalPath === resolved.dockerDir
+        ? ""
+        : resolvedPath.logicalPath.slice(resolved.dockerDir.length + 1);
+    const realRoot = await existingRealRoot(resolved.hostDir);
+    const target = await resolveExistingTarget(realRoot, suffix);
+    return { realRoot, target };
+}
+function contentTypeFor(fileName) {
+    const extension = path.extname(fileName).toLowerCase();
+    if (extension === ".md")
+        return "text/markdown; charset=utf-8";
+    if (extension === ".html")
+        return "text/html; charset=utf-8";
+    if (extension === ".json")
+        return "application/json; charset=utf-8";
+    throw new WorkspaceEventError("UNSUPPORTED_FILE_TYPE", "只支持 JSON、MD、HTML 文件");
+}
+async function readTextFile(target, requestedFileName) {
+    const fileName = requestedFileName;
+    const contentType = contentTypeFor(fileName);
+    let info;
+    try {
+        info = await stat(target);
+    }
+    catch (error) {
+        if (isFsCode(error, "ENOENT"))
+            throw new WorkspaceEventError("NOT_FOUND", "文件不存在");
+        throw new WorkspaceEventError("READ_FAILED", "无法读取文件信息");
+    }
+    if (!info.isFile())
+        throw new WorkspaceEventError("NOT_A_FILE", "请求路径不是文件");
+    if (info.size > MAX_FILE_BYTES) {
+        throw new WorkspaceEventError("FILE_TOO_LARGE", "文件超过1MiB，无法预览或下载");
+    }
+    let buffer;
+    try {
+        buffer = await readFile(target);
+    }
+    catch {
+        throw new WorkspaceEventError("READ_FAILED", "无法读取文件");
+    }
+    if (buffer.length > MAX_FILE_BYTES) {
+        throw new WorkspaceEventError("FILE_TOO_LARGE", "文件超过1MiB，无法预览或下载");
+    }
+    const decoded = decodeTextBuffer(buffer);
+    const latest = await stat(target);
+    return {
+        fileName,
+        size: buffer.length,
+        modifiedAt: Math.trunc(latest.mtimeMs),
+        contentType,
+        content: decoded.content,
+        sourceEncoding: decoded.encoding,
+    };
+}
+/**
+ * 无第三方依赖的低成本文本编码兼容：UTF-8 优先；UTF-16 仅认 BOM；最后尝试
+ * GB18030（覆盖常见 GBK/GB2312）。回传 JSON 仍统一由 WebSocket 编码为 UTF-8。
+ */
+function decodeTextBuffer(buffer) {
+    try {
+        return {
+            content: new TextDecoder("utf-8", { fatal: true }).decode(buffer),
+            encoding: "utf-8",
+        };
+    }
+    catch {
+        // 继续尝试带 BOM 的 UTF-16 和中文环境常见编码。
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
+        try {
+            return {
+                content: new TextDecoder("utf-16le", { fatal: true }).decode(buffer),
+                encoding: "utf-16le",
+            };
+        }
+        catch {
+            // 继续尝试 GB18030。
+        }
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff) {
+        try {
+            return {
+                content: new TextDecoder("utf-16be", { fatal: true }).decode(buffer),
+                encoding: "utf-16be",
+            };
+        }
+        catch {
+            // 继续尝试 GB18030。
+        }
+    }
+    try {
+        return {
+            content: new TextDecoder("gb18030", { fatal: true }).decode(buffer),
+            encoding: "gb18030",
+        };
+    }
+    catch {
+        throw new WorkspaceEventError("READ_FAILED", "文件不是支持的文本编码");
+    }
+}
+function responseBytes(params) {
+    return Buffer.byteLength(JSON.stringify({ cmd: OPENCLAW_WORKSPACE_EVENT_CMD, params }), "utf8");
+}
+function baseResponse(request, resolvedPath) {
+    return {
+        _wsRelayId: request.relayId,
+        event: request.event === "TREE_REQUEST" ? "TREE_RESULT" : "FILE_RESULT",
+        groupId: request.groupId,
+        path: resolvedPath.displayPath,
+    };
+}
+function configuredBaseResponse(request, resolvedPath, config) {
+    const base = baseResponse(request, resolvedPath);
+    if (request.workspace.sourceType === "NAS")
+        base.nasSiteCode = resolveNasSiteCode(config);
+    return base;
+}
+function fallbackFields(raw, config) {
+    const record = asRecord(raw) ?? {};
+    const workspace = asRecord(record.workspace);
+    const isNas = typeof workspace?.sourceType === "string" && workspace.sourceType.trim().toUpperCase() === "NAS";
+    const event = record.event === "FILE_REQUEST" ? "FILE_RESULT" : "TREE_RESULT";
+    return {
+        _wsRelayId: boundedFallbackString(record._wsRelayId, 256),
+        event,
+        groupId: boundedFallbackString(record.groupId, 128),
+        ...(isNas ? { nasSiteCode: resolveNasSiteCode(config) } : {}),
+        path: "",
+    };
+}
+function boundedFallbackString(value, maxLength) {
+    return typeof value === "string" && value.length <= maxLength ? value.trim() : "";
+}
+function failureResponse(base, code, message) {
+    return { ...base, success: false, errorCode: code, message };
+}
+function fitTreeResponse(base, displayPath, page) {
+    const entries = [...page.entries];
+    let nextCursor = page.nextCursor;
+    while (true) {
+        const response = { ...base, success: true, entries, nextCursor };
+        if (responseBytes(response) <= MAX_WS_RESPONSE_BYTES)
+            return response;
+        const removed = entries.pop();
+        if (!removed || entries.length === 0) {
+            throw new WorkspaceEventError("READ_FAILED", "目录项过大，无法通过WebSocket返回");
+        }
+        nextCursor = encodeCursor(displayPath, entries[entries.length - 1]);
+    }
+}
+/** 实际执行一次工作区读取；并发控制由导出的 handleWorkspaceEvent 统一处理。 */
+async function executeWorkspaceEvent(ctx, rawParams) {
+    let request;
+    let resolvedPath;
+    try {
+        request = parseWorkspaceRequest(rawParams);
+        resolvedPath = resolveRequestPath(request.workspace.rootPath, request.fullPath);
+        const base = configuredBaseResponse(request, resolvedPath, ctx.config);
+        if (request.event === "TREE_REQUEST") {
+            const entries = request.workspace.sourceType === "NAS"
+                ? await listNasDirectory(request, resolvedPath, ctx)
+                : await (async () => {
+                    const target = await resolveLocalTarget(ctx, request, resolvedPath);
+                    return listPhysicalDirectory(target.realRoot, target.target, resolvedPath.displayPath);
+                })();
+            const page = paginateEntries(entries, resolvedPath.displayPath, request.limit, request.cursor);
+            const response = fitTreeResponse(base, resolvedPath.displayPath, page);
+            ctx.log.info(`${ctx.logPrefix} [workspace] event=TREE_REQUEST groupId=${request.groupId} ` +
+                `relayId=${clipPath(request.relayId)} path=${clipPath(resolvedPath.displayPath)} entries=${response.entries.length}`);
+            return response;
+        }
+        const target = request.workspace.sourceType === "NAS"
+            ? await resolveNasFileTarget(request, resolvedPath, ctx)
+            : await resolveLocalTarget(ctx, request, resolvedPath);
+        const readResult = await readTextFile(target.target, path.posix.basename(resolvedPath.displayPath));
+        const { sourceEncoding, ...file } = readResult;
+        const response = { ...base, success: true, ...file };
+        if (responseBytes(response) > MAX_WS_RESPONSE_BYTES) {
+            throw new WorkspaceEventError("FILE_TOO_LARGE", "文件编码后超过WebSocket返回上限");
+        }
+        ctx.log.info(`${ctx.logPrefix} [workspace] event=FILE_REQUEST groupId=${request.groupId} ` +
+            `relayId=${clipPath(request.relayId)} path=${clipPath(resolvedPath.displayPath)} ` +
+            `size=${file.size} encoding=${sourceEncoding}`);
+        return response;
+    }
+    catch (error) {
+        const workspaceError = error instanceof WorkspaceEventError
+            ? error
+            : new WorkspaceEventError("READ_FAILED", "工作区读取失败");
+        const base = request && resolvedPath
+            ? configuredBaseResponse(request, resolvedPath, ctx.config)
+            : fallbackFields(rawParams, ctx.config);
+        ctx.log.warn?.(`${ctx.logPrefix} [workspace] failed event=${String(base.event)} groupId=${String(base.groupId)} ` +
+            `relayId=${clipPath(String(base._wsRelayId ?? ""))} path=${clipPath(String(base.path ?? ""))} code=${workspaceError.code}`);
+        return failureResponse(base, workspaceError.code, workspaceError.message);
+    }
+}
+function busyWorkspaceResponse(ctx, rawParams, reason) {
+    let base = fallbackFields(rawParams, ctx.config);
+    try {
+        const request = parseWorkspaceRequest(rawParams);
+        const resolvedPath = resolveRequestPath(request.workspace.rootPath, request.fullPath);
+        base = configuredBaseResponse(request, resolvedPath, ctx.config);
+    }
+    catch {
+        // 忙碌回包优先保留 relay/event/groupId；请求本身的详细校验留给非过载路径。
+    }
+    const state = workspaceEventScheduler.snapshot();
+    ctx.log.warn?.(`${ctx.logPrefix} [workspace] busy reason=${reason} event=${String(base.event)} ` +
+        `groupId=${String(base.groupId)} relayId=${clipPath(String(base._wsRelayId ?? ""))} ` +
+        `active=${state.activeTotal} files=${state.activeFiles} queued=${state.queued}`);
+    return failureResponse(base, "BUSY", "工作区请求较多，请稍后重试");
+}
+/**
+ * 处理工作区请求。所有账户共享进程级调度器；无效 event 不进入队列，直接返回协议错误。
+ */
+export async function handleWorkspaceEvent(ctx, rawParams) {
+    const rawEvent = asRecord(rawParams)?.event;
+    if (rawEvent !== "TREE_REQUEST" && rawEvent !== "FILE_REQUEST") {
+        return executeWorkspaceEvent(ctx, rawParams);
+    }
+    const kind = rawEvent === "FILE_REQUEST" ? "FILE" : "TREE";
+    return workspaceEventScheduler.run({
+        agentKey: ctx.config.agentId?.trim() || "main",
+        kind,
+        limits: resolveWorkspaceEventConcurrencyLimits(ctx.config),
+        task: () => executeWorkspaceEvent(ctx, rawParams),
+        onBusy: (reason) => busyWorkspaceResponse(ctx, rawParams, reason),
+    });
+}
+function clipPath(value) {
+    const normalized = value.replace(/[\r\n\t]/g, " ");
+    return normalized.length <= 160 ? normalized : `${normalized.slice(0, 157)}...`;
+}
+//# sourceMappingURL=workspace-event.js.map