@jingyi0605/codingns 0.8.5 → 0.9.5

package/dist/server/modules/file/file-controller.d.ts

@@ -4,7 +4,12 @@ import type { FilePreviewLinkService } from "./file-preview-link-service.js";
 import type { FilePreviewService } from "./file-preview-service.js";
 import type { FileSearchService } from "./file-search-service.js";
 import type { FileTreeService } from "./file-tree-service.js";
+import type { WorkspaceIndexApplyService } from "./workspace-index-apply-service.js";
 import type { RecentFileService } from "./recent-file-service.js";
+import type { RecentModifiedFileService } from "./recent-modified-file-service.js";
+import type { AffairsLibraryPreviewLinkService } from "../workspace/affairs-library-preview-link-service.js";
+import type { AffairsLibraryService } from "../workspace/affairs-library-service.js";
+import type { OnlyOfficeIntegrationService } from "../office/onlyoffice-integration-service.js";
 import type { WorkspaceFileBridgeListDirOptions, WorkspaceFileBridgeService, WorkspaceFileBridgeWriteTextOptions, WorkspaceFileBridgeDeleteFileOptions } from "./workspace-file-bridge-service.js";
 import type { WorkspaceFileBridgeWatchDirOptions } from "./workspace-file-bridge-watch-service.js";
 interface FileWorkspaceQuery {
@@ -14,6 +19,7 @@ interface FileWorkspaceQuery {
     page?: string;
     pageSize?: string;
     limit?: string;
+    displayMode?: string;
 }
 interface SaveFileBody {
     workspaceId?: string;
@@ -84,15 +90,23 @@ interface WorkspaceBridgePollWatchQuery {
     watchId?: string;
     cursor?: string;
 }
+interface WorkspaceBridgeApplyIndexConfigBody {
+    workspaceId?: string;
+}
 export declare class FileController {
     private readonly fileTreeService;
     private readonly fileContentService;
     private readonly fileSearchService;
     private readonly recentFileService;
+    private readonly recentModifiedFileService;
     private readonly filePreviewService;
     private readonly filePreviewLinkService;
+    private readonly affairsLibraryPreviewLinkService;
+    private readonly affairsLibraryService;
+    private readonly onlyOfficeIntegrationService;
     private readonly workspaceFileBridgeService;
-    constructor(fileTreeService: FileTreeService, fileContentService: FileContentService, fileSearchService: FileSearchService, recentFileService: RecentFileService, filePreviewService: FilePreviewService, filePreviewLinkService: FilePreviewLinkService, workspaceFileBridgeService: WorkspaceFileBridgeService);
+    private readonly workspaceIndexApplyService;
+    constructor(fileTreeService: FileTreeService, fileContentService: FileContentService, fileSearchService: FileSearchService, recentFileService: RecentFileService, recentModifiedFileService: RecentModifiedFileService, filePreviewService: FilePreviewService, filePreviewLinkService: FilePreviewLinkService, affairsLibraryPreviewLinkService: AffairsLibraryPreviewLinkService, affairsLibraryService: AffairsLibraryService, onlyOfficeIntegrationService: OnlyOfficeIntegrationService, workspaceFileBridgeService: WorkspaceFileBridgeService, workspaceIndexApplyService: WorkspaceIndexApplyService);
     readonly getTree: (request: FastifyRequest<{
         Querystring: FileWorkspaceQuery;
     }>, reply: FastifyReply) => Promise<void>;
@@ -117,6 +131,9 @@ export declare class FileController {
     readonly getRecent: (request: FastifyRequest<{
         Querystring: FileWorkspaceQuery;
     }>, reply: FastifyReply) => Promise<void>;
+    readonly getRecentModified: (request: FastifyRequest<{
+        Querystring: FileWorkspaceQuery;
+    }>, reply: FastifyReply) => Promise<void>;
     readonly preview: (request: FastifyRequest<{
         Querystring: FileWorkspaceQuery;
     }>, reply: FastifyReply) => Promise<void>;
@@ -220,12 +237,29 @@ export declare class FileController {
     readonly previewWorkspaceBridgePollWatch: (request: FastifyRequest<{
         Querystring: WorkspaceBridgePollWatchQuery;
     }>, reply: FastifyReply) => Promise<void>;
-    private resolvePreviewRequestWorkspaceId;
+    readonly workspaceBridgeApplyIndexConfig: (request: FastifyRequest<{
+        Body: WorkspaceBridgeApplyIndexConfigBody;
+    }>, reply: FastifyReply) => Promise<void>;
+    readonly previewWorkspaceBridgeApplyIndexConfig: (request: FastifyRequest<{
+        Params: PublicWorkspaceBridgeParams;
+        Querystring: PublicWorkspaceBridgeQuery;
+    }>, reply: FastifyReply) => Promise<void>;
+    private resolvePreviewBridgeContext;
+    private listAffairsLibraryBridgeDir;
+    private readAffairsLibraryBridgeText;
+    private writeAffairsLibraryBridgeText;
+    private statAffairsLibraryBridgePath;
+    private resolveAffairsLibraryBridgePath;
+    private resolveExistingAffairsLibraryBridgePath;
+    private resolveAffairsLibraryBridgePathWithExistingParent;
     private sendWorkspaceBridgeUnwatch;
     private sendWorkspaceBridgePollWatch;
     readonly publicPreview: (request: FastifyRequest<{
         Params: PublicFilePreviewParams;
     }>, reply: FastifyReply) => Promise<void>;
+    readonly publicAffairsPreview: (request: FastifyRequest<{
+        Params: PublicFilePreviewParams;
+    }>, reply: FastifyReply) => Promise<void>;
     readonly workspaceBridgeRuntime: (_request: FastifyRequest, reply: FastifyReply) => Promise<void>;
 }
 export {};

package/dist/server/modules/file/file-controller.js

@@ -1,23 +1,35 @@
 import { readFileSync } from "node:fs";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { AppError } from "../../shared/errors/app-error.js";
+import { AppError, isAppError } from "../../shared/errors/app-error.js";
+import { hashContent } from "../../shared/utils/hash.js";
 import { isResourcePreviewKind } from "./file-preview-types.js";
 export class FileController {
     fileTreeService;
     fileContentService;
     fileSearchService;
     recentFileService;
+    recentModifiedFileService;
     filePreviewService;
     filePreviewLinkService;
+    affairsLibraryPreviewLinkService;
+    affairsLibraryService;
+    onlyOfficeIntegrationService;
     workspaceFileBridgeService;
-    constructor(fileTreeService, fileContentService, fileSearchService, recentFileService, filePreviewService, filePreviewLinkService, workspaceFileBridgeService) {
+    workspaceIndexApplyService;
+    constructor(fileTreeService, fileContentService, fileSearchService, recentFileService, recentModifiedFileService, filePreviewService, filePreviewLinkService, affairsLibraryPreviewLinkService, affairsLibraryService, onlyOfficeIntegrationService, workspaceFileBridgeService, workspaceIndexApplyService) {
         this.fileTreeService = fileTreeService;
         this.fileContentService = fileContentService;
         this.fileSearchService = fileSearchService;
         this.recentFileService = recentFileService;
+        this.recentModifiedFileService = recentModifiedFileService;
         this.filePreviewService = filePreviewService;
         this.filePreviewLinkService = filePreviewLinkService;
+        this.affairsLibraryPreviewLinkService = affairsLibraryPreviewLinkService;
+        this.affairsLibraryService = affairsLibraryService;
+        this.onlyOfficeIntegrationService = onlyOfficeIntegrationService;
         this.workspaceFileBridgeService = workspaceFileBridgeService;
+        this.workspaceIndexApplyService = workspaceIndexApplyService;
     }
     getTree = async (request, reply) => {
         const workspaceId = requireWorkspaceId(request.query.workspaceId);
@@ -88,15 +100,37 @@ export class FileController {
             items: this.recentFileService.list(requireWorkspaceId(request.query.workspaceId), requireUserId(request), Number(request.query.limit ?? "10"))
         });
     };
+    getRecentModified = async (request, reply) => {
+        reply.send({
+            items: this.recentModifiedFileService.list(requireWorkspaceId(request.query.workspaceId), {
+                limit: Number(request.query.limit ?? "10"),
+                keyword: request.query.keyword?.trim() ?? null
+            })
+        });
+    };
     preview = async (request, reply) => {
         const workspaceId = requireWorkspaceId(request.query.workspaceId);
+        const userId = requireUserId(request);
+        const username = request.auth?.user.username ?? userId;
         const filePath = request.query.path ?? "";
-        const preview = this.filePreviewService.preview(workspaceId, filePath, requireUserId(request));
-        if (preview.supported && isResourcePreviewKind(preview.kind)) {
-            const previewLink = this.filePreviewLinkService.createLink(workspaceId, filePath, requireUserId(request));
+        const preview = this.filePreviewService.preview(workspaceId, filePath, userId);
+        if (preview.supported && preview.kind !== "office" && isResourcePreviewKind(preview.kind)) {
+            const previewLink = this.filePreviewLinkService.createLink(workspaceId, filePath, userId);
             preview.previewPath = previewLink.previewPath;
             preview.previewUrl = buildAbsolutePreviewUrl(request, previewLink.previewPath);
         }
+        if (preview.supported && preview.kind === "office") {
+            preview.onlyOffice = this.onlyOfficeIntegrationService.buildWorkspacePreview({
+                workspaceId,
+                userId,
+                username,
+                filePath,
+                version: preview.version,
+                editable: true,
+                displayMode: normalizeOnlyOfficeDisplayMode(request.query.displayMode)
+            });
+            preview.previewUrl = preview.onlyOffice.documentUrl;
+        }
         reply.send(preview);
     };
     createPreviewLink = async (request, reply) => {
@@ -147,38 +181,134 @@ export class FileController {
         this.sendWorkspaceBridgePollWatch(request.query, reply);
     };
     previewWorkspaceBridgeCapabilities = async (request, reply) => {
-        this.resolvePreviewRequestWorkspaceId(request);
+        this.resolvePreviewBridgeContext(request);
         reply.send(this.workspaceFileBridgeService.getCapabilities());
     };
     previewWorkspaceBridgeListDir = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.listDir(this.resolvePreviewRequestWorkspaceId(request), request.body.path, request.body.options));
+        const context = this.resolvePreviewBridgeContext(request);
+        if (context.kind === "affairs_library") {
+            reply.send(this.listAffairsLibraryBridgeDir(context, request.body.path, request.body.options));
+            return;
+        }
+        reply.send(this.workspaceFileBridgeService.listDir(context.workspaceId, request.body.path, request.body.options));
     };
     previewWorkspaceBridgeReadText = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.readText(this.resolvePreviewRequestWorkspaceId(request), request.body.path?.trim() ?? ""));
+        const context = this.resolvePreviewBridgeContext(request);
+        const filePath = request.body.path?.trim() ?? "";
+        if (context.kind === "affairs_library") {
+            reply.send(this.readAffairsLibraryBridgeText(context, filePath));
+            return;
+        }
+        reply.send(this.workspaceFileBridgeService.readText(context.workspaceId, filePath));
     };
     previewWorkspaceBridgeReadTexts = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.readTexts(this.resolvePreviewRequestWorkspaceId(request), Array.isArray(request.body.paths) ? request.body.paths : []));
+        const context = this.resolvePreviewBridgeContext(request);
+        const paths = Array.isArray(request.body.paths) ? request.body.paths : [];
+        if (context.kind === "affairs_library") {
+            reply.send({
+                items: paths.map((filePath) => {
+                    const safePath = typeof filePath === "string" ? filePath : "";
+                    try {
+                        return this.readAffairsLibraryBridgeText(context, safePath);
+                    }
+                    catch (error) {
+                        return {
+                            path: safePath,
+                            error: toPreviewBridgeErrorShape(error, safePath)
+                        };
+                    }
+                })
+            });
+            return;
+        }
+        reply.send(this.workspaceFileBridgeService.readTexts(context.workspaceId, paths));
     };
     previewWorkspaceBridgeWriteText = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.writeText(this.resolvePreviewRequestWorkspaceId(request), request.body.path?.trim() ?? "", typeof request.body.content === "string" ? request.body.content : "", request.body.options));
+        const context = this.resolvePreviewBridgeContext(request);
+        const filePath = request.body.path?.trim() ?? "";
+        if (context.kind === "affairs_library") {
+            reply.send(this.writeAffairsLibraryBridgeText(context, filePath, typeof request.body.content === "string" ? request.body.content : "", request.body.options));
+            return;
+        }
+        reply.send(this.workspaceFileBridgeService.writeText(context.workspaceId, filePath, typeof request.body.content === "string" ? request.body.content : "", request.body.options));
     };
     previewWorkspaceBridgeDeleteFile = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.deleteFile(this.resolvePreviewRequestWorkspaceId(request), request.body.path?.trim() ?? "", request.body.options));
+        const context = this.resolvePreviewBridgeContext(request);
+        const filePath = request.body.path?.trim() ?? "";
+        if (context.kind === "affairs_library") {
+            const resolvedPath = this.resolveAffairsLibraryBridgePath(context, filePath, {
+                mustExist: true,
+                kind: "file"
+            });
+            reply.send(this.affairsLibraryService.operateFile(context.workspaceId, context.userId, {
+                opType: "delete",
+                srcPath: resolvedPath
+            }));
+            return;
+        }
+        reply.send(this.workspaceFileBridgeService.deleteFile(context.workspaceId, filePath, request.body.options));
     };
     previewWorkspaceBridgeStat = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.stat(this.resolvePreviewRequestWorkspaceId(request), request.query.path));
+        const context = this.resolvePreviewBridgeContext(request);
+        if (context.kind === "affairs_library") {
+            reply.send(this.statAffairsLibraryBridgePath(context, request.query.path));
+            return;
+        }
+        reply.send(this.workspaceFileBridgeService.stat(context.workspaceId, request.query.path));
     };
     previewWorkspaceBridgeExists = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.exists(this.resolvePreviewRequestWorkspaceId(request), request.query.path));
+        const context = this.resolvePreviewBridgeContext(request);
+        if (context.kind === "affairs_library") {
+            reply.send({ exists: this.statAffairsLibraryBridgePath(context, request.query.path).exists });
+            return;
+        }
+        reply.send(this.workspaceFileBridgeService.exists(context.workspaceId, request.query.path));
     };
     previewWorkspaceBridgeOpenFile = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.prepareOpenWorkspaceFile(this.resolvePreviewRequestWorkspaceId(request), request.body.path?.trim() ?? ""));
+        const context = this.resolvePreviewBridgeContext(request);
+        if (context.kind === "affairs_library") {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "DESKTOP_ACTION_NOT_SUPPORTED",
+                detail: "事务文档库预览暂不支持通过 workspace bridge 打开本地文件"
+            });
+        }
+        reply.send(this.workspaceFileBridgeService.prepareOpenWorkspaceFile(context.workspaceId, request.body.path?.trim() ?? ""));
     };
     previewWorkspaceBridgeRevealInFileManager = async (request, reply) => {
-        reply.send(this.workspaceFileBridgeService.prepareRevealWorkspaceFile(this.resolvePreviewRequestWorkspaceId(request), request.body.path?.trim() ?? ""));
+        const context = this.resolvePreviewBridgeContext(request);
+        if (context.kind === "affairs_library") {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "DESKTOP_ACTION_NOT_SUPPORTED",
+                detail: "事务文档库预览暂不支持通过 workspace bridge 定位本地文件"
+            });
+        }
+        reply.send(this.workspaceFileBridgeService.prepareRevealWorkspaceFile(context.workspaceId, request.body.path?.trim() ?? ""));
     };
     previewWorkspaceBridgeWatchDir = async (request, reply) => {
-        reply.send(await this.workspaceFileBridgeService.watchDir(this.resolvePreviewRequestWorkspaceId(request), request.body.path, request.body.options));
+        const context = this.resolvePreviewBridgeContext(request);
+        if (context.kind === "affairs_library") {
+            const resolvedPath = this.resolveAffairsLibraryBridgePath(context, request.body.path?.trim() ?? "", {
+                mustExist: true,
+                kind: "directory",
+                allowRoot: true
+            });
+            const resolved = this.affairsLibraryService.resolvePreviewFile(context.workspaceId, context.userId, resolvedPath, {
+                mustExist: true,
+                kind: "directory",
+                allowRoot: true
+            });
+            reply.send(await this.workspaceFileBridgeService.watchResolvedDir({
+                scopeId: buildAffairsLibraryWatchScopeId(context),
+                displayWorkspaceId: context.workspaceId,
+                basePath: resolved.relativePath,
+                absolutePath: resolved.absolutePath,
+                options: request.body.options
+            }));
+            return;
+        }
+        reply.send(await this.workspaceFileBridgeService.watchDir(context.workspaceId, request.body.path, request.body.options));
     };
     previewWorkspaceBridgeUnwatch = async (request, reply) => {
         this.sendWorkspaceBridgeUnwatch(request.body, reply);
@@ -186,7 +316,13 @@ export class FileController {
     previewWorkspaceBridgePollWatch = async (request, reply) => {
         this.sendWorkspaceBridgePollWatch(request.query, reply);
     };
-    resolvePreviewRequestWorkspaceId(request) {
+    workspaceBridgeApplyIndexConfig = async (request, reply) => {
+        reply.send(await this.workspaceIndexApplyService.applyConfig(requireWorkspaceId(request.body.workspaceId)));
+    };
+    previewWorkspaceBridgeApplyIndexConfig = async (request, reply) => {
+        reply.send(await this.workspaceIndexApplyService.applyConfig(this.resolvePreviewBridgeContext(request).workspaceId));
+    };
+    resolvePreviewBridgeContext(request) {
         const safeToken = (request.query?.token ?? request.params?.token ?? "").trim();
         if (!safeToken) {
             throw new AppError({
@@ -195,7 +331,216 @@ export class FileController {
                 detail: "预览链接无效，请重新打开文件预览"
             });
         }
-        return this.filePreviewLinkService.resolveWorkspaceId(safeToken);
+        try {
+            const affairsPreview = this.affairsLibraryPreviewLinkService.resolveTokenContext(safeToken);
+            return {
+                kind: "affairs_library",
+                workspaceId: affairsPreview.workspaceId,
+                userId: affairsPreview.userId,
+                previewPath: affairsPreview.previewPath
+            };
+        }
+        catch {
+            return {
+                kind: "workspace",
+                workspaceId: this.filePreviewLinkService.resolveWorkspaceId(safeToken)
+            };
+        }
+    }
+    listAffairsLibraryBridgeDir(context, requestedPath, options = {}) {
+        const requestedLimit = typeof options.limit === "number" ? options.limit : undefined;
+        const resolvedPath = this.resolveAffairsLibraryBridgePath(context, requestedPath?.trim() ?? "", {
+            mustExist: true,
+            kind: "directory",
+            allowRoot: true
+        });
+        const items = this.affairsLibraryService.listFiles(context.workspaceId, context.userId, resolvedPath || null, requestedLimit);
+        return {
+            path: resolvedPath,
+            items: items
+                .filter((item) => (options.kind && options.kind !== "any" ? item.kind === options.kind : true))
+                .map((item) => ({
+                name: item.name,
+                path: item.path,
+                kind: item.kind,
+                size: item.size,
+                mtime: item.updatedAt ? Date.parse(item.updatedAt) : 0,
+                hidden: item.name.startsWith(".")
+            }))
+        };
+    }
+    readAffairsLibraryBridgeText(context, requestedPath) {
+        const resolvedPath = this.resolveAffairsLibraryBridgePath(context, requestedPath, {
+            mustExist: true,
+            kind: "file"
+        });
+        const preview = this.affairsLibraryService.previewDocument(context.workspaceId, context.userId, resolvedPath);
+        if (!preview.supported || typeof preview.content !== "string") {
+            throw new AppError({
+                statusCode: 400,
+                errorCode: "FILE_PREVIEW_NOT_SUPPORTED",
+                detail: preview.reason ?? "当前文件不能通过 workspace bridge 读取",
+                field: "path"
+            });
+        }
+        return {
+            path: preview.path,
+            content: preview.content,
+            mtime: preview.updatedAt ? Date.parse(preview.updatedAt) : 0,
+            size: preview.size
+        };
+    }
+    writeAffairsLibraryBridgeText(context, requestedPath, content, options) {
+        const normalizedPath = this.resolveAffairsLibraryBridgePath(context, requestedPath.trim(), {
+            mustExist: false,
+            kind: "file"
+        });
+        try {
+            const current = this.readAffairsLibraryBridgeText(context, normalizedPath);
+            if (options?.overwrite === false) {
+                throw new AppError({
+                    statusCode: 409,
+                    errorCode: "FILE_ALREADY_EXISTS",
+                    detail: "目标文件已存在",
+                    field: "path"
+                });
+            }
+            this.affairsLibraryService.operateFile(context.workspaceId, context.userId, {
+                opType: "write",
+                srcPath: normalizedPath,
+                content,
+                expectedVersion: hashContent(Buffer.from(current.content, "utf8"))
+            });
+        }
+        catch (error) {
+            if (!isFileNotFoundError(error) || options?.createIfMissing !== true) {
+                throw error;
+            }
+            this.affairsLibraryService.operateFile(context.workspaceId, context.userId, {
+                opType: "create_file",
+                dstPath: normalizedPath,
+                content
+            });
+        }
+        const next = this.readAffairsLibraryBridgeText(context, normalizedPath);
+        return {
+            path: next.path,
+            mtime: next.mtime,
+            size: next.size
+        };
+    }
+    statAffairsLibraryBridgePath(context, requestedPath) {
+        const normalizedPath = requestedPath?.trim() ?? "";
+        try {
+            const resolvedPath = this.resolveAffairsLibraryBridgePath(context, normalizedPath, {
+                mustExist: true,
+                kind: "any",
+                allowRoot: true
+            });
+            const resolved = this.affairsLibraryService.resolvePreviewFile(context.workspaceId, context.userId, resolvedPath, {
+                mustExist: true,
+                kind: "any",
+                allowRoot: true
+            });
+            return {
+                exists: true,
+                path: resolved.relativePath,
+                name: resolved.relativePath ? resolved.relativePath.split("/").pop() ?? resolved.relativePath : "",
+                kind: resolved.stats?.isDirectory() ? "directory" : "file",
+                size: resolved.stats?.isFile() ? resolved.stats.size : null,
+                mtime: resolved.stats ? Math.round(resolved.stats.mtimeMs) : null,
+                hidden: resolved.relativePath.split("/").some((segment) => segment.startsWith("."))
+            };
+        }
+        catch (error) {
+            if (!isFileNotFoundError(error)) {
+                throw error;
+            }
+            return {
+                exists: false,
+                path: normalizedPath,
+                name: normalizedPath.split("/").pop() ?? normalizedPath,
+                kind: null,
+                size: null,
+                mtime: null,
+                hidden: normalizedPath.split("/").some((segment) => segment.startsWith("."))
+            };
+        }
+    }
+    resolveAffairsLibraryBridgePath(context, requestedPath, options) {
+        const normalizedPath = normalizePreviewBridgeRelativePath(requestedPath, options.allowRoot ?? false);
+        const candidates = buildAffairsLibraryBridgePathCandidates(context.previewPath, normalizedPath);
+        if (!options.mustExist) {
+            const existingCandidate = this.resolveExistingAffairsLibraryBridgePath(context, candidates, {
+                kind: options.kind,
+                allowRoot: options.allowRoot
+            });
+            if (existingCandidate) {
+                return existingCandidate;
+            }
+            const candidateWithExistingParent = this.resolveAffairsLibraryBridgePathWithExistingParent(context, candidates);
+            if (candidateWithExistingParent) {
+                return candidateWithExistingParent;
+            }
+            return candidates[0] ?? normalizedPath;
+        }
+        for (const candidate of candidates) {
+            try {
+                const resolved = this.affairsLibraryService.resolvePreviewFile(context.workspaceId, context.userId, candidate, {
+                    mustExist: options.mustExist,
+                    kind: options.kind,
+                    allowRoot: options.allowRoot
+                });
+                return resolved.relativePath;
+            }
+            catch (error) {
+                if (!options.mustExist) {
+                    throw error;
+                }
+                if (!isFileNotFoundError(error)) {
+                    throw error;
+                }
+            }
+        }
+        return normalizedPath;
+    }
+    resolveExistingAffairsLibraryBridgePath(context, candidates, options) {
+        for (const candidate of candidates) {
+            try {
+                const resolved = this.affairsLibraryService.resolvePreviewFile(context.workspaceId, context.userId, candidate, {
+                    mustExist: true,
+                    kind: options.kind,
+                    allowRoot: options.allowRoot
+                });
+                return resolved.relativePath;
+            }
+            catch (error) {
+                if (!isFileNotFoundError(error)) {
+                    throw error;
+                }
+            }
+        }
+        return null;
+    }
+    resolveAffairsLibraryBridgePathWithExistingParent(context, candidates) {
+        for (const candidate of candidates) {
+            const parentPath = path.posix.dirname(candidate);
+            const safeParentPath = parentPath === "." ? "" : parentPath;
+            try {
+                this.affairsLibraryService.resolvePreviewFile(context.workspaceId, context.userId, safeParentPath, {
+                    mustExist: true,
+                    kind: "directory",
+                    allowRoot: true
+                });
+                return candidate;
+            }
+            catch (error) {
+                if (!isFileNotFoundError(error)) {
+                    throw error;
+                }
+            }
+        }
+        return null;
     }
     sendWorkspaceBridgeUnwatch(body, reply) {
         const watchId = body.watchId?.trim() ?? "";
@@ -239,6 +584,22 @@ export class FileController {
         }
         reply.send(readFileSync(previewFile.absolutePath));
     };
+    publicAffairsPreview = async (request, reply) => {
+        const { token, filePath } = parsePublicPreviewPath(request.params["*"] ?? "");
+        const previewFile = this.affairsLibraryPreviewLinkService.resolvePublicFile(token, filePath);
+        reply.header("Cache-Control", "no-store");
+        reply.header("X-Content-Type-Options", "nosniff");
+        reply.type(previewFile.contentType);
+        if (previewFile.contentType.startsWith("text/html")) {
+            reply.send(injectWorkspaceBridgeRuntime(readFileSync(previewFile.absolutePath, "utf8"), {
+                workspaceId: previewFile.workspaceId,
+                hostOrigin: resolveRequestOrigin(request),
+                parentOrigin: resolveWorkspaceBridgeParentOrigin(request)
+            }));
+            return;
+        }
+        reply.send(readFileSync(previewFile.absolutePath));
+    };
     workspaceBridgeRuntime = async (_request, reply) => {
         reply.header("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
         reply.header("Pragma", "no-cache");
@@ -249,6 +610,9 @@ export class FileController {
         reply.send(readFileSync(resolveWorkspaceBridgeRuntimePath(), "utf8"));
     };
 }
+function normalizeOnlyOfficeDisplayMode(value) {
+    return value === "reading" ? "reading" : "default";
+}
 function parsePublicPreviewPath(rawPath) {
     const [tokenSegment, ...fileSegments] = rawPath.split("/");
     const token = tokenSegment?.trim() ?? "";
@@ -348,7 +712,7 @@ function injectWorkspaceBridgeRuntime(html, bootstrap) {
         "</script>",
         `<script src="${runtimeScriptPath}" data-codingns-workspace-id="${workspaceIdAttr}" data-codingns-host-origin="${hostOriginAttr}" data-codingns-parent-origin="${parentOriginAttr}" data-codingns-runtime-version="${runtimeVersionAttr}"></script>`
     ].join("");
-    if (html.includes("/preview/runtime/codingns-workspace-bridge.js")) {
+    if (hasInjectedWorkspaceBridgeRuntime(html)) {
         return html;
     }
     if (/<head[^>]*>/i.test(html)) {
@@ -362,6 +726,84 @@ function injectWorkspaceBridgeRuntime(html, bootstrap) {
     }
     return `${runtimeSnippet}${html}`;
 }
+function hasInjectedWorkspaceBridgeRuntime(html) {
+    return /<script\b[^>]*\bsrc=(["'])\/preview\/runtime\/codingns-workspace-bridge\.js(?:\?[^"']*)?\1[^>]*>/i.test(html);
+}
+function isFileNotFoundError(error) {
+    return isAppError(error) && error.errorCode === "FILE_NOT_FOUND";
+}
+function toPreviewBridgeErrorShape(error, fallbackPath) {
+    if (isAppError(error)) {
+        return {
+            code: error.errorCode,
+            message: error.message,
+            path: typeof error.data === "object" && error.data && "path" in error.data
+                ? String(error.data.path)
+                : fallbackPath
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            code: "INTERNAL_ERROR",
+            message: error.message,
+            path: fallbackPath
+        };
+    }
+    return {
+        code: "INTERNAL_ERROR",
+        message: "未知错误",
+        path: fallbackPath
+    };
+}
+function buildAffairsLibraryBridgePathCandidates(previewPath, requestedPath) {
+    const normalizedPreviewPath = normalizePreviewBridgeRelativePath(previewPath, false);
+    const normalizedRequestedPath = normalizePreviewBridgeRelativePath(requestedPath, false);
+    const candidates = [normalizedRequestedPath];
+    const previewDir = path.posix.dirname(normalizedPreviewPath);
+    if (!previewDir || previewDir === ".") {
+        return uniqueNonEmptyPaths(candidates);
+    }
+    const previewSegments = previewDir.split("/").filter(Boolean);
+    for (let index = previewSegments.length; index > 0; index -= 1) {
+        const prefix = previewSegments.slice(0, index).join("/");
+        if (prefix) {
+            candidates.push(path.posix.join(prefix, normalizedRequestedPath));
+        }
+    }
+    return uniqueNonEmptyPaths(candidates);
+}
+function buildAffairsLibraryWatchScopeId(context) {
+    return [
+        "affairs-library",
+        context.workspaceId,
+        context.userId,
+        normalizePreviewBridgeRelativePath(context.previewPath, true)
+    ].join("::");
+}
+function normalizePreviewBridgeRelativePath(pathText, allowRoot = false) {
+    const normalized = String(pathText ?? "")
+        .replace(/\\/g, "/")
+        .replace(/^\/+/, "")
+        .replace(/\/+/g, "/")
+        .trim();
+    if (!normalized || normalized === ".") {
+        return allowRoot ? "" : normalized;
+    }
+    return path.posix.normalize(normalized).replace(/^\/+/, "");
+}
+function uniqueNonEmptyPaths(paths) {
+    const seen = new Set();
+    const result = [];
+    for (const item of paths) {
+        const normalized = normalizePreviewBridgeRelativePath(item, true);
+        if (seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}
 function resolveWorkspaceBridgeRuntimePath() {
     return fileURLToPath(new URL("./runtime/codingns-workspace-bridge.js", import.meta.url));
 }