WeKnora/internal/handler/session/temporary_document.go

206 lines
7.4 KiB
Go
Raw Normal View History

package session
import (
"fmt"
"net/http"
"path/filepath"
"strings"
apperrors "github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/filetransport"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/types"
secutils "github.com/Tencent/WeKnora/internal/utils"
"github.com/gin-gonic/gin"
)
// UploadTemporaryDocument accepts one multipart file and immediately returns
// a session-scoped document ID. Parsing continues in the document worker.
func (h *Handler) UploadTemporaryDocument(c *gin.Context) {
ctx := c.Request.Context()
sessionID := c.Param("session_id")
// Uploading attaches content to the session, so use the strict owner scope:
// a tenant admin may read an API-key session but must not add attachments.
if _, err := h.sessionService.GetOwnedSession(ctx, sessionID); err != nil {
c.Error(apperrors.NewNotFoundError("Session not found"))
return
}
maxBytes := secutils.GetMaxFileSizeMB()*1024*1024 + 1024*1024
c.Request.Body = http.MaxBytesReader(c.Writer, c.Request.Body, maxBytes)
fileHeader, err := c.FormFile("file")
if err != nil {
c.Error(apperrors.NewBadRequestError(fmt.Sprintf("invalid attachment upload: %v", err)))
return
}
file, err := fileHeader.Open()
if err != nil {
c.Error(apperrors.NewBadRequestError("failed to open attachment"))
return
}
defer file.Close()
sourceTenantID, parseErr := types.ParseAgentSourceTenantID(c.PostForm(types.AgentSourceTenantIDParam))
if parseErr != nil {
c.Error(apperrors.NewBadRequestError(parseErr.Error()))
return
}
agent, resourceTenantID, _ := h.resolveAgent(ctx, c, c.PostForm("agent_id"), sourceTenantID)
if sourceTenantID != 0 && agent == nil {
c.Error(apperrors.NewNotFoundError("Shared agent not found"))
return
}
ext := strings.TrimPrefix(strings.ToLower(filepath.Ext(fileHeader.Filename)), ".")
options := types.TemporaryDocumentCreateOptions{ParserEngine: strings.TrimSpace(c.PostForm("parser_engine"))}
if agent != nil {
options.ResourceTenantID = resourceTenantID
fix(security): close the low-severity shared-space findings (#3416) * fix(security): close the low-severity shared-space findings Verified and fixed from the shared-space permission review: - Embed channels kept knowledge_ids, tag_ids, mentioned_items, skill_names and summary_model_id from anonymous visitors. Mentions are only scoped for shared agents, so a visitor could query any KB (and pick any model) of the channel workspace by ID. The payload now drops them; the widget never sends them. - PUT /knowledgebase/:kb_id/wiki/issues/:issue_id/status updated any issue by ID. The update is now scoped to the path's KB (404 otherwise). - A direct org invite let the inviter attach any user of the target workspace (or any user by ID) as its representative, whose username and email the roster then showed to all members. Direct adds attach no representative, and the roster returns emails only for the caller's own workspace. - COS and KS3 dropped the bucket (and COS the region) segment when turning a path into an object key, while the tenant check scans every segment: cos://42/<region>/prefix/7/... passed as tenant 42 and read tenant 7's object from a shared bucket. Both must now match the service's config. - Shared agent listings returned the full agent to receivers. Prompts and the creator's user ID are withheld; capabilities and scope stay visible. - Temporary document uploads let the caller pick the parser engine (and its credentials) of a shared agent's workspace; only the agent's rules choose one there now. - Suggested questions used request / message-snapshot knowledge_ids without a permission check. Each document is now resolved to its KB and checked like KB IDs, including a shared agent's scope. - IM channels accepted any knowledge_base_id (and any agent ID on create). Both must belong to the channel's workspace, the KB also to a restricted API key's allow-list. - KB-restricted API keys could list org-shared KBs outside their allow-list in the organization views; those listings are now filtered. - With enable_rbac=false, RequireKBAccess let cross-workspace denials through. That switch is for roles inside a workspace; the guard now always denies another workspace's KB, since handlers behind it load by ID without a tenant filter. - The org member limit was counted before and enforced apart from the insert; it is now checked in the insert's transaction with the organization row locked (SQLite serializes writers instead). - The UpdateOrganization route comment and API doc said owner-only; the service and UI allow org admins. Comment and doc corrected. Documented, not changed: issued /r/ and presigned links stay valid until they expire after a share is revoked. * fix(security): address review of the low-severity shared-space fixes - Embed payloads also drop question_origin. It selects a KB like an @mention for agents that retrieve only when mentioned, and the widget never sends it; the selection stays inside the agent's scope, but an anonymous visitor should not pick among its KBs. suggestion_attribution is kept (the widget sends it and it is validated). - The receiver view of a shared agent also withholds the follow-up suggestion instruction, a prompt like the others. Starter questions are shown to receivers anyway, and the sharer's name is displayed by design. - Follow-up suggestion generation moves into the agent's workspace with types.WithExecutionTenant instead of a bare tenant rewrite, so the caller is pinned before the document permission check runs. The auth middleware and the shared run already pinned it; this removes the dependency on that. - KS3 CopyFile copies only from the service's own bucket (as COS and S3 do); another bucket's path is a cross-backend copy. Tests cover the dropped question_origin, the follow-up instruction and the /shared-agents listing, a follow-up context with the tenant switched, a repeated wiki issue status update, and the KS3 copy source.
2026-09-18 14:58:46 +00:00
// A shared agent parses in its owner's workspace, with the parser
// engines (and credentials) configured there: only the agent's own
// rules may pick one, not the caller.
if resourceTenantID != 0 && resourceTenantID != c.GetUint64(types.TenantIDContextKey.String()) {
options.ParserEngine = ""
}
if len(agent.Config.SupportedFileTypes) > 0 && !containsFileType(agent.Config.SupportedFileTypes, ext) {
c.Error(apperrors.NewBadRequestError("file type is not supported by this agent"))
return
}
if isAudioExtension(ext) {
if !agent.Config.AudioUploadEnabled || agent.Config.ASRModelID == "" {
c.Error(apperrors.NewBadRequestError("audio upload is not enabled or no ASR model is configured"))
return
}
options.ASRModelID = agent.Config.ASRModelID
}
// Resolve the parser engine from the agent's chat rules when the caller
// did not pass an explicit engine. Tenant-level rules remain the final
// fallback and are applied in the parse worker.
if options.ParserEngine == "" || options.ParserEngine == "auto" {
if engine := agent.Config.ResolveChatParserEngine(ext); engine != "" {
options.ParserEngine = engine
}
}
// Image understanding (caption/OCR) uses the agent's VLM model. Images
// always benefit; scanned/image-only documents only OCR when the agent
// enabled AttachmentImageUnderstanding (see parse worker threshold gate).
if agent.Config.ImageUploadEnabled && agent.Config.VLMModelID != "" {
options.VLMModelID = agent.Config.VLMModelID
options.ImageUnderstanding = agent.Config.AttachmentImageUnderstanding
options.OCRMaxPages = agent.Config.AttachmentOCRMaxPages
}
}
document, err := h.temporaryDocuments.Create(
ctx, c.GetUint64(types.TenantIDContextKey.String()), sessionID,
fileHeader.Filename, fileHeader.Header.Get("Content-Type"), fileHeader.Size, file, options,
)
if err != nil {
c.Error(apperrors.NewBadRequestError(err.Error()))
return
}
c.JSON(http.StatusAccepted, gin.H{"success": true, "data": document})
}
func (h *Handler) ListTemporaryDocuments(c *gin.Context) {
ctx := c.Request.Context()
sessionID := sessionIDParam(c)
if _, err := h.sessionService.GetSession(ctx, sessionID); err != nil {
c.Error(apperrors.NewNotFoundError("Session not found"))
return
}
documents, err := h.temporaryDocuments.List(ctx, c.GetUint64(types.TenantIDContextKey.String()), sessionID)
if err != nil {
c.Error(apperrors.NewInternalServerError(err.Error()))
return
}
c.JSON(http.StatusOK, gin.H{"success": true, "data": documents})
}
func (h *Handler) GetTemporaryDocument(c *gin.Context) {
ctx := c.Request.Context()
sessionID := sessionIDParam(c)
if _, err := h.sessionService.GetSession(ctx, sessionID); err != nil {
c.Error(apperrors.NewNotFoundError("Session not found"))
return
}
document, err := h.temporaryDocuments.Get(ctx, c.GetUint64(types.TenantIDContextKey.String()), sessionID, c.Param("attachment_id"))
if err != nil {
c.Error(apperrors.NewInternalServerError(err.Error()))
return
}
if document == nil {
c.Error(apperrors.NewNotFoundError("Attachment not found"))
return
}
c.JSON(http.StatusOK, gin.H{"success": true, "data": document})
}
func (h *Handler) PreviewTemporaryDocument(c *gin.Context) {
ctx := c.Request.Context()
sessionID := sessionIDParam(c)
if _, err := h.sessionService.GetSession(ctx, sessionID); err != nil {
c.Error(apperrors.NewNotFoundError("Session not found"))
return
}
attachmentID := secutils.SanitizeForLog(c.Param("attachment_id"))
if attachmentID == "" {
c.Error(apperrors.NewBadRequestError("Attachment ID cannot be empty"))
return
}
file, filename, err := h.temporaryDocuments.OpenFile(
ctx, c.GetUint64(types.TenantIDContextKey.String()), sessionID, attachmentID,
)
if err != nil {
if strings.Contains(strings.ToLower(err.Error()), "not found") {
c.Error(apperrors.NewNotFoundError("Attachment not found"))
return
}
logger.ErrorWithFields(ctx, err, nil)
c.Error(apperrors.NewInternalServerError("Failed to retrieve attachment").WithDetails(err.Error()))
return
}
if err := filetransport.Serve(c.Writer, c.Request, file, filetransport.Options{
Filename: filename, CacheControl: "private, no-store",
}); err != nil {
logger.Errorf(ctx, "Failed to stream attachment preview: %v", err)
}
}
func (h *Handler) DeleteTemporaryDocument(c *gin.Context) {
ctx := c.Request.Context()
sessionID := sessionIDParam(c)
// Deleting mutates the session's attachments, so use the strict owner scope:
// a tenant admin may read an API-key session but must not remove attachments.
if _, err := h.sessionService.GetOwnedSession(ctx, sessionID); err != nil {
c.Error(apperrors.NewNotFoundError("Session not found"))
return
}
if err := h.temporaryDocuments.Delete(ctx, c.GetUint64(types.TenantIDContextKey.String()), sessionID, c.Param("attachment_id")); err != nil {
c.Error(apperrors.NewInternalServerError(err.Error()))
return
}
c.Status(http.StatusNoContent)
}
func sessionIDParam(c *gin.Context) string {
if value := c.Param("session_id"); value != "" {
return value
}
return c.Param("id")
}
func containsFileType(supported []string, ext string) bool {
for _, item := range supported {
if strings.TrimPrefix(strings.ToLower(strings.TrimSpace(item)), ".") == ext {
return true
}
}
return false
}
func isAudioExtension(ext string) bool {
switch ext {
case "mp3", "wav", "m4a", "flac", "ogg", "aac":
return true
default:
return false
}
}