Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
refactor(resource-access): unify scoped authorization and transfer recovery (#3097)
lyingbug3d81b977f12f
diff --git a/internal/application/access/README.md b/internal/application/access/README.mdnew file mode 100644index 000000000..2e199178b--- /dev/null+++ b/internal/application/access/README.md@@ -0,0 +1,294 @@+# Resource access boundaries++`access` contains shared permission resolution without depending on Gin or the+application service implementations. HTTP adapters keep parameter parsing, status+codes, RBAC rollout behavior, and response projection at their existing boundaries.++| Entry point | Shared rule | Additional boundary |+| --- | --- | --- |+| Resource mutations with URL/body KB selectors | `CheckOwnershipOrRole`: creator or sufficient tenant role | API-key capabilities, KB scope and tenant visibility remain separate checks |+| KB/document detail and content routes | `ResolveKB`: own tenant, organization share, then read-only shared agent | Tenant role/ownership guards and API-key capabilities |+| Shared documents, chunks, search targets and suggestions | `KBSharePermissions`: organization grants only | Existing user requirements and caller-specific filtering/error behavior |+| FAQ and tag service reads | `resolveKBReadTenant`: execution tenant or organization share | Direct cross-tenant calls require a user; no implicit agent fallback |+| KB list, document search and batch restoration with `agent_id` | Shared-agent lookup, then `SharedAgentKBScope` | API-key intersection; dynamic list/search selections also apply capability filtering |+| Wiki fixer source tenant | Organization Editor permission | Built-in fixer only; exactly one KB |+| Message file shared-KB fallback | Organization Viewer permission | Persisted message reference, exact resource handle, KB/resource owner match |+| KB file proxy | `ResolveKBFile`: exact Viewer grant and current explicit KB binding | Owner tenant and exports namespace; original uploads retain their separate download permission |+| Message file proxy | `ResolveMessageFile`: session ownership and exact persisted output reference | Current shared-agent or organization-KB permission for source-owned resources |+| Message artifact download | `ResolveMessageArtifact`: session ownership and persisted artifact index | Session-owned output remains accessible; source-owned output rechecks current sharing |+| FAQ and tag mutations | `RequireKBWrite`: exact Editor operation grant | API-key ingest capability and KB scope; tenant-role/creator checks remain at the admission boundary |++## Ownership and write roles++URL middleware and body-based handlers use the same lazy ownership decision.+The middleware adapter resolves identity, RBAC rollout configuration and the+configuration-gated superuser flag. API-key principals, sufficient roles,+cross-tenant superusers and disabled enforcement skip the creator lookup.+API keys still require their route capabilities and allowed KB scope.++When a lookup is needed, it must check tenant visibility before returning the+creator. An empty creator never matches an empty user. Middleware passes missing+resources to the handler, reports lookup failures as 503 and audits only actual+policy denials. Body-based handlers retain their existing 404/403/500 mapping.+KB, initialization, Wiki and body-based KB lookups share the same tenant check.++## Caller and resource tenant++`types.Caller` holds the authenticated tenant, user and tenant role. Auth records+it once; `KBRequest.Caller` and `KBAccess.Caller` use that same identity. The+legacy `TenantIDContextKey` continues to scope repository/model execution, so+existing storage APIs do not need a coordinated signature migration.++Use `types.WithExecutionTenant` to switch execution tenants. It captures the+caller first, even when identity is missing, and grants no access by itself.+Use `KBAccess.Context` after authorization to carry both the exact KB grant and+its execution tenant, or `WithGrant` to carry the grant without switching yet.+Grants bind the KB ID, owner tenant, caller and resolved permission; changing+execution tenant cannot turn a Viewer grant into Editor or expose another KB.+HTTP adapters retain Gin's caller keys for existing handlers.++Service reads use `KBPermissions` to check caller ownership, exact upstream+grants, then organization shares for the original caller. This check also applies+to documents/chunks returned by the initial tenant-scoped batch query, not just+rows found during cross-tenant expansion. Search preflight, result enrichment,+FAQ/tag reads, search targets and suggestion scopes follow the same boundary.+General document search enumerates the caller's own/shared KBs; its execution+tenant is not a new identity.++After authorizing a shared agent, `WithSharedAgent` carries its configured,+source-tenant-bound read scope into the pipeline. An arbitrary execution switch+cannot substitute for that grant. `logger.CloneContext` preserves the caller and+resource grants for detached work within the operation. Context grants contain+immutable snapshots; deriving a context does not mutate a sibling search branch.+They are not persisted as authority for subsequent requests. API-key scope is+reapplied when consuming any grant.++## Organization shares++`KBSharePermissions` fixes the caller tenant and role for one operation and caches+the granular decision per KB. Reading many documents/chunks from one KB therefore+queries its membership once. Both denied decisions and errors are cached within+that operation. The next request creates a new resolver and observes revocations.+The resolver is not a process-wide cache and is not shared between goroutines.++The share service remains responsible for the role cap across share permission,+organization membership and caller tenant role. The resolver returns lookup errors+so strict search preflight can report an infrastructure failure while best-effort+result expansion can omit inaccessible rows. `ResolveKB` retains its independent+read-only agent fallback when organization resolution cannot grant access.++## Shared-agent KB scope++A scope is created only after looking up an accessible shared agent. `all` means+all KBs in that agent's tenant; `selected` means its explicit nonempty ID set.+`none`, unknown modes and empty selections authorize no KBs. A nil/empty ID slice+never implicitly grants an entire tenant. Specifying an agent does not permit+falling back to a different shared agent.++These rules do not replace message/session ownership, persisted file-reference+validation, resource binding, Agent tool search-target restrictions, or embed/IM+capability checks. Raw tenant files and message files have different authorization+contracts and must not be admitted by a generic KB grant alone.++## FAQ and tag writes++FAQ/tag service mutations consume an explicit Editor grant; setting an execution+tenant or supplying a KB ID is insufficient. `ResolveKB` keeps the effective+permission used for response projection, but caps its context grant to the+requested operation. Thus an owner read does not mint a reusable write grant.+HTTP routes retain their existing role/creator admission checks. API-key ingest+capability and KB scope are reapplied when consuming a write grant.++Trusted FAQ-import, data-source sync and automatic-tagging workers use+`WithKBTaskWrite` after loading and validating their target KB and child-resource+bindings. This represents continuation of an admitted job, not renewed user+authorization on every retry. It carries exactly one KB, preserves the caller+or its absence, survives in-operation context cloning, and grants no tenant-wide+role. Services use the KB owner's TenantInfo for model/index configuration.++Batch FAQ updates resolve all source/destination tags, entries and exclusions+before mutation. Batch deletion also resolves all parent documents first.+Tag-only batch updates use the same plan. Tag groups execute in ascending seq_id+order, then explicit entry updates override only their specified fields.+Import retains per-entry content-validation results, but out-of-scope resource+references are rejected before admission and checked again in the worker.+This preflight prevents partial writes caused by invalid resource selections;+it does not add a transaction across the database, task queue and search index.++## File authorization and transport++File resolvers return request-local `FileAccess` locators before any storage+reader is opened. The KB catalog accepts only explicit resource bindings to live+documents in the exact live KB. Registered physical aliases resolve to the same+resource ID; chunk/wiki text is never authorization evidence. Historical files+without explicit bindings fail closed and need a trusted migration. A same-tenant+path or handle prefix cannot replace a KB binding. Message evidence comes from+persisted content, references, images, artifacts and tool results; tool arguments+do not prove that the message returned a file. The organization-shared KB+fallback also checks the catalog for an independent live KB/file binding;+retrieval text and a currently shared KB ID alone are insufficient.++Source-owned shared-agent files also require the current live agent share.+KB sources need an explicit live KB binding allowed by the agent's current+`all`/`selected` selection and the caller's API-key KB scope; `none`, unknown+modes, removed KB selections and deleted sources fail closed. Independently+generated artifacts remain accessible when explicitly bound to the exact+authorized message as an artifact. Mentioning a file in message text or the+artifact list does not create that binding. Caller-owned artifacts retain their+session ownership contract.++The storage adapter uses the authorized owner and backend. The shared+`filetransport` package owns response headers, safe inline/download disposition,+streaming and reader closure. Seekable readers use standard HTTP Range and HEAD+handling; streaming-only backends return full content with `Accept-Ranges: none`+without buffering the object (RFC 9110 sections 14.2 and 14.3). Permission-controlled responses use `private, no-store` so a later+request rechecks current access. Tenant-wide and signed-token file routes keep+their own authorization and caching contracts.++## Document and chunk writes++Document metadata, manual content, reparse, document tags/folders, image edits, chunk mutations+and generated-question edits consume explicit Editor grants after loading the+persisted document/KB binding. Full chunk objects cannot reparent existing rows.+Batch inputs are deduplicated and fully validated, including missing IDs and+each KB's grant, before writes. Text edits also check the parent/image-child+relationships that they will modify. Body-based HTTP routes explicitly resolve+an Editor operation; a previously cached owner read is not a write admission.++Document deletion shares a preflight plan and executor for single and batch+calls. The plan validates every selection and KB, loads owner TenantInfo and+routing metadata, and captures image references before marking rows as deleting.+Index/graph failures leave the document and original file available for retry.+Wiki deletion collects all chunk types before deleting chunks, so parent, image+and summary citations are removed along with text citations.+Physical file cleanup remains best effort after database deletion; this does not+introduce a transaction across database, indexes and storage or durable blob GC.++New queued deletion payloads pin `knowledge_base_id` as well as tenant and exact+document IDs. Workers consume a private cleanup scope bound to those references,+not general KB write permission; already deleted IDs are successful no-ops.+A moved document rejects the batch before side effects. Pre-upgrade payloads that+omit the KB are accepted only when remaining rows resolve to one same-tenant KB;+they cannot reconstruct the KB that existed at enqueue time. Failure callbacks+skip rejected scopes and condition status updates on tenant, KB and deleting+state. Scope/identity errors are not retried; infrastructure failures are.++Single/batch delete, clear-content and batch-reparse admission reject already+moving documents with HTTP 409 before enqueue. Workers recheck current state;+a deletion conflict is terminal for that admitted task, so retries cannot+follow a document into a different KB. This does not serialize admission with+a concurrent move. Synchronous metadata/image/chunk/summary handlers preserve+application 403/409 errors, including wrapped errors.++Batch reparse and batch document tags resolve an Editor operation and apply the+same creator-or-Admin admission policy as single-document writes, respecting+RBAC rollout/API-key behavior. Batch reparse payloads likewise carry the admitted+KB ID. Workers validate the whole batch before any submission and use exactly one `WithKBTaskWrite` grant;+each reparse reload consumes that grant and rejects a document still moving.+Missing/mixed/moved selections fail without submitting earlier batch members.+Legacy reparse payloads can reconstruct only a present, single-KB binding.++Session-history, temporary-KB and clone cleanup use exact server-derived+references from their already admitted operations. These cleanup contexts cannot+be used for document/chunk updates or additional IDs. Parsing and enrichment+workers use repositories for their internal persistence and rollback; they must+keep their existing task ownership checks, abort checks and resource bindings.+Repository access is not an incoming-request authorization API.++## Clone and move operations++`WithKBTransfer` admits the exact source/target pair after HTTP role/creator+checks. Clone consumes source Viewer, target Editor and the API-key+`manage_kbs` capability; move consumes Editor on both sides and `ingest`.+Both operations remain within one tenant. Creating a clone reserves its target+ID before enqueue and carries its creator into the worker. The ID of a new+resource is not checked against an existing-resource API-key allow-list.++Workers reload both KBs, validate their owners and consume a private pair grant.+Document/FAQ plans validate all selected resources, chunks, parents and tags+before destructive work. Lifecycle reads include every chunk type and indexing+state. A document's `_knowledge_transfer` metadata records task identity and+progress; retries reuse the reserved target, replace incomplete clones, skip+completed vector moves and retry outstanding wiki cleanup/parser enqueue.+This field is internal operation state, not caller-supplied custom metadata.+For `reparse`, transfer `done` means target binding and parser admission are+complete, not that parsing has finished. `ParseStatus` remains the parser's+state. `reparse_pending` already admits the target parser; extending the+`moving` write guard to that phase would also block legitimate worker writes.+Locking all writes until parsing finishes is a separate processing/concurrency+contract, including ordinary reparses, and is not provided by this transfer marker.++Failed clone chunk/index writes attempt rollback after conditionally claiming+the original destination. Rollback failures are returned, references retained+when cleanup is uncertain, and later retries replace the failed copy. Accounting+is committed only after the clone succeeds. FAQ containers do not inherit the+source document's transfer marker.++Source wiki cleanup starts only after the document ownership CAS succeeds.+The transfer checkpoint preserves source chunk IDs and summary before reparse+removes them. Retract page lists are persisted before page source refs are removed, so queue+failures retain retry evidence. Cleanup errors propagate; redelivery resumes cleanup after a+committed move without repeating vector/chunk relocation. These retries do not+provide a distributed transaction or recovery after retries are exhausted.++Vector reuse relocates KB metadata while preserving physical vector/chunk IDs.+Weaviate and Milvus drain the first source-filtered page until a follow-up query+is empty, avoiding offset limits/skipped rows. Repeated IDs or partial failures+return errors and leave the document checkpoint pending for retry.+OpenSearch selects the entire source KB/document pair, even without DB chunks,+and rejects version conflicts, timeouts and partial failures before DB relocation.+OpenSearch and Elasticsearch 7/8 require present non-negative `total`/`updated`+counts with `updated == total`; their move scripts do not skip/delete documents.+A zero/zero result allows a retry after metadata already reached the target.+Reparse cleanup loads and validates the source KB before touching any backend,+reusing its storage binding throughout; a failed/missing lookup cannot fall+back to the tenant default store.+Vector reuse never copies vectors and then deletes by the same document ID. Source and+target must use the same vector store for reuse, and the same concrete file+storage instance for either mode. Doris ANN tables cannot safely replace rows+without a delete/insert gap, so their moves require `reparse`. Clone still+requires compatible embedding models and vector stores; a move also retains+the existing same-model requirement. This is not a cross-storage migration API.++Conditional document checkpoints bind tenant, KB, status and the stored update+time. They keep storage accounting in the same database transaction and read+back timestamp precision. Delete stops when its checkpoint no longer matches.+Ordinary document/chunk writes reject a document in the `moving` phase. Parser+admission and failure callbacks verify the task's persisted tenant/KB binding;+table-summary failure cleanup also stops if its document changed.++## Follow-up work outside this refactor++These are separate follow-ups, not capabilities provided by this package:++1. **Complete worker contracts and concurrency control.** Audit enrichment,+ table-summary, multimodal, wiki and indexing workers end to end. Standardize+ payload resource bindings, processing-attempt IDs and conditional writes,+ including operations admitted before a concurrent move. Do not replace+ these checks with an execution-tenant switch or a blanket task write grant.+2. **Durable recovery across systems.** Add a transactional outbox and explicit+ recovery/cancellation for exhausted transfer tasks. Current retries use the+ same admitted task identity; a new move request is not a resume API. Database,+ queue, vector, graph and blob operations are not one atomic transaction.+ Physical file cleanup remains best effort and needs durable garbage collection.+3. **External-backend integration coverage.** Exercise clone/move, partial+ backend failures, retries, pagination and search/edit behavior against live+ PostgreSQL, Elasticsearch 7/8, OpenSearch, Qdrant, Milvus, Weaviate,+ TencentVectorDB and Doris. Local SQLite vector tests and backend compilation+ do not establish this coverage. Doris ANN vector reuse remains unsupported.+4. **Finish service-layer migration.** Apply explicit operation grants to the+ remaining KB configuration/duplicate/delete, wiki and resource-administration+ service methods, preserving their existing route admission policies. Keep+ user/organization membership, embed, IM and signed-resource contracts separate.+5. **Trusted legacy file migration.** Backfill historical file bindings from+ verified provenance, not arbitrary chunk/wiki mentions. Unbound historical+ files now fail closed; request-path text fallback has been removed. Migrate+ old queued payloads and transfer records without captured source wiki refs.+ A legacy delete task without a KB ID can reconstruct only its present+ unambiguous binding, not its original enqueue-time binding.++No public request schema or database column migration is required by this+refactor. Internal service interfaces require operation contexts, queued payloads+add optional scope fields, and malformed/out-of-scope batch selections now fail+before mutation instead of being silently skipped. Callers must also handle a+409 for document edits/deletes while a move is in progress.diff --git a/internal/application/access/context.go b/internal/application/access/context.gonew file mode 100644index 000000000..fbfe0796b--- /dev/null+++ b/internal/application/access/context.go@@ -0,0 +1,94 @@+package access++import (+ "context"++ "github.com/Tencent/WeKnora/internal/types"+)++// Context grants contain values, not mutable KB objects. Deriving a context+// copies the grant slice so parallel search branches cannot widen each other.+type kbGrant struct {+ caller types.Caller+ kbID string+ tenantID uint64+ permission types.OrgMemberRole+ task bool+}++type agentGrant struct {+ caller types.Caller+ scope types.SharedAgentKBScope+}++// WithSharedAgent scopes execution after the caller has authorized this exact+// agent. Only its configured KBs receive read access; other source-tenant KBs+// and the source tenant's organization memberships are not inherited.+func WithSharedAgent(ctx context.Context, agent *types.CustomAgent) context.Context {+ grant := agentGrant{caller: types.CallerFromContext(ctx), scope: types.NewSharedAgentKBScope(agent)}+ ctx = context.WithValue(ctx, types.SharedAgentGrantContextKey, grant)+ if agent == nil {+ return ctx+ }+ return types.WithExecutionTenant(ctx, agent.TenantID)+}++// HasKBGrant checks only previously resolved resource access. It never infers+// ownership from the execution tenant, and always reapplies API-key scope.+func HasKBGrant(ctx context.Context, kbID string, tenantID uint64, required types.OrgMemberRole) bool {+ if !required.IsValid() || types.AuthorizeTenantAPIKeyKnowledgeBases(ctx, kbID) != nil {+ return false+ }+ caller := types.CallerFromContext(ctx)+ if kbID == "" || tenantID == 0 {+ return false+ }+ grants, _ := ctx.Value(types.KBGrantsContextKey).([]kbGrant)+ for _, grant := range grants {+ if (caller.TenantID != 0 || grant.task) && grant.caller == caller && grant.kbID == kbID &&+ grant.tenantID == tenantID &&+ grant.permission.HasPermission(required) {+ return true+ }+ }+ grant, ok := ctx.Value(types.SharedAgentGrantContextKey).(agentGrant)+ return ok && caller.TenantID != 0 && required == types.OrgRoleViewer && grant.caller == caller &&+ grant.scope.Allows(kbID, tenantID)+}++// KBPermissions combines caller ownership, exact context grants and organization+// shares for one service operation. Pass nil shares when that entry point does+// not permit organization expansion (for example, a caller without a user).+type KBPermissions struct {+ ctx context.Context+ caller types.Caller+ shares *KBSharePermissions+}++// NewKBPermissions resolves reads for one caller and operation.+func NewKBPermissions(ctx context.Context, shares KBShareLookup) *KBPermissions {+ caller := types.CallerFromContext(ctx)+ return &KBPermissions{+ ctx: ctx,+ caller: caller,+ shares: NewKBSharePermissions(ctx, shares, caller.TenantID, caller.Role),+ }+}++// Check combines caller ownership, exact grants and organization sharing.+func (p *KBPermissions) Check(kbID string, ownerTenantID uint64, required types.OrgMemberRole) (bool, error) {+ if kbID == "" || ownerTenantID == 0 || !required.IsValid() {+ return false, nil+ }+ if err := types.AuthorizeTenantAPIKeyKnowledgeBases(p.ctx, kbID); err != nil {+ return false, err+ }+ if (p.caller.TenantID == ownerTenantID && required == types.OrgRoleViewer) ||+ HasKBGrant(p.ctx, kbID, ownerTenantID, required) {+ return true, nil+ }+ if p.caller.TenantID == 0 || p.caller.TenantID == ownerTenantID {+ return false, nil+ }+ return p.shares.Check(kbID, required)+}diff --git a/internal/application/access/context_test.go b/internal/application/access/context_test.gonew file mode 100644index 000000000..bef519c84--- /dev/null+++ b/internal/application/access/context_test.go@@ -0,0 +1,140 @@+package access++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++func callerContext() context.Context {+ ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(1))+ ctx = context.WithValue(ctx, types.UserIDContextKey, "user")+ return context.WithValue(ctx, types.TenantRoleContextKey, types.TenantRoleContributor)+}++func TestKBGrantSurvivesExecutionSwitchAndDetachWithoutWidening(t *testing.T) {+ ctx := callerContext()+ kb := &types.KnowledgeBase{ID: "shared", TenantID: 2}+ grant, err := ResolveKB(+ ctx,+ KBRequest{Caller: types.CallerFromContext(ctx)},+ kb,+ types.OrgRoleViewer,+ &shareLookup{permission: types.OrgRoleViewer},+ nil,+ )+ require.NoError(t, err)+ ctx = grant.Context(ctx)+ require.Equal(t, uint64(2), types.MustTenantIDFromContext(ctx))+ ctx = logger.CloneContext(types.WithExecutionTenant(ctx, 3))+ require.Equal(+ t,+ types.Caller{TenantID: 1, UserID: "user", Role: types.TenantRoleContributor},+ types.CallerFromContext(ctx),+ )+ require.True(t, HasKBGrant(ctx, "shared", 2, types.OrgRoleViewer))+ // A later mutation of the service model cannot mutate the captured grant.+ kb.ID = "private"+ require.False(t, HasKBGrant(ctx, "private", 2, types.OrgRoleViewer))+ require.False(t, HasKBGrant(ctx, "shared", 3, types.OrgRoleViewer))+ require.False(t, HasKBGrant(ctx, "shared", 2, types.OrgRoleEditor))+ for _, caller := range []types.Caller{+ {TenantID: 9, UserID: "user", Role: types.TenantRoleContributor},+ {TenantID: 1, UserID: "other", Role: types.TenantRoleContributor},+ {TenantID: 1, UserID: "user", Role: types.TenantRoleViewer},+ } {+ otherCtx := types.WithCaller(ctx, caller)+ require.False(t, HasKBGrant(otherCtx, "shared", 2, types.OrgRoleViewer))+ require.Equal(+ t,+ caller,+ types.CallerFromContext(grant.Context(otherCtx)),+ "reusing a grant cannot impersonate its caller",+ )+ require.Equal(+ t,+ uint64(3),+ types.MustTenantIDFromContext(grant.Context(otherCtx)),+ "a caller mismatch must not change execution scope",+ )+ }+ narrowed := types.WithTenantAPIKeyScope(+ ctx,+ types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"another"}},+ )+ require.False(t, HasKBGrant(narrowed, "shared", 2, types.OrgRoleViewer))+}++func TestExecutionTenantDoesNotGrantOwnershipOrChangeShareIdentity(t *testing.T) {+ ctx := types.WithExecutionTenant(callerContext(), 2)+ shares := &shareLookup{}+ allowed, err := NewKBPermissions(ctx, shares).Check("private", 2, types.OrgRoleViewer)+ require.NoError(t, err)+ require.False(t, allowed)+ require.Equal(t, uint64(1), shares.caller)+ require.Equal(t, types.TenantRoleContributor, shares.role)+ ctx = types.WithExecutionTenant(context.Background(), 2)+ allowed, err = NewKBPermissions(ctx, nil).Check("private", 2, types.OrgRoleViewer)+ require.NoError(t, err)+ require.False(t, allowed, "an absent caller must not become the execution tenant")+}++func TestSharedAgentGrantPreservesConfiguredScopeAcrossDetach(t *testing.T) {+ for _, mode := range []string{"all", "selected", "none", "unknown"} {+ t.Run(mode, func(t *testing.T) {+ agent := &types.CustomAgent{+ TenantID: 2,+ Config: types.CustomAgentConfig{KBSelectionMode: mode, KnowledgeBases: []string{"selected"}},+ }+ ctx := logger.CloneContext(WithSharedAgent(callerContext(), agent))+ require.Equal(t, uint64(1), types.CallerFromContext(ctx).TenantID)+ require.Equal(t, uint64(2), types.MustTenantIDFromContext(ctx))+ require.Equal(t, mode == "all" || mode == "selected", HasKBGrant(ctx, "selected", 2, types.OrgRoleViewer))+ require.Equal(t, mode == "all", HasKBGrant(ctx, "other", 2, types.OrgRoleViewer))+ require.False(t, HasKBGrant(ctx, "selected", 3, types.OrgRoleViewer))+ require.False(t, HasKBGrant(ctx, "selected", 2, types.OrgRoleEditor))+ })+ }+}++func TestKBGrantBranchesRemainIndependent(t *testing.T) {+ base := callerContext()+ grant := &KBAccess{Caller: types.CallerFromContext(base), EffectiveTenantID: 2, Permission: types.OrgRoleViewer}+ grant.KnowledgeBase = &types.KnowledgeBase{ID: "first", TenantID: 2}+ first := grant.WithGrant(base)+ grant.KnowledgeBase = &types.KnowledgeBase{ID: "second", TenantID: 2}+ second := grant.WithGrant(base)+ require.True(t, HasKBGrant(first, "first", 2, types.OrgRoleViewer))+ require.False(t, HasKBGrant(first, "second", 2, types.OrgRoleViewer))+ require.True(t, HasKBGrant(second, "second", 2, types.OrgRoleViewer))+ require.False(t, HasKBGrant(second, "first", 2, types.OrgRoleViewer))+}++func TestKBPermissionsOwnerShortcutOnlyGrantsRead(t *testing.T) {+ roles := []types.TenantRole{types.TenantRoleViewer, types.TenantRoleContributor, types.TenantRoleAdmin}+ for _, role := range roles {+ ctx := context.WithValue(callerContext(), types.TenantRoleContextKey, role)+ permissions := NewKBPermissions(ctx, nil)+ for _, required := range []types.OrgMemberRole{types.OrgRoleViewer, types.OrgRoleEditor, types.OrgRoleAdmin} {+ allowed, err := permissions.Check("kb", 1, required)+ require.NoError(t, err)+ require.Equal(t, required == types.OrgRoleViewer, allowed)+ }+ grant := &KBAccess{+ Caller: types.CallerFromContext(ctx),+ KnowledgeBase: &types.KnowledgeBase{ID: "kb", TenantID: 1},+ EffectiveTenantID: 1,+ Permission: types.OrgRoleEditor,+ }+ permissions = NewKBPermissions(grant.Context(ctx), nil)+ allowed, err := permissions.Check("kb", 1, types.OrgRoleEditor)+ require.NoError(t, err)+ require.True(t, allowed)+ allowed, err = permissions.Check("kb", 1, types.OrgRoleAdmin)+ require.NoError(t, err)+ require.False(t, allowed)+ }+}diff --git a/internal/application/access/files.go b/internal/application/access/files.gonew file mode 100644index 000000000..f18e6bcb8--- /dev/null+++ b/internal/application/access/files.go@@ -0,0 +1,256 @@+package access++import (+ "context"+ "encoding/json"+ "fmt"+ "strings"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ secutils "github.com/Tencent/WeKnora/internal/utils"+)++// FileAccess is a request-local result, produced before storage is opened.+// Physical locators are not a substitute for KB/message authorization.+type FileAccess struct {+ OwnerTenantID uint64+ Path string+ Filename string+ StorageBackendID string+}++// FileCatalog resolves logical references to their stored owner and locator.+type FileCatalog interface {+ ResolvePath(context.Context, string) (string, *types.StoredResource, error)+}++func resolveFile(+ ctx context.Context,+ catalog FileCatalog,+ reference string,+) (FileAccess, *types.StoredResource, error) {+ file := FileAccess{Path: reference, Filename: reference}+ if catalog == nil {+ if _, resource := types.ParseResourcePath(reference); resource {+ return file, nil, ErrNotFound+ }+ return file, nil, nil+ }+ path, resource, err := catalog.ResolvePath(ctx, reference)+ if err != nil {+ return file, nil, ErrNotFound+ }+ file.Path = path+ file.Filename = path+ if resource != nil {+ file.OwnerTenantID = resource.TenantID+ file.StorageBackendID = resource.StorageBackendID+ if strings.TrimSpace(resource.OriginalName) != "" {+ file.Filename = resource.OriginalName+ }+ }+ return file, resource, nil+}++// ResolveKBFile requires the route's exact KB grant and an independent live+// explicit binding check. Rewriting the execution tenant is insufficient.+func ResolveKBFile(+ ctx context.Context,+ grant *KBAccess,+ kbID, reference string,+ catalog FileCatalog,+ bindings interfaces.KBResourceLookup,+) (FileAccess, error) {+ var empty FileAccess+ if grant == nil || grant.KnowledgeBase == nil || grant.KnowledgeBase.ID != kbID ||+ grant.Caller != types.CallerFromContext(ctx) || !grant.Permission.HasPermission(types.OrgRoleViewer) {+ return empty, ErrForbidden+ }+ if err := types.AuthorizeTenantAPIKeyKnowledgeBases(ctx, kbID); err != nil {+ return empty, err+ }+ file, resource, err := resolveFile(ctx, catalog, reference)+ if err != nil {+ return empty, err+ }+ owner := grant.EffectiveTenantID+ if owner == 0 || (resource != nil && resource.TenantID != owner) {+ return empty, ErrForbidden+ }+ if err := secutils.ValidateKBScopedStoragePath(file.Path, owner); err != nil {+ return empty, ErrForbidden+ }+ if bindings == nil {+ return empty, ErrForbidden+ }+ bound, err := bindings.IsReferencedByKnowledgeBase(ctx, owner, kbID, reference)+ if err != nil {+ return empty, fmt.Errorf("check KB file binding: %w", err)+ }+ if !bound {+ return empty, ErrForbidden+ }+ file.OwnerTenantID = owner+ return file, nil+}++// MessageReferencesFile examines only persisted rendering/output fields. Tool+// arguments and request metadata are not evidence of a returned file.+func MessageReferencesFile(message *types.Message, reference string) bool {+ if message == nil {+ return false+ }+ if types.ContainsStorageReference(message.Content, reference) {+ return true+ }+ for _, artifact := range message.Artifacts {+ if artifact.URL == reference {+ return true+ }+ }+ for _, value := range []interface{}{message.KnowledgeReferences, message.Images} {+ data, _ := json.Marshal(value)+ if types.ContainsStorageReference(string(data), reference) {+ return true+ }+ }+ for _, step := range message.AgentSteps {+ for _, call := range step.ToolCalls {+ if call.Result == nil {+ continue+ }+ data, _ := json.Marshal(call.Result)+ if types.ContainsStorageReference(string(data), reference) {+ return true+ }+ }+ }+ return false+}++// ResolveMessageFile loads the session-authorized message using the original+// caller and rechecks its current sharing relationships on every request.+func ResolveMessageFile(ctx context.Context, sessionID, messageID, reference string, messages MessageFileLookup,+ agents SharedAgentFileLookup, catalog FileCatalog, kbShares MessageKBShareAuthorizer,+) (FileAccess, error) {+ caller := types.CallerFromContext(ctx)+ if caller.TenantID == 0 {+ return FileAccess{}, ErrUnauthorized+ }+ if messages == nil {+ return FileAccess{}, ErrNotFound+ }+ ctx = types.WithExecutionTenant(ctx, caller.TenantID)+ message, err := messages.GetMessage(ctx, sessionID, messageID)+ if err != nil || message == nil {+ return FileAccess{}, ErrNotFound+ }+ return AuthorizeMessageFile(ctx, message, reference, agents, catalog, kbShares)+}++// AuthorizeMessageFile also serves index-based artifact downloads after their+// session/message lookup. It never accepts an unchecked client message.+func AuthorizeMessageFile(ctx context.Context, message *types.Message, reference string, agents SharedAgentFileLookup,+ catalog FileCatalog, kbShares MessageKBShareAuthorizer,+) (FileAccess, error) {+ caller := types.CallerFromContext(ctx)+ if caller.TenantID == 0 {+ return FileAccess{}, ErrUnauthorized+ }+ if !MessageReferencesFile(message, reference) {+ return FileAccess{}, ErrForbidden+ }+ file, resource, err := resolveFile(ctx, catalog, reference)+ if err != nil {+ return FileAccess{}, err+ }+ owner := message.AgentTenantID+ if resource != nil {+ owner = resource.TenantID+ }+ if owner == 0 {+ return FileAccess{}, ErrForbidden+ }+ if message.Role == "user" && owner != caller.TenantID {+ return FileAccess{}, ErrForbidden+ }+ if kbShares.Bindings == nil {+ kbShares.Bindings, _ = catalog.(interfaces.KBResourceLookup)+ }+ kbAuthorized := false+ if resource != nil && message.AgentTenantID != 0 && message.AgentTenantID != owner {+ kbAuthorized = kbShares.resourceAccessibleViaSharedKB(ctx, message, resource, caller.TenantID, caller.Role)+ if !kbAuthorized {+ return FileAccess{}, ErrForbidden+ }+ }+ if owner != caller.TenantID && !kbAuthorized {+ if message.AgentTenantID == 0 {+ kbAuthorized = kbShares.resourceAccessibleViaSharedKB(ctx, message, resource, caller.TenantID, caller.Role)+ }+ if !kbAuthorized {+ if message.AgentID == "" || agents == nil {+ return FileAccess{}, ErrForbidden+ }+ agent, err := agents.GetSharedAgentForTenant(ctx, caller.TenantID, caller.Role, message.AgentID, owner)+ if err != nil || agent == nil || agent.TenantID != owner {+ return FileAccess{}, ErrForbidden+ }+ bindings, ok := catalog.(interfaces.MessageFileBindingLookup)+ if !ok {+ return FileAccess{}, ErrForbidden+ }+ origins, err := bindings.GetMessageFileBindings(ctx, owner, reference, message.ID)+ if err != nil || origins == nil {+ return FileAccess{}, ErrForbidden+ }+ allowed := origins.MessageArtifact+ scope := types.NewSharedAgentKBScope(agent)+ for _, kbID := range origins.KnowledgeBaseIDs {+ if scope.Allows(kbID, owner) && types.AuthorizeTenantAPIKeyKnowledgeBases(ctx, kbID) == nil {+ allowed = true+ }+ }+ if !allowed {+ return FileAccess{}, ErrForbidden+ }+ }+ }+ if resource == nil {+ if err := secutils.ValidateStoragePathTenant(file.Path, owner); err != nil {+ return FileAccess{}, ErrForbidden+ }+ }+ file.OwnerTenantID = owner+ return file, nil+}++// ResolveMessageArtifact selects a persisted artifact after session ownership+// was checked. Session-owned output stays downloadable independently of the+// agent; source-owned output still requires its current sharing permission.+func ResolveMessageArtifact(ctx context.Context, message *types.Message, index int, agents SharedAgentFileLookup,+ catalog FileCatalog, kbShares MessageKBShareAuthorizer,+) (FileAccess, error) {+ caller := types.CallerFromContext(ctx)+ if caller.TenantID == 0 {+ return FileAccess{}, ErrUnauthorized+ }+ if message == nil || index < 0 || index >= len(message.Artifacts) {+ return FileAccess{}, ErrNotFound+ }+ artifact := message.Artifacts[index]+ file, resource, err := resolveFile(ctx, catalog, artifact.URL)+ if err != nil {+ return FileAccess{}, err+ }+ if (resource != nil && resource.TenantID == caller.TenantID) ||+ (resource == nil && secutils.ValidateStoragePathTenant(file.Path, caller.TenantID) == nil) {+ file.OwnerTenantID = caller.TenantID+ file.Filename = artifact.FileName+ return file, nil+ }+ file, err = AuthorizeMessageFile(ctx, message, artifact.URL, agents, catalog, kbShares)+ file.Filename = artifact.FileName+ return file, err+}diff --git a/internal/application/access/files_test.go b/internal/application/access/files_test.gonew file mode 100644index 000000000..e6693527f--- /dev/null+++ b/internal/application/access/files_test.go@@ -0,0 +1,162 @@+package access++import (+ "context"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++type fileCatalog struct{ resource *types.StoredResource }++func (c fileCatalog) ResolvePath(_ context.Context, ref string) (string, *types.StoredResource, error) {+ if c.resource == nil {+ return ref, nil, nil+ }+ return c.resource.PhysicalPath, c.resource, nil+}++type fileBinding struct {+ allowed bool+ err error+ kb string+ tenant uint64+}++func (b *fileBinding) IsReferencedByKnowledgeBase(_ context.Context, tenant uint64, kb, _ string) (bool, error) {+ b.kb, b.tenant = kb, tenant+ return b.allowed, b.err+}++type fileMessages struct {+ message *types.Message+ tenant uint64+}++func (m *fileMessages) GetMessage(ctx context.Context, _, _ string) (*types.Message, error) {+ m.tenant = types.MustTenantIDFromContext(ctx)+ return m.message, nil+}++func TestKBFilesRequireExactGrantAndBinding(t *testing.T) {+ base := callerContext()+ grant := &KBAccess{+ Caller: types.CallerFromContext(base),+ KnowledgeBase: &types.KnowledgeBase{ID: "kb", TenantID: 2},+ EffectiveTenantID: 2,+ Permission: types.OrgRoleViewer,+ }+ ctx := grant.Context(base)+ bindings := &fileBinding{allowed: true}+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ catalog := fileCatalog{+ &types.StoredResource{TenantID: 2, PhysicalPath: "local://2/exports/a.png", OriginalName: "a.png"},+ }+ file, err := ResolveKBFile(ctx, grant, "kb", ref, catalog, bindings)+ require.NoError(t, err)+ require.Equal(t, uint64(2), file.OwnerTenantID)+ require.Equal(t, "kb", bindings.kb)+ require.Equal(t, uint64(2), bindings.tenant)+ bindings.allowed = false+ _, err = ResolveKBFile(ctx, grant, "kb", ref, catalog, bindings)+ require.ErrorIs(t, err, ErrForbidden, "a same-tenant file still needs an exact KB binding")+ bindings.allowed = true+ _, err = ResolveKBFile(ctx, grant, "another", ref, catalog, bindings)+ require.ErrorIs(t, err, ErrForbidden)+ _, err = ResolveKBFile(ctx, nil, "kb", ref, catalog, bindings)+ require.ErrorIs(t, err, ErrForbidden, "execution tenant alone is not a grant")+ bindings.err = errors.New("database unavailable")+ _, err = ResolveKBFile(ctx, grant, "kb", ref, catalog, bindings)+ require.ErrorIs(t, err, bindings.err)+}++func TestMessageFilesRequireReferenceAndRecheckRevocation(t *testing.T) {+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ messages := &fileMessages{+ message: &types.Message{ID: "message", AgentID: "agent", AgentTenantID: 2, Role: "assistant"},+ }+ agents := &agentLookup{agent: &types.CustomAgent{ID: "agent", TenantID: 2}}+ catalog := artifactFileCatalog{+ fileCatalog{&types.StoredResource{TenantID: 2, PhysicalPath: "local://2/exports/a.png"}},+ }+ ctx := types.WithExecutionTenant(callerContext(), 2)+ _, err := ResolveMessageFile(ctx, "session", "message", ref, messages, agents, catalog, MessageKBShareAuthorizer{})+ require.ErrorIs(t, err, ErrForbidden)+ messages.message.Content = ""+ _, err = ResolveMessageFile(ctx, "session", "message", ref, messages, agents, catalog, MessageKBShareAuthorizer{})+ require.ErrorIs(t, err, ErrForbidden, "a longer handle is not the requested handle")+ messages.message.Content = ""+ _, err = ResolveMessageFile(ctx, "session", "message", ref, messages, agents, catalog, MessageKBShareAuthorizer{})+ require.NoError(t, err)+ require.Equal(t, uint64(1), messages.tenant, "session lookup must use the caller")+ agents.agent = nil+ _, err = ResolveMessageFile(ctx, "session", "message", ref, messages, agents, catalog, MessageKBShareAuthorizer{})+ require.ErrorIs(t, err, ErrForbidden, "historical references cannot bypass share revocation")+}++func TestMessageArtifactsKeepSessionOwnershipSeparateFromAgentOutput(t *testing.T) {+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ message := &types.Message{+ AgentID: "agent",+ AgentTenantID: 2,+ Artifacts: types.MessageArtifacts{{URL: ref, FileName: "report.pdf"}},+ }+ catalog := fileCatalog{&types.StoredResource{TenantID: 1, PhysicalPath: "local://1/exports/report.pdf"}}+ file, err := ResolveMessageArtifact(callerContext(), message, 0, nil, catalog, MessageKBShareAuthorizer{})+ require.NoError(t, err)+ require.Equal(t, uint64(1), file.OwnerTenantID)+ catalog.resource.TenantID = 2+ catalog.resource.PhysicalPath = "local://2/exports/report.pdf"+ _, err = ResolveMessageArtifact(callerContext(), message, 0, nil, catalog, MessageKBShareAuthorizer{})+ require.ErrorIs(t, err, ErrForbidden)+}++type messageFileKBs struct{ kb *types.KnowledgeBase }++func (k messageFileKBs) GetKnowledgeBasesByIDsOnly(context.Context, []string) ([]*types.KnowledgeBase, error) {+ return []*types.KnowledgeBase{k.kb}, nil+}++func TestMessageSharedKBFilesRequireLiveBinding(t *testing.T) {+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ message := &types.Message{+ AgentTenantID: 1, Role: "assistant",+ KnowledgeReferences: types.References{{KnowledgeBaseID: "shared", Content: ref}},+ }+ catalog := fileCatalog{&types.StoredResource{+ Handle: "AbCdEfGhIjKlMnOpQrStUv", TenantID: 2, PhysicalPath: "local://2/exports/a.png",+ }}+ binding := &fileBinding{allowed: true}+ shares := &shareLookup{permission: types.OrgRoleViewer}+ authorizer := MessageKBShareAuthorizer{+ ShareGuard: shares, KBs: messageFileKBs{kb: &types.KnowledgeBase{ID: "shared", TenantID: 2}}, Bindings: binding,+ }+ _, err := AuthorizeMessageFile(callerContext(), message, ref, nil, catalog, authorizer)+ require.NoError(t, err)+ require.Equal(t, "shared", binding.kb)+ require.Equal(t, uint64(2), binding.tenant)+ binding.allowed = false+ _, err = AuthorizeMessageFile(callerContext(), message, ref, nil, catalog, authorizer)+ require.ErrorIs(t, err, ErrForbidden, "retrieval text alone must not authorize an unrelated same-tenant resource")+ binding.allowed = true+ binding.err = errors.New("binding lookup unavailable")+ _, err = AuthorizeMessageFile(callerContext(), message, ref, nil, catalog, authorizer)+ require.ErrorIs(t, err, ErrForbidden)+ binding.err = nil+ authorizer.Bindings = nil+ _, err = AuthorizeMessageFile(callerContext(), message, ref, nil, catalog, authorizer)+ require.ErrorIs(t, err, ErrForbidden, "missing live lookup must fail closed")+}++// This fixture represents a catalog claim made by the artifact collector.+type artifactFileCatalog struct{ fileCatalog }++func (artifactFileCatalog) GetMessageFileBindings(+ _ context.Context,+ _ uint64,+ _, messageID string,+) (*types.MessageFileBindings, error) {+ return &types.MessageFileBindings{MessageArtifact: messageID == "message"}, nil+}diff --git a/internal/application/access/kb_shares.go b/internal/application/access/kb_shares.gonew file mode 100644index 000000000..b73957dbe--- /dev/null+++ b/internal/application/access/kb_shares.go@@ -0,0 +1,62 @@+package access++import (+ "context"++ "github.com/Tencent/WeKnora/internal/types"+)++// KBSharePermissions resolves organization grants for one caller during one+// operation. It deliberately does not grant tenant ownership or shared-agent+// access. Callers retain their own policy for lookup failures (abort or filter).+// Create a new instance for each operation; it is not a cross-request cache and+// must not be shared between goroutines.+type KBSharePermissions struct {+ ctx context.Context+ lookup KBShareLookup+ tenantID uint64+ role types.TenantRole+ results map[string]kbSharePermission+}++type kbSharePermission struct {+ role types.OrgMemberRole+ shared bool+ err error+}++// NewKBSharePermissions creates a request-local permission cache.+func NewKBSharePermissions(+ ctx context.Context,+ lookup KBShareLookup,+ tenantID uint64,+ role types.TenantRole,+) *KBSharePermissions {+ return &KBSharePermissions{+ ctx: ctx,+ lookup: lookup,+ tenantID: tenantID,+ role: role,+ results: make(map[string]kbSharePermission),+ }+}++// Permission caches both grants and failures so multiple documents/chunks in a+// KB observe the same decision, without repeating the membership queries.+func (p *KBSharePermissions) Permission(kbID string) (types.OrgMemberRole, bool, error) {+ if kbID == "" || p.tenantID == 0 || p.lookup == nil {+ return "", false, nil+ }+ result, ok := p.results[kbID]+ if !ok {+ result.role, result.shared, result.err = p.lookup.CheckTenantKBPermission(p.ctx, kbID, p.tenantID, p.role)+ p.results[kbID] = result+ }+ return result.role, result.shared, result.err+}++// Check tests the required role against the cached organization permission.+func (p *KBSharePermissions) Check(kbID string, required types.OrgMemberRole) (bool, error) {+ role, shared, err := p.Permission(kbID)+ return err == nil && shared && role.IsValid() && required.IsValid() && role.HasPermission(required), err+}diff --git a/internal/application/access/kb_shares_test.go b/internal/application/access/kb_shares_test.gonew file mode 100644index 000000000..2fc5cc11e--- /dev/null+++ b/internal/application/access/kb_shares_test.go@@ -0,0 +1,84 @@+package access++import (+ "context"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++type permissionLookupFunc func(context.Context, string, uint64, types.TenantRole) (types.OrgMemberRole, bool, error)++func (f permissionLookupFunc) CheckTenantKBPermission(+ ctx context.Context,+ id string,+ tenant uint64,+ role types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ return f(ctx, id, tenant, role)+}++func TestKBSharePermissionsCachePerOperation(t *testing.T) {+ calls := map[string]int{}+ granted := true+ lookup := permissionLookupFunc(+ func(_ context.Context, kb string, tenant uint64, role types.TenantRole) (types.OrgMemberRole, bool, error) {+ require.Equal(t, uint64(1), tenant)+ require.Equal(t, types.TenantRoleContributor, role)+ calls[kb]+++ return types.OrgRoleEditor, granted, nil+ },+ )+ permissions := NewKBSharePermissions(context.Background(), lookup, 1, types.TenantRoleContributor)+ for _, required := range []types.OrgMemberRole{types.OrgRoleViewer, types.OrgRoleEditor, types.OrgRoleAdmin} {+ allowed, err := permissions.Check("kb", required)+ require.NoError(t, err)+ require.Equal(t, required != types.OrgRoleAdmin, allowed)+ }+ require.Equal(t, 1, calls["kb"], "different minimum roles share the same membership lookup")+ _, err := permissions.Check("other", types.OrgRoleViewer)+ require.NoError(t, err)+ require.Equal(t, 1, calls["other"])+ granted = false+ fresh := NewKBSharePermissions(context.Background(), lookup, 1, types.TenantRoleContributor)+ allowed, err := fresh.Check("kb", types.OrgRoleViewer)+ require.NoError(t, err)+ require.False(t, allowed, "a new operation must observe share revocation")+ require.Equal(t, 2, calls["kb"])+}++func TestKBSharePermissionsCachesFailuresWithoutGranting(t *testing.T) {+ failure := errors.New("database unavailable")+ calls := 0+ lookup := permissionLookupFunc(+ func(context.Context, string, uint64, types.TenantRole) (types.OrgMemberRole, bool, error) {+ calls+++ return types.OrgRoleAdmin, true, failure+ },+ )+ permissions := NewKBSharePermissions(context.Background(), lookup, 1, types.TenantRoleAdmin)+ for i := 0; i < 3; i++ {+ allowed, err := permissions.Check("kb", types.OrgRoleViewer)+ require.False(t, allowed)+ require.ErrorIs(t, err, failure, "callers must retain the infrastructure error")+ }+ require.Equal(t, 1, calls)+}++func TestKBSharePermissionsMissingLookupAndInvalidRolesDeny(t *testing.T) {+ permissions := NewKBSharePermissions(context.Background(), nil, 1, types.TenantRoleAdmin)+ allowed, err := permissions.Check("kb", types.OrgRoleViewer)+ require.NoError(t, err)+ require.False(t, allowed)+ lookup := permissionLookupFunc(+ func(context.Context, string, uint64, types.TenantRole) (types.OrgMemberRole, bool, error) {+ return types.OrgRoleEditor, true, nil+ },+ )+ permissions = NewKBSharePermissions(context.Background(), lookup, 1, types.TenantRoleAdmin)+ allowed, err = permissions.Check("kb", "unknown")+ require.NoError(t, err)+ require.False(t, allowed)+}diff --git a/internal/application/access/kb_transfer.go b/internal/application/access/kb_transfer.gonew file mode 100644index 000000000..0cac5b40e--- /dev/null+++ b/internal/application/access/kb_transfer.go@@ -0,0 +1,227 @@+package access++import (+ "context"+ "fmt"++ "github.com/Tencent/WeKnora/internal/types"+)++// KBTransferOperation selects the source and destination permission contract.+type KBTransferOperation string++// Supported knowledge-base transfer operations.+const (+ KBTransferClone KBTransferOperation = "clone"+ KBTransferMove KBTransferOperation = "move"+)++type kbTransferGrant struct {+ caller types.Caller+ tenant uint64+ source, target, taskID, creatorID string+ operation KBTransferOperation+ create bool+}++// WithKBTransfer admits a pair of resources after the entry point has resolved+// the source and destination grants and applied its creator/role policy. A new+// clone destination must be a server-reserved ID; it is not an existing KB.+func WithKBTransfer(+ ctx context.Context,+ source, target *types.KnowledgeBase,+ operation KBTransferOperation,+ taskID string,+ create bool,+) (context.Context, error) {+ caller := types.CallerFromContext(ctx)+ if taskID == "" {+ return ctx, ErrForbidden+ }+ if err := validateTransferPair(source, target, caller.TenantID, operation, create); err != nil {+ return ctx, err+ }+ if err := transferAPIScope(ctx, source.ID, target.ID, operation, create); err != nil {+ return ctx, err+ }+ required := types.OrgRoleViewer+ if operation == KBTransferMove {+ required = types.OrgRoleEditor+ }+ if !HasKBGrant(ctx, source.ID, source.TenantID, required) ||+ (!create && !HasKBGrant(ctx, target.ID, target.TenantID, types.OrgRoleEditor)) {+ return ctx, ErrForbidden+ }+ return withTransferGrant(ctx, source, target, operation, taskID, create, false), nil+}++// WithKBTransferTask continues an admitted task. Both KBs must first be loaded+// with their persisted owners (or a reserved new clone destination). This scope+// cannot authorize a different pair or upgrade the worker into a tenant user.+func WithKBTransferTask(+ ctx context.Context,+ source, target *types.KnowledgeBase,+ expectedTenant uint64,+ operation KBTransferOperation,+ taskID string,+ create bool,+) (context.Context, error) {+ if taskID == "" {+ return ctx, ErrForbidden+ }+ if err := validateTransferPair(source, target, expectedTenant, operation, create); err != nil {+ return ctx, err+ }+ ctx = types.WithExecutionTenant(ctx, expectedTenant)+ return withTransferGrant(ctx, source, target, operation, taskID, create, true), nil+}++func withTransferGrant(+ ctx context.Context,+ source, target *types.KnowledgeBase,+ operation KBTransferOperation,+ taskID string,+ create, task bool,+) context.Context {+ caller := types.CallerFromContext(ctx)+ grant := kbTransferGrant{+ caller: caller,+ tenant: source.TenantID,+ source: source.ID,+ target: target.ID,+ taskID: taskID,+ creatorID: target.CreatorID,+ operation: operation,+ create: create,+ }+ required := types.OrgRoleViewer+ if operation == KBTransferMove {+ required = types.OrgRoleEditor+ }+ ctx = context.WithValue(ctx, types.KBGrantsContextKey, []kbGrant{+ {caller: caller, kbID: source.ID, tenantID: source.TenantID, permission: required, task: task},+ {caller: caller, kbID: target.ID, tenantID: target.TenantID, permission: types.OrgRoleEditor, task: task},+ })+ return context.WithValue(ctx, types.KBTransferContextKey, grant)+}++// RequireKBTransfer consumes the exact caller, operation and resource-pair grant.+func RequireKBTransfer(ctx context.Context, source, target *types.KnowledgeBase, operation KBTransferOperation) error {+ grant, ok := ctx.Value(types.KBTransferContextKey).(kbTransferGrant)+ if !ok || grant.caller != types.CallerFromContext(ctx) || grant.operation != operation {+ return ErrForbidden+ }+ if err := validateTransferPair(source, target, grant.tenant, operation, grant.create); err != nil {+ return err+ }+ if grant.source != source.ID || grant.target != target.ID {+ return ErrForbidden+ }+ return transferAPIScope(ctx, source.ID, target.ID, operation, grant.create)+}++// CloneDestination exposes only the destination already admitted by the+// request/worker; CopyKnowledgeBase cannot turn an empty ID into ambient write.+func CloneDestination(ctx context.Context, sourceID string) (id string, create bool, creatorID string, err error) {+ g, ok := ctx.Value(types.KBTransferContextKey).(kbTransferGrant)+ if !ok || g.caller != types.CallerFromContext(ctx) || g.operation != KBTransferClone || g.source != sourceID {+ return "", false, "", ErrForbidden+ }+ return g.target, g.create, g.creatorID, nil+}++// TransferTaskID returns the admitted operation identity for retry checkpoints.+func TransferTaskID(ctx context.Context) string {+ g, ok := ctx.Value(types.KBTransferContextKey).(kbTransferGrant)+ if !ok || g.caller != types.CallerFromContext(ctx) {+ return ""+ }+ return g.taskID+}++func validateTransferPair(+ source, target *types.KnowledgeBase,+ tenant uint64,+ operation KBTransferOperation,+ create bool,+) error {+ if source == nil || target == nil || tenant == 0 || source.ID == "" || target.ID == "" ||+ source.TenantID != tenant ||+ target.TenantID != tenant {+ return ErrForbidden+ }+ if source.ID == target.ID {+ return fmt.Errorf("source and target knowledge bases must differ")+ }+ if operation != KBTransferClone && operation != KBTransferMove || create && operation != KBTransferClone {+ return ErrForbidden+ }+ return nil+}++func transferAPIScope(+ ctx context.Context,+ sourceID, targetID string,+ operation KBTransferOperation,+ create bool,+) error {+ ids := []string{sourceID}+ if !create {+ ids = append(ids, targetID)+ }+ if err := types.AuthorizeTenantAPIKeyKnowledgeBases(ctx, ids...); err != nil {+ return err+ }+ capability := types.APIKeyCapabilityManageKnowledgeBases+ if operation == KBTransferMove {+ capability = types.APIKeyCapabilityIngest+ }+ if scope, ok := types.TenantAPIKeyScopeFromContext(ctx); ok && !scope.FullAccess &&+ !scope.HasCapability(capability) {+ return ErrForbidden+ }+ return nil+}++// ValidateKBTransferCompatibility is shared by synchronous admission and task+// execution, so invalid modes/configurations fail before resource mutations.+func ValidateKBTransferCompatibility(+ source, target *types.KnowledgeBase,+ operation KBTransferOperation,+ mode string,+ tenant *types.Tenant,+) error {+ if source == nil || target == nil {+ return ErrNotFound+ }+ if source.ID == target.ID {+ return fmt.Errorf("source and target knowledge bases must differ")+ }+ if source.Type != target.Type {+ return fmt.Errorf("source and target knowledge bases must have the same type")+ }+ if source.EmbeddingModelID != target.EmbeddingModelID {+ return fmt.Errorf("source and target knowledge bases use different embedding models")+ }+ if operation == KBTransferMove && mode != "reuse_vectors" && mode != "reparse" {+ return fmt.Errorf("unknown move mode: %s", mode)+ }+ if (operation == KBTransferClone || mode == "reuse_vectors") && !source.SharesStoreWith(target) {+ return fmt.Errorf("source and target knowledge bases use different vector stores; use reparse mode for moves")+ }+ // A move retains file paths too, so resolving them through another storage+ // instance would make the document unreadable, even when vectors are reparsed.+ defaultID, defaultProvider := "", ""+ if tenant != nil {+ if tenant.DefaultStorageBackendID != nil {+ defaultID = *tenant.DefaultStorageBackendID+ }+ if tenant.StorageEngineConfig != nil {+ defaultProvider = tenant.StorageEngineConfig.DefaultProvider+ }+ }+ if !source.SharesStorageBackendWith(target, defaultID, defaultProvider) {+ return fmt.Errorf("source and target knowledge bases use different storage instances")+ }+ return nil+}diff --git a/internal/application/access/kb_transfer_test.go b/internal/application/access/kb_transfer_test.gonew file mode 100644index 000000000..f3fa0ee0d--- /dev/null+++ b/internal/application/access/kb_transfer_test.go@@ -0,0 +1,96 @@+package access++import (+ "context"+ "fmt"+ "testing"++ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++func TestTransferAdmissionRequiresIndependentGrants(t *testing.T) {+ source, target := &types.KnowledgeBase{ID: "source", TenantID: 1}, &types.KnowledgeBase{ID: "target", TenantID: 1}+ ctx := types.WithCaller(+ context.Background(),+ types.Caller{TenantID: 1, UserID: "user", Role: types.TenantRoleAdmin},+ )+ _, err := WithKBTransfer(ctx, source, target, KBTransferMove, "task", false)+ require.ErrorIs(t, err, ErrForbidden)+ request := KBRequest{Caller: types.CallerFromContext(ctx)}+ sourceRead, err := ResolveKB(ctx, request, source, types.OrgRoleViewer, nil, nil)+ require.NoError(t, err)+ targetRead, err := ResolveKB(ctx, request, target, types.OrgRoleViewer, nil, nil)+ require.NoError(t, err)+ reads := targetRead.WithGrant(sourceRead.WithGrant(ctx))+ _, err = WithKBTransfer(reads, source, target, KBTransferClone, "task", false)+ require.ErrorIs(t, err, ErrForbidden, "owner read projection must not authorize target replacement")+ targetWrite, err := ResolveKB(ctx, request, target, types.OrgRoleEditor, nil, nil)+ require.NoError(t, err)+ cloneCtx, err := WithKBTransfer(targetWrite.WithGrant(reads), source, target, KBTransferClone, "task", false)+ require.NoError(t, err)+ require.NoError(t, RequireKBTransfer(logger.CloneContext(cloneCtx), source, target, KBTransferClone))+ require.False(t, HasKBGrant(cloneCtx, source.ID, 1, types.OrgRoleEditor))+ _, err = WithKBTransfer(targetWrite.WithGrant(reads), source, target, KBTransferMove, "task", false)+ require.ErrorIs(t, err, ErrForbidden)+}++func TestTransferTaskScopeIsExactAndDoesNotCreateCaller(t *testing.T) {+ source, target := &types.KnowledgeBase{ID: "source", TenantID: 7}, &types.KnowledgeBase{ID: "target", TenantID: 7}+ ctx, err := WithKBTransferTask(context.Background(), source, target, 7, KBTransferMove, "task", false)+ require.NoError(t, err)+ ctx = logger.CloneContext(ctx)+ require.Zero(t, types.CallerFromContext(ctx).TenantID)+ require.NoError(t, RequireKBTransfer(ctx, source, target, KBTransferMove))+ require.ErrorIs(t, RequireKBTransfer(ctx, source, target, KBTransferClone), ErrForbidden)+ require.ErrorIs(+ t,+ RequireKBTransfer(ctx, source, &types.KnowledgeBase{ID: "third", TenantID: 7}, KBTransferMove),+ ErrForbidden,+ )+ require.False(t, HasKBGrant(ctx, "third", 7, types.OrgRoleViewer))+ _, err = WithKBTransferTask(+ ctx,+ source,+ &types.KnowledgeBase{ID: "target", TenantID: 8},+ 7,+ KBTransferMove,+ "task",+ false,+ )+ require.ErrorIs(t, err, ErrForbidden)+ changed := types.WithCaller(ctx, types.Caller{TenantID: 7, UserID: "different"})+ require.ErrorIs(t, RequireKBTransfer(changed, source, target, KBTransferMove), ErrForbidden)+}++func TestTransferAPICapabilitiesRemainSeparate(t *testing.T) {+ source, target := &types.KnowledgeBase{ID: "source", TenantID: 1}, &types.KnowledgeBase{ID: "target", TenantID: 1}+ for _, tc := range []struct {+ operation KBTransferOperation+ capability string+ create bool+ ids []string+ allowed bool+ }{+ {KBTransferClone, "manage_kbs", false, []string{"source", "target"}, true},+ {KBTransferClone, "ingest", false, []string{"source", "target"}, false},+ {KBTransferMove, "ingest", false, []string{"source", "target"}, true},+ {KBTransferMove, "manage_kbs", false, []string{"source", "target"}, false},+ {KBTransferMove, "ingest", false, []string{"source"}, false},+ {KBTransferClone, "manage_kbs", true, []string{"source"}, true},+ } {+ t.Run(+ fmt.Sprintf("%s/%s/create=%v/ids=%d", tc.operation, tc.capability, tc.create, len(tc.ids)),+ func(t *testing.T) {+ ctx, err := WithKBTransferTask(context.Background(), source, target, 1, tc.operation, "task", tc.create)+ require.NoError(t, err)+ ctx = types.WithTenantAPIKeyScope(+ ctx,+ types.TenantAPIKeyScope{Capabilities: types.StringArray{tc.capability}, KnowledgeBaseIDs: tc.ids},+ )+ require.Equal(t, tc.allowed, RequireKBTransfer(ctx, source, target, tc.operation) == nil)+ },+ )+ }+}diff --git a/internal/application/access/kb_write.go b/internal/application/access/kb_write.gonew file mode 100644index 000000000..282f663c1--- /dev/null+++ b/internal/application/access/kb_write.go@@ -0,0 +1,45 @@+package access++import (+ "context"++ "github.com/Tencent/WeKnora/internal/types"+)++// RequireKBWrite consumes an explicit operation grant. Tenant ownership and+// role checks belong to the entry point that resolved the grant; an execution+// tenant alone, or a shared-agent/read grant, never authorizes a mutation.+func RequireKBWrite(ctx context.Context, kb *types.KnowledgeBase) error {+ if kb == nil || kb.ID == "" || kb.TenantID == 0 {+ return ErrNotFound+ }+ if scope, ok := types.TenantAPIKeyScopeFromContext(ctx); ok && !scope.FullAccess &&+ !scope.HasCapability(types.APIKeyCapabilityIngest) {+ return ErrForbidden+ }+ if !HasKBGrant(ctx, kb.ID, kb.TenantID, types.OrgRoleEditor) {+ return ErrForbidden+ }+ return nil+}++// WithKBTaskWrite is for trusted workers continuing an admitted operation.+// The worker supplies a server-loaded KB and verifies its child-resource+// bindings before any side effects. It grants only this KB, preserves the+// original caller (including an absent caller), and never creates an Admin.+// This is a task execution grant, not a way to authorize an incoming request.+func WithKBTaskWrite(ctx context.Context, kb *types.KnowledgeBase, expectedTenant uint64) (context.Context, error) {+ if kb == nil || kb.ID == "" || expectedTenant == 0 || kb.TenantID != expectedTenant {+ return ctx, ErrForbidden+ }+ ctx = types.WithExecutionTenant(ctx, expectedTenant)+ grant := kbGrant{+ caller: types.CallerFromContext(ctx),+ kbID: kb.ID,+ tenantID: expectedTenant,+ permission: types.OrgRoleEditor,+ task: true,+ }+ // A worker gets exactly one scope, without inheriting another task's KBs.+ return context.WithValue(ctx, types.KBGrantsContextKey, []kbGrant{grant}), nil+}diff --git a/internal/application/access/kb_write_test.go b/internal/application/access/kb_write_test.gonew file mode 100644index 000000000..ee6106ed9--- /dev/null+++ b/internal/application/access/kb_write_test.go@@ -0,0 +1,85 @@+package access++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++func TestKBWriteConsumesOperationGrant(t *testing.T) {+ ctx := callerContext()+ kb := &types.KnowledgeBase{ID: "kb", TenantID: types.CallerFromContext(ctx).TenantID}+ read, err := ResolveKB(ctx, KBRequest{Caller: types.CallerFromContext(ctx)}, kb, types.OrgRoleViewer, nil, nil)+ require.NoError(t, err)+ require.Equal(t, types.OrgRoleAdmin, read.Permission, "owner permission projection remains unchanged")+ require.ErrorIs(t, RequireKBWrite(read.Context(ctx), kb), ErrForbidden, "an owner read does not grant mutation")+ require.ErrorIs(t, RequireKBWrite(types.WithExecutionTenant(ctx, kb.TenantID), kb), ErrForbidden)+ write, err := ResolveKB(ctx, KBRequest{Caller: types.CallerFromContext(ctx)}, kb, types.OrgRoleEditor, nil, nil)+ require.NoError(t, err)+ ctx = logger.CloneContext(write.Context(ctx))+ require.NoError(t, RequireKBWrite(ctx, kb))+ require.ErrorIs(t, RequireKBWrite(ctx, &types.KnowledgeBase{ID: "other", TenantID: kb.TenantID}), ErrForbidden)+ require.ErrorIs(t, RequireKBWrite(ctx, &types.KnowledgeBase{ID: kb.ID, TenantID: kb.TenantID + 1}), ErrForbidden)+ for _, tt := range []struct {+ name string+ scope types.TenantAPIKeyScope+ allowed bool+ }{+ {"retrieve only", types.TenantAPIKeyScope{Capabilities: types.StringArray{"retrieve"}}, false},+ {+ "ingest",+ types.TenantAPIKeyScope{+ Capabilities: types.StringArray{"ingest"},+ KnowledgeBaseIDs: types.StringArray{"kb"},+ },+ true,+ },++ {+ "wrong KB",+ types.TenantAPIKeyScope{+ Capabilities: types.StringArray{"ingest"},+ KnowledgeBaseIDs: types.StringArray{"other"},+ },+ false,+ },++ {"full access", types.TenantAPIKeyScope{FullAccess: true}, true},+ } {+ t.Run(tt.name, func(t *testing.T) {+ err := RequireKBWrite(types.WithTenantAPIKeyScope(ctx, tt.scope), kb)+ require.Equal(t, tt.allowed, err == nil)+ })+ }+}++func TestKBTaskWriteIsExplicitAndBounded(t *testing.T) {+ kb := &types.KnowledgeBase{ID: "kb", TenantID: 7}+ base := context.Background()+ ctx, err := WithKBTaskWrite(base, kb, 7)+ require.NoError(t, err)+ ctx = logger.CloneContext(ctx)+ require.Zero(t, types.CallerFromContext(ctx).TenantID, "a worker must not impersonate the tenant owner")+ require.NoError(t, RequireKBWrite(ctx, kb))+ allowed, err := NewKBPermissions(ctx, nil).Check("kb", 7, types.OrgRoleViewer)+ require.NoError(t, err)+ require.True(t, allowed, "a scoped write task can read its KB")+ allowed, err = NewKBPermissions(ctx, nil).Check("other", 7, types.OrgRoleViewer)+ require.NoError(t, err)+ require.False(t, allowed)+ require.ErrorIs(t, RequireKBWrite(ctx, &types.KnowledgeBase{ID: "other", TenantID: 7}), ErrForbidden)+ _, err = WithKBTaskWrite(base, kb, 8)+ require.ErrorIs(t, err, ErrForbidden)+ _, err = WithKBTaskWrite(base, kb, 0)+ require.ErrorIs(t, err, ErrForbidden)+ require.False(t, HasKBGrant(base, "kb", 7, types.OrgRoleEditor), "the parent context stays unmodified")+ request := callerContext()+ task, err := WithKBTaskWrite(request, kb, 7)+ require.NoError(t, err)+ require.Equal(t, types.CallerFromContext(request), types.CallerFromContext(task))+ changed := types.WithCaller(task, types.Caller{TenantID: 99, UserID: "another"})+ require.ErrorIs(t, RequireKBWrite(changed, kb), ErrForbidden)+}diff --git a/internal/application/access/knowledge_state.go b/internal/application/access/knowledge_state.gonew file mode 100644index 000000000..96bdcefa9--- /dev/null+++ b/internal/application/access/knowledge_state.go@@ -0,0 +1,38 @@+package access++import (+ "encoding/json"++ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+)++// RejectMovingKnowledge is shared by admission and persisted service checks.+// Admission prevents misleading task acceptance; workers must recheck after+// enqueue because a move can claim the document in the intervening window.+func RejectMovingKnowledge(knowledge *types.Knowledge) error {+ if knowledge == nil {+ return apperrors.NewNotFoundError("knowledge not found")+ }+ fields := map[string]json.RawMessage{}+ if len(knowledge.Metadata) != 0 {+ if err := json.Unmarshal(knowledge.Metadata, &fields); err != nil {+ return err+ }+ }+ raw := fields[types.KnowledgeTransferMetadataKey]+ if len(raw) == 0 {+ return nil+ }+ var state struct {+ Operation KBTransferOperation `json:"operation"`+ Phase string `json:"phase"`+ }+ if err := json.Unmarshal(raw, &state); err != nil {+ return err+ }+ if state.Operation == KBTransferMove && state.Phase == "moving" {+ return apperrors.NewConflictError("knowledge has an unfinished move; retry the move first")+ }+ return nil+}diff --git a/internal/application/access/knowledgebase.go b/internal/application/access/knowledgebase.gonew file mode 100644index 000000000..4a875aab5--- /dev/null+++ b/internal/application/access/knowledgebase.go@@ -0,0 +1,156 @@+// Package access resolves resource permissions independently of HTTP routing.+// Tenant roles, API-key capabilities, and resource ownership guards remain+// separate checks; a KB grant does not replace them.+package access++import (+ "context"+ "errors"+ "fmt"++ "github.com/Tencent/WeKnora/internal/types"+)++// Resource access errors retain distinct adapter response mappings.+var (+ ErrUnauthorized = errors.New("kb_access: unauthorized")+ ErrNotFound = errors.New("kb_access: not found")+ ErrForbidden = errors.New("kb_access: forbidden")+ ErrInvalidAgentSource = errors.New("kb_access: invalid agent source")+)++// KBRequest keeps the authenticated caller separate from the resource tenant.+// AgentSourceTenantID is parsed only when the explicit-agent fallback is used.+type KBRequest struct {+ Caller types.Caller+ AgentID string+ AgentSourceTenantID string+}++// KBAccess binds a resolved resource permission to its original caller.+type KBAccess struct {+ KnowledgeBase *types.KnowledgeBase+ Caller types.Caller+ EffectiveTenantID uint64+ Permission types.OrgMemberRole+ // A read resolution must not mint a write grant even for the KB owner.+ operationPermission types.OrgMemberRole+}++// Context scopes resource operations without changing the authenticated caller.+func (a *KBAccess) Context(ctx context.Context) context.Context {+ if a == nil || a.KnowledgeBase == nil {+ return ctx+ }+ scoped := a.WithGrant(ctx)+ if types.CallerFromContext(scoped) != a.Caller.Normalize() {+ return ctx+ }+ return types.WithExecutionTenant(scoped, a.EffectiveTenantID)+}++// WithGrant carries this authorization without changing execution scope.+func (a *KBAccess) WithGrant(ctx context.Context) context.Context {+ if a == nil || a.KnowledgeBase == nil {+ return ctx+ }+ caller := a.Caller.Normalize()+ if existing, ok := ctx.Value(types.CallerContextKey).(types.Caller); ok && existing != caller {+ return ctx // A grant cannot replace an already authenticated caller.+ }+ grants, _ := ctx.Value(types.KBGrantsContextKey).([]kbGrant)+ permission := a.Permission+ if a.operationPermission.IsValid() && permission.HasPermission(a.operationPermission) {+ permission = a.operationPermission+ }+ grants = append(+ append([]kbGrant(nil), grants...),+ kbGrant{caller: caller, kbID: a.KnowledgeBase.ID, tenantID: a.EffectiveTenantID, permission: permission},+ )+ return context.WithValue(types.WithCaller(ctx, caller), types.KBGrantsContextKey, grants)+}++// KBShareLookup resolves organization sharing with the caller role cap.+type KBShareLookup interface {+ CheckTenantKBPermission(context.Context, string, uint64, types.TenantRole) (types.OrgMemberRole, bool, error)+}++// SharedAgentLookup verifies access to a particular shared agent.+type SharedAgentLookup interface {+ GetSharedAgentForTenant(context.Context, uint64, types.TenantRole, string, ...uint64) (*types.CustomAgent, error)+}++// AgentShareLookup also supports read access through any reachable agent.+type AgentShareLookup interface {+ SharedAgentLookup+ TenantCanAccessKBViaSomeSharedAgent(context.Context, uint64, types.TenantRole, *types.KnowledgeBase) (bool, error)+}++// ResolveKB authorizes a server-loaded KB (or a document's persisted KB/tenant+// reference). Its tenant is authoritative; resolving the owner from a share+// record again would add a lookup and a second source of truth. It never treats+// an effective resource tenant as the caller.+// Share lookup errors do not grant access; an independent agent grant may still+// allow reading. An explicit agent selector never falls back to another agent.+func ResolveKB(ctx context.Context, request KBRequest, kb *types.KnowledgeBase, required types.OrgMemberRole,+ shares KBShareLookup, agents AgentShareLookup,+) (*KBAccess, error) {+ if request.Caller.TenantID == 0 {+ return nil, ErrUnauthorized+ }+ if kb == nil || kb.ID == "" {+ return nil, ErrNotFound+ }+ if err := types.AuthorizeTenantAPIKeyKnowledgeBases(ctx, kb.ID); err != nil {+ return nil, err+ }+ request.Caller = request.Caller.Normalize()+ if caller, ok := ctx.Value(types.CallerContextKey).(types.Caller); ok && caller != request.Caller {+ return nil, ErrForbidden+ }+ grant := func(permission types.OrgMemberRole) (*KBAccess, error) {+ return &KBAccess{+ KnowledgeBase: kb, Caller: request.Caller,+ EffectiveTenantID: kb.TenantID, Permission: permission, operationPermission: required,+ }, nil+ }+ if kb.TenantID == request.Caller.TenantID {+ return grant(types.OrgRoleAdmin)+ }+ if shares != nil {+ permissions := NewKBSharePermissions(ctx, shares, request.Caller.TenantID, request.Caller.Role)+ permission, shared, err := permissions.Permission(kb.ID)+ if err == nil && shared && permission.HasPermission(required) {+ return grant(permission)+ }+ }+ if required != types.OrgRoleViewer || agents == nil {+ return nil, ErrForbidden+ }+ if request.AgentID != "" {+ source, err := types.ParseAgentSourceTenantID(request.AgentSourceTenantID)+ if err != nil {+ return nil, fmt.Errorf("%w: %s", ErrInvalidAgentSource, err)+ }+ agent, err := agents.GetSharedAgentForTenant(+ ctx,+ request.Caller.TenantID,+ request.Caller.Role,+ request.AgentID,+ source,+ )+ if err == nil && types.SharedAgentIncludesKB(agent, kb) {+ return grant(types.OrgRoleViewer)+ }+ } else {+ allowed,+ err := agents.TenantCanAccessKBViaSomeSharedAgent(ctx,+ request.Caller.TenantID,+ request.Caller.Role,+ kb)+ if err == nil && allowed {+ return grant(types.OrgRoleViewer)+ }+ }+ return nil, ErrForbidden+}diff --git a/internal/application/access/knowledgebase_test.go b/internal/application/access/knowledgebase_test.gonew file mode 100644index 000000000..a29f81c52--- /dev/null+++ b/internal/application/access/knowledgebase_test.go@@ -0,0 +1,282 @@+package access++import (+ "context"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++type shareLookup struct {+ permission types.OrgMemberRole+ err error+ caller uint64+ role types.TenantRole+}++func (s *shareLookup) CheckTenantKBPermission(+ _ context.Context,+ _ string,+ caller uint64,+ role types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ s.caller, s.role = caller, role+ return s.permission, s.permission != "", s.err+}++type agentLookup struct {+ agent *types.CustomAgent+ any bool+ err error+ anyCalls int+ source uint64+}++func (s *agentLookup) GetSharedAgentForTenant(+ _ context.Context,+ _ uint64,+ _ types.TenantRole,+ _ string,+ source ...uint64,+) (*types.CustomAgent, error) {+ s.source = source[0]+ return s.agent, s.err+}++func (s *agentLookup) TenantCanAccessKBViaSomeSharedAgent(+ context.Context,+ uint64,+ types.TenantRole,+ *types.KnowledgeBase,+) (bool, error) {+ s.anyCalls+++ return s.any, s.err+}++func TestResolveKBPermissionMatrix(t *testing.T) {+ for _, tt := range []struct {+ name string+ own bool+ permission types.OrgMemberRole+ required types.OrgMemberRole+ shareError bool+ agentID, source, mode string+ selected []string+ wrongTenant, missingAgent, agentError, anyAgent bool+ want types.OrgMemberRole+ wantErr error+ }{+ {name: "own KB", own: true, required: types.OrgRoleEditor, want: types.OrgRoleAdmin},+ {+ name: "organization reader",+ permission: types.OrgRoleViewer,+ required: types.OrgRoleViewer,+ want: types.OrgRoleViewer,+ },++ {+ name: "organization editor",+ permission: types.OrgRoleEditor,+ required: types.OrgRoleEditor,+ want: types.OrgRoleEditor,+ },++ {+ name: "reader cannot write",+ permission: types.OrgRoleViewer,+ required: types.OrgRoleEditor,+ wantErr: ErrForbidden,+ },++ {+ name: "share lookup fails closed",+ permission: types.OrgRoleEditor,+ shareError: true,+ required: types.OrgRoleViewer,+ wantErr: ErrForbidden,+ },++ {+ name: "independent agent grant after share error",+ shareError: true,+ anyAgent: true,+ required: types.OrgRoleViewer,+ want: types.OrgRoleViewer,+ },++ {name: "any shared agent read", anyAgent: true, required: types.OrgRoleViewer, want: types.OrgRoleViewer},+ {name: "any agent cannot write", anyAgent: true, required: types.OrgRoleEditor, wantErr: ErrForbidden},+ {+ name: "agent lookup error",+ anyAgent: true,+ agentError: true,+ required: types.OrgRoleViewer,+ wantErr: ErrForbidden,+ },++ {+ name: "explicit all",+ agentID: "agent",+ source: "2",+ mode: "all",+ required: types.OrgRoleViewer,+ want: types.OrgRoleViewer,+ },++ {+ name: "explicit selected",+ agentID: "agent",+ mode: "selected",+ selected: []string{"kb"},+ required: types.OrgRoleViewer,+ want: types.OrgRoleViewer,+ },++ {+ name: "selection miss does not fall back",+ agentID: "agent",+ mode: "selected",+ selected: []string{"other"},+ anyAgent: true,+ required: types.OrgRoleViewer,+ wantErr: ErrForbidden,+ },++ {+ name: "none does not fall back",+ agentID: "agent",+ mode: "none",+ anyAgent: true,+ required: types.OrgRoleViewer,+ wantErr: ErrForbidden,+ },++ {+ name: "unknown mode denied",+ agentID: "agent",+ mode: "invalid",+ required: types.OrgRoleViewer,+ wantErr: ErrForbidden,+ },++ {+ name: "tenant mismatch denied",+ agentID: "agent",+ mode: "all",+ wrongTenant: true,+ required: types.OrgRoleViewer,+ wantErr: ErrForbidden,+ },++ {+ name: "missing explicit agent does not fall back",+ agentID: "agent",+ missingAgent: true,+ anyAgent: true,+ required: types.OrgRoleViewer,+ wantErr: ErrForbidden,+ },++ {+ name: "invalid source rejected",+ agentID: "agent",+ source: "bad",+ mode: "all",+ required: types.OrgRoleViewer,+ wantErr: ErrInvalidAgentSource,+ },++ {+ name: "own grant precedes agent parsing",+ own: true,+ agentID: "agent",+ source: "bad",+ required: types.OrgRoleViewer,+ want: types.OrgRoleAdmin,+ },++ {+ name: "share grant precedes agent parsing",+ permission: types.OrgRoleViewer,+ agentID: "agent",+ source: "bad",+ required: types.OrgRoleViewer,+ want: types.OrgRoleViewer,+ },+ } {+ t.Run(tt.name, func(t *testing.T) {+ kb := &types.KnowledgeBase{ID: "kb", TenantID: 2}+ if tt.own {+ kb.TenantID = 1+ }+ shares := &shareLookup{permission: tt.permission}+ if tt.shareError {+ shares.err = errors.New("unavailable")+ }+ agents := &agentLookup{+ any: tt.anyAgent,+ agent: &types.CustomAgent{+ TenantID: 2,+ Config: types.CustomAgentConfig{KBSelectionMode: tt.mode, KnowledgeBases: tt.selected},+ },+ }+ if tt.wrongTenant {+ agents.agent.TenantID = 3+ }+ if tt.missingAgent {+ agents.agent = nil+ }+ if tt.agentError {+ agents.err = errors.New("unavailable")+ }+ request := KBRequest{+ Caller: types.Caller{TenantID: 1, Role: types.TenantRoleViewer},+ AgentID: tt.agentID,+ AgentSourceTenantID: tt.source,+ }+ grant, err := ResolveKB(context.Background(), request, kb, tt.required, shares, agents)+ if tt.wantErr != nil {+ require.ErrorIs(t, err, tt.wantErr)+ require.Nil(t, grant)+ } else {+ require.NoError(t, err)+ require.Equal(t, tt.want, grant.Permission)+ require.Equal(t, uint64(1), grant.Caller.TenantID)+ require.Equal(t, kb.TenantID, grant.EffectiveTenantID)+ }+ if !tt.own {+ require.Equal(t, uint64(1), shares.caller)+ require.Equal(t, types.TenantRoleViewer, shares.role)+ }+ if tt.agentID != "" {+ require.Zero(t, agents.anyCalls)+ }+ if tt.source == "2" {+ require.Equal(t, uint64(2), agents.source)+ }+ })+ }+}++func TestResolveKBMissingIdentityResourceAndAPIKeyScope(t *testing.T) {+ kb := &types.KnowledgeBase{ID: "kb", TenantID: 1}+ _, err := ResolveKB(context.Background(), KBRequest{}, kb, types.OrgRoleViewer, nil, nil)+ require.ErrorIs(t, err, ErrUnauthorized)+ _, err = ResolveKB(+ context.Background(),+ KBRequest{Caller: types.Caller{TenantID: 1}},+ nil,+ types.OrgRoleViewer,+ nil,+ nil,+ )+ require.ErrorIs(t, err, ErrNotFound)+ ctx := types.WithTenantAPIKeyScope(+ context.Background(),+ types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"other"}},+ )+ _, err = ResolveKB(ctx, KBRequest{Caller: types.Caller{TenantID: 1}}, kb, types.OrgRoleViewer, nil, nil)+ require.Error(t, err, "API key scope must apply even to owned KBs")+}diff --git a/internal/application/access/message_files.go b/internal/application/access/message_files.gonew file mode 100644index 000000000..7f7d6bd11--- /dev/null+++ b/internal/application/access/message_files.go@@ -0,0 +1,249 @@+package access++import (+ "context"+ "strings"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+)++// MessageFileLookup is the narrow message-service surface needed by the+// message-scoped file proxy. Keeping it small makes the authorization boundary+// independently testable.+type MessageFileLookup interface {+ GetMessage(ctx context.Context, sessionID, messageID string) (*types.Message, error)+}++// SharedAgentFileLookup verifies that a source workspace's agent is still+// shared to the caller. Revoking the share therefore also revokes historical+// message-file access.+type SharedAgentFileLookup interface {+ GetSharedAgentForTenant(+ ctx context.Context,+ tenantID uint64,+ callerTenantRole types.TenantRole,+ agentID string,+ sourceTenantID ...uint64,+ ) (*types.CustomAgent, error)+}++// KBSharePermissionGuard is the org-share surface the message-scoped proxy+// needs for its shared-KB fallback.+type KBSharePermissionGuard = KBShareLookup++// KBTenantLookup resolves knowledge bases without a tenant filter, so a+// message's persisted retrieval evidence can be mapped back to the knowledge+// bases the chunks were retrieved from.+type KBTenantLookup interface {+ GetKnowledgeBasesByIDsOnly(ctx context.Context, ids []string) ([]*types.KnowledgeBase, error)+}++// KnowledgeOwnerLookup resolves a knowledge entry to its knowledge base for+// message references that predate the denormalized knowledge_base_id field.+type KnowledgeOwnerLookup interface {+ GetKnowledgeByIDOnly(ctx context.Context, id string) (*types.Knowledge, error)+}++// MessageKBShareAuthorizer bundles the read-only lookups behind the+// message proxy's org-shared-KB fallback. A nil ShareGuard or KBs lookup+// disables the fallback. A live Bindings lookup is also required and can+// be supplied by the resource catalog. A nil Knowledges lookup only disables the+// pre-denormalization KnowledgeID path.+type MessageKBShareAuthorizer struct {+ ShareGuard KBSharePermissionGuard+ KBs KBTenantLookup+ Knowledges KnowledgeOwnerLookup+ Bindings interfaces.KBResourceLookup+}++// resourceAccessibleViaSharedKB reports whether the message's persisted+// retrieval evidence proves the resource came from an org-shared KB the+// caller may read. This is the fallback for replies whose agent belongs to+// the caller's own workspace while the retrieved resources belong to the+// workspace that shared the knowledge base (#3022).+//+// Evidence required from one retrieval record: a canonical resource://+// handle (not a prefix of a longer token) appears in the chunk text or+// image_info, its knowledge base belongs to the resource's tenant, and+// that KB is org-shared to the caller with at least viewer permission, and+// an independent live resource binding confirms the file still belongs to it.+// Smart-reasoning turns persist that evidence on AgentSteps when+// KnowledgeReferences was never filled. Any lookup failure fails closed.+func (a MessageKBShareAuthorizer) resourceAccessibleViaSharedKB(+ ctx context.Context,+ message *types.Message,+ resource *types.StoredResource,+ callerTenantID uint64,+ callerTenantRole types.TenantRole,+) bool {+ if a.ShareGuard == nil || a.KBs == nil || a.Bindings == nil || message == nil || resource == nil {+ return false+ }+ handle, ok := types.ParseResourcePath(types.BuildResourcePath(resource.Handle))+ if !ok {+ return false+ }++ kbIDs := a.collectSharedKBEvidenceIDs(ctx, message, handle)+ if len(kbIDs) == 0 {+ return false+ }++ kbs, err := a.KBs.GetKnowledgeBasesByIDsOnly(ctx, kbIDs)+ if err != nil {+ return false+ }+ permissions := NewKBSharePermissions(ctx, a.ShareGuard, callerTenantID, callerTenantRole)+ for _, kb := range kbs {+ if kb == nil || kb.TenantID != resource.TenantID {+ continue+ }+ shared, err := permissions.Check(kb.ID, types.OrgRoleViewer)+ if err == nil && shared {+ bound, bindingErr := a.Bindings.IsReferencedByKnowledgeBase(+ ctx, resource.TenantID, kb.ID, types.BuildResourcePath(handle))+ if bindingErr == nil && bound {+ return true+ }+ }+ }+ return false+}++func (a MessageKBShareAuthorizer) collectSharedKBEvidenceIDs(+ ctx context.Context,+ message *types.Message,+ handle string,+) []string {+ seenKB := make(map[string]bool)+ seenKnowledge := make(map[string]bool)+ var kbIDs, knowledgeIDs []string+ addKB := func(id string) {+ if id == "" || seenKB[id] {+ return+ }+ seenKB[id] = true+ kbIDs = append(kbIDs, id)+ }+ addKnowledge := func(id string) {+ if id == "" || seenKnowledge[id] {+ return+ }+ seenKnowledge[id] = true+ knowledgeIDs = append(knowledgeIDs, id)+ }++ for _, ref := range message.KnowledgeReferences {+ if !searchResultHasResourceHandle(ref, handle) {+ continue+ }+ if ref.KnowledgeBaseID != "" {+ addKB(ref.KnowledgeBaseID)+ continue+ }+ addKnowledge(ref.KnowledgeID)+ }+ collectKBEvidenceFromValue(message.AgentSteps, handle, "", "", addKB, addKnowledge)++ if a.Knowledges != nil {+ for _, knowledgeID := range knowledgeIDs {+ knowledge, err := a.Knowledges.GetKnowledgeByIDOnly(ctx, knowledgeID)+ if err != nil || knowledge == nil {+ continue+ }+ addKB(knowledge.KnowledgeBaseID)+ }+ }+ return kbIDs+}++func searchResultHasResourceHandle(ref *types.SearchResult, handle string) bool {+ if ref == nil {+ return false+ }+ return textHasResourceHandle(ref.Content, handle) ||+ textHasResourceHandle(ref.MatchedContent, handle) ||+ textHasResourceHandle(ref.ImageInfo, handle)+}++func textHasResourceHandle(text, handle string) bool {+ if text == "" || handle == "" {+ return false+ }+ want := types.BuildResourcePath(handle)+ for _, ref := range types.ScanResourceReferences(text) {+ if ref == want {+ return true+ }+ }+ return false+}++func collectKBEvidenceFromValue(+ v interface{},+ handle, kbID, knowledgeID string,+ addKB, addKnowledge func(string),+) {+ switch val := v.(type) {+ case string:+ if !textHasResourceHandle(val, handle) {+ return+ }+ if kbID != "" {+ addKB(kbID)+ return+ }+ addKnowledge(knowledgeID)+ case types.AgentSteps:+ for _, step := range val {+ collectKBEvidenceFromValue(step, handle, kbID, knowledgeID, addKB, addKnowledge)+ }+ case types.AgentStep:+ collectKBEvidenceFromValue(val.ToolCalls, handle, kbID, knowledgeID, addKB, addKnowledge)+ case []types.ToolCall:+ for _, call := range val {+ collectKBEvidenceFromValue(call, handle, kbID, knowledgeID, addKB, addKnowledge)+ }+ case types.ToolCall:+ if val.Result != nil {+ collectKBEvidenceFromValue(val.Result.Output, handle, kbID, knowledgeID, addKB, addKnowledge)+ collectKBEvidenceFromValue(val.Result.Data, handle, kbID, knowledgeID, addKB, addKnowledge)+ }+ case map[string]interface{}:+ nextKB := firstNonEmptyString(+ stringFromAnyMap(val, "knowledge_base_id"),+ stringFromAnyMap(val, "knowledge_base"),+ kbID,+ )+ nextKnowledge := firstNonEmptyString(stringFromAnyMap(val, "knowledge_id"), knowledgeID)+ for _, nested := range val {+ collectKBEvidenceFromValue(nested, handle, nextKB, nextKnowledge, addKB, addKnowledge)+ }+ case []interface{}:+ for _, item := range val {+ collectKBEvidenceFromValue(item, handle, kbID, knowledgeID, addKB, addKnowledge)+ }+ case []map[string]interface{}:+ for _, item := range val {+ collectKBEvidenceFromValue(item, handle, kbID, knowledgeID, addKB, addKnowledge)+ }+ }+}++func stringFromAnyMap(m map[string]interface{}, key string) string {+ if m == nil {+ return ""+ }+ s, _ := m[key].(string)+ return strings.TrimSpace(s)+}++func firstNonEmptyString(values ...string) string {+ for _, value := range values {+ if strings.TrimSpace(value) != "" {+ return strings.TrimSpace(value)+ }+ }+ return ""+}diff --git a/internal/application/access/ownership.go b/internal/application/access/ownership.gonew file mode 100644index 000000000..29efc876c--- /dev/null+++ b/internal/application/access/ownership.go@@ -0,0 +1,69 @@+package access++import (+ "errors"++ "github.com/Tencent/WeKnora/internal/types"+)++var (+ // ErrResourceNotFound means the ownership lookup found no resource visible+ // in the caller's tenant. HTTP adapters decide how to produce the 404.+ ErrResourceNotFound = errors.New("rbac: resource not found")+ // ErrOwnershipForbidden indicates neither ownership nor the required role.+ ErrOwnershipForbidden = errors.New("rbac: ownership or role insufficient")+)++// OwnershipRequest carries server-resolved identity and rollout policy. The+// cross-tenant bypass must already account for the cluster configuration.+// This gate does not replace API-key capabilities or resource-scope checks.+type OwnershipRequest struct {+ UserID string+ Role types.TenantRole+ APIKey bool+ CrossTenantSuperuser bool+ Enforce bool+}++// OwnershipDecision contains the details adapters need for logs and audits.+// The error returned with it determines whether access was allowed.+type OwnershipDecision struct {+ CreatorID string+ EnforcementSkipped bool+ LookupFailed bool+}++// CheckOwnershipOrRole performs no resource lookup when API-key authorization,+// role, superuser status, or the RBAC rollout policy already settles the gate.+// The lookup must enforce tenant visibility before returning a creator ID.+func CheckOwnershipOrRole(+ request OwnershipRequest,+ required types.TenantRole,+ lookup func() (string, error),+) (OwnershipDecision, error) {+ var decision OwnershipDecision+ if request.APIKey || request.Role.HasPermission(required) || request.CrossTenantSuperuser {+ return decision, nil+ }+ if !request.Enforce {+ decision.EnforcementSkipped = true+ return decision, nil+ }+ if lookup == nil {+ decision.LookupFailed = true+ return decision, errors.New("rbac: creator lookup unavailable")+ }+ creator, err := lookup()+ decision.CreatorID = creator+ if errors.Is(err, ErrResourceNotFound) {+ return decision, ErrResourceNotFound+ }+ if err != nil {+ decision.LookupFailed = true+ return decision, err+ }+ if creator != "" && creator == request.UserID {+ return decision, nil+ }+ return decision, ErrOwnershipForbidden+}diff --git a/internal/application/access/ownership_test.go b/internal/application/access/ownership_test.gonew file mode 100644index 000000000..77806b649--- /dev/null+++ b/internal/application/access/ownership_test.go@@ -0,0 +1,103 @@+package access++import (+ "errors"+ "fmt"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++func TestCheckOwnershipOrRoleSkipsLookupWhenGateAlreadyResolved(t *testing.T) {+ for _, tt := range []struct {+ name string+ request OwnershipRequest+ skipped bool+ }{+ {name: "API key", request: OwnershipRequest{APIKey: true, Role: types.TenantRoleViewer, Enforce: true}},+ {name: "admin", request: OwnershipRequest{Role: types.TenantRoleAdmin, Enforce: true}},+ {name: "owner role", request: OwnershipRequest{Role: types.TenantRoleOwner, Enforce: true}},+ {+ name: "cross tenant superuser",+ request: OwnershipRequest{+ Role: types.TenantRoleViewer,+ CrossTenantSuperuser: true,+ Enforce: true,+ },+ },++ {name: "enforcement disabled", request: OwnershipRequest{Role: types.TenantRoleViewer}, skipped: true},+ {name: "role before rollout", request: OwnershipRequest{Role: types.TenantRoleAdmin}},+ } {+ t.Run(tt.name, func(t *testing.T) {+ decision, err := CheckOwnershipOrRole(tt.request, types.TenantRoleAdmin, func() (string, error) {+ t.Fatal("ownership lookup must not run on a fast path")+ return "", errors.New("unavailable")+ })+ require.NoError(t, err)+ require.Equal(t, tt.skipped, decision.EnforcementSkipped)+ require.False(t, decision.LookupFailed)+ })+ }+}++func TestCheckOwnershipOrRoleResolvesCreator(t *testing.T) {+ failure := errors.New("database unavailable")+ for _, tt := range []struct {+ name, user, creator string+ lookupErr, wantErr error+ lookupFailed bool+ }{+ {name: "creator", user: "user", creator: "user"},+ {name: "other creator", user: "user", creator: "other", wantErr: ErrOwnershipForbidden},+ {name: "tenant owned", user: "user", wantErr: ErrOwnershipForbidden},+ {name: "missing identity cannot match empty creator", wantErr: ErrOwnershipForbidden},+ {name: "missing resource", user: "user", lookupErr: ErrResourceNotFound, wantErr: ErrResourceNotFound},+ {+ name: "wrapped missing resource",+ user: "user",+ lookupErr: fmt.Errorf("load: %w",+ ErrResourceNotFound),+ wantErr: ErrResourceNotFound,+ },++ {+ name: "lookup failure wins over creator match",+ user: "user",+ creator: "user",+ lookupErr: failure,+ wantErr: failure,+ lookupFailed: true,+ },++ {+ name: "lookup denial remains a lookup failure",+ lookupErr: ErrOwnershipForbidden,+ wantErr: ErrOwnershipForbidden,+ lookupFailed: true,+ },+ } {+ t.Run(tt.name, func(t *testing.T) {+ calls := 0+ decision, err := CheckOwnershipOrRole(+ OwnershipRequest{UserID: tt.user, Role: types.TenantRoleContributor, Enforce: true},+ types.TenantRoleAdmin,+ func() (string, error) {+ calls+++ return tt.creator, tt.lookupErr+ },+ )+ require.Equal(t, 1, calls)+ require.ErrorIs(t, err, tt.wantErr)+ require.Equal(t, tt.creator, decision.CreatorID)+ require.Equal(t, tt.lookupFailed, decision.LookupFailed)+ })+ }+}++func TestCheckOwnershipOrRoleMissingLookupFailsClosed(t *testing.T) {+ decision, err := CheckOwnershipOrRole(OwnershipRequest{Enforce: true}, types.TenantRoleAdmin, nil)+ require.Error(t, err)+ require.True(t, decision.LookupFailed)+}diff --git a/internal/application/repository/chunk.go b/internal/application/repository/chunk.goindex ccb9fe871..d06c83cf7 100644--- a/internal/application/repository/chunk.go+++ b/internal/application/repository/chunk.go@@ -575,7 +575,7 @@ func (r *chunkRepository) DeleteByKnowledgeList(ctx context.Context, tenantID uifunc (r *chunkRepository) MoveChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string, targetKBID string) error {return r.db.WithContext(ctx).Model(&types.Chunk{}).Where("tenant_id = ? AND knowledge_id = ?", tenantID, knowledgeID).- Update("knowledge_base_id", targetKBID).Error+ Updates(map[string]any{"knowledge_base_id": targetKBID, "tag_id": ""}).Error}// DeleteChunksByTagID deletes all chunks with the specified tag ID@@ -953,30 +953,22 @@ func (r *chunkRepository) UpdateChunkFieldsByTagID(newTagID *string,excludeIDs []string,) ([]string, error) {- // First, get the IDs of chunks that will be affected (for is_enabled sync)+ if isEnabled == nil && setFlags == 0 && clearFlags == 0 && newTagID == nil {+ return nil, nil+ }+ // Return every affected entry, including tag-only and flag-only changes.+ // Callers use these IDs for index synchronization and subsequent patches.var affectedIDs []string- if isEnabled != nil {- var chunks []*types.Chunk- query := r.db.WithContext(ctx).- Select("id").- Where("tenant_id = ? AND knowledge_base_id = ? AND chunk_type = ?",- tenantID, kbID, types.ChunkTypeFAQ)- if tagID != "" {- query = query.Where("tag_id = ?", tagID)- }-- if len(excludeIDs) > 0 {- query = query.Where("id NOT IN ?", excludeIDs)- }-- // Only get chunks that need to change- query = query.Where("is_enabled != ?", *isEnabled)- if err := query.Find(&chunks).Error; err != nil {- return nil, err- }- for _, c := range chunks {- affectedIDs = append(affectedIDs, c.ID)- }+ selection := r.db.WithContext(ctx).Model(&types.Chunk{}).+ Where("tenant_id = ? AND knowledge_base_id = ? AND chunk_type = ?", tenantID, kbID, types.ChunkTypeFAQ)+ if tagID != "" {+ selection = selection.Where("tag_id = ?", tagID)+ }+ if len(excludeIDs) > 0 {+ selection = selection.Where("id NOT IN ?", excludeIDs)+ }+ if err := selection.Pluck("id", &affectedIDs).Error; err != nil {+ return nil, err}// Build update query@@ -1309,3 +1301,17 @@ func (r *chunkRepository) ListRecentDocumentChunksWithQuestions(return chunks, nil}++func (r *chunkRepository) ListAllChunksByKnowledgeID(+ ctx context.Context,+ tenantID uint64,+ knowledgeID string,+) ([]*types.Chunk, error) {+ var chunks []*types.Chunk+ err := r.db.WithContext(ctx).+ Where("tenant_id = ? AND knowledge_id = ?", tenantID, knowledgeID).+ Order("id ASC").+ Find(&chunks).+ Error+ return chunks, err+}diff --git a/internal/application/repository/chunk_fields_test.go b/internal/application/repository/chunk_fields_test.gonew file mode 100644index 000000000..f8a9be271--- /dev/null+++ b/internal/application/repository/chunk_fields_test.go@@ -0,0 +1,60 @@+package repository++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++func TestTagFieldUpdatesReturnAllAffectedChunks(t *testing.T) {+ for _, flagsOnly := range []bool{false, true} {+ name := "tag only"+ if flagsOnly {+ name = "flags only"+ }+ t.Run(name, func(t *testing.T) {+ db := setupChunkTestDB(t)+ repo := NewChunkRepository(db)+ for _, chunk := range []*types.Chunk{+ {ID: "selected", TenantID: 7, KnowledgeBaseID: "kb", ChunkType: types.ChunkTypeFAQ, TagID: "tag"},+ {ID: "excluded", TenantID: 7, KnowledgeBaseID: "kb", ChunkType: types.ChunkTypeFAQ, TagID: "tag"},+ {ID: "other-kb", TenantID: 7, KnowledgeBaseID: "other", ChunkType: types.ChunkTypeFAQ, TagID: "tag"},+ {ID: "other-tenant", TenantID: 8, KnowledgeBaseID: "kb", ChunkType: types.ChunkTypeFAQ, TagID: "tag"},+ {ID: "deleted", TenantID: 7, KnowledgeBaseID: "kb", ChunkType: types.ChunkTypeFAQ, TagID: "tag"},+ } {+ require.NoError(t, db.Create(chunk).Error)+ }+ require.NoError(t, db.Delete(&types.Chunk{ID: "deleted"}).Error)+ next := "next"+ var tag *string+ var flags types.ChunkFlags+ if flagsOnly {+ flags = types.ChunkFlagRecommended+ } else {+ tag = &next+ }+ ids, err := repo.UpdateChunkFieldsByTagID(+ context.Background(),+ 7,+ "kb",+ "tag",+ nil,+ flags,+ 0,+ tag,+ []string{"excluded"},+ )+ require.NoError(t, err)+ require.Equal(t, []string{"selected"}, ids)+ selected, err := repo.GetChunkByID(context.Background(), 7, "selected")+ require.NoError(t, err)+ if flagsOnly {+ require.True(t, selected.Flags.HasFlag(types.ChunkFlagRecommended))+ } else {+ require.Equal(t, "next", selected.TagID)+ }+ })+ }+}diff --git a/internal/application/repository/knowledge.go b/internal/application/repository/knowledge.goindex 065912c69..db94133e7 100644--- a/internal/application/repository/knowledge.go+++ b/internal/application/repository/knowledge.go@@ -560,15 +560,20 @@ func (r *knowledgeRepository) UpdateKnowledgeColumns(// to normal queries and have not moved out of the transient deleting state.func (r *knowledgeRepository) UpdateActiveDeletingKnowledgeColumns(ctx context.Context,- id string,+ tenantID uint64,+ kbID, id string,values map[string]interface{},) (bool, error) {- if len(values) == 0 {+ if tenantID == 0 || kbID == "" || len(values) == 0 {return false, nil}result := r.db.WithContext(ctx).Model(&types.Knowledge{}).- Where("id = ? AND parse_status = ?", id, types.ParseStatusDeleting).+ Where("tenant_id = ? AND knowledge_base_id = ? AND id = ? AND parse_status = ?",+ tenantID,+ kbID,+ id,+ types.ParseStatusDeleting).Updates(values)if result.Error != nil {return false, result.Errordiff --git a/internal/application/repository/knowledge_finalize_test.go b/internal/application/repository/knowledge_finalize_test.goindex abcb68a97..501ea8a6a 100644--- a/internal/application/repository/knowledge_finalize_test.go+++ b/internal/application/repository/knowledge_finalize_test.go@@ -353,22 +353,63 @@ func TestUpdateActiveDeletingKnowledgeColumns_GuardsStateAndSoftDelete(t *testinactiveCompletedID := insertKnowledgeWithStatus(t, db, types.ParseStatusCompleted, false)deletedDeletingID := insertKnowledgeWithStatus(t, db, types.ParseStatusDeleting, true)- updated, err := repo.UpdateActiveDeletingKnowledgeColumns(ctx, activeDeletingID, map[string]interface{}{- "parse_status": types.ParseStatusFailed,- "error_message": "delete task exhausted retries",- })+ require.NoError(+ t,+ db.Exec(+ "UPDATE knowledges SET knowledge_base_id = ? WHERE id IN ?",+ "delete-kb",+ []string{activeDeletingID, activeCompletedID, deletedDeletingID},+ ).Error,+ )+ for _, scope := range []struct {+ tenant uint64+ kb string+ }{{2, "delete-kb"}, {1, "other-kb"}, {0, "delete-kb"}, {1, ""}} {+ updated, err := repo.UpdateActiveDeletingKnowledgeColumns(+ ctx,+ scope.tenant,+ scope.kb,+ activeDeletingID,+ map[string]interface{}{"parse_status": types.ParseStatusFailed},+ )+ require.NoError(t, err)+ require.False(t, updated)+ }++ updated, err := repo.UpdateActiveDeletingKnowledgeColumns(+ ctx,+ 1,+ "delete-kb",+ activeDeletingID,+ map[string]interface{}{+ "parse_status": types.ParseStatusFailed,+ "error_message": "delete task exhausted retries",+ },+ )require.NoError(t, err)assert.True(t, updated)- updated, err = repo.UpdateActiveDeletingKnowledgeColumns(ctx, activeCompletedID, map[string]interface{}{- "parse_status": types.ParseStatusFailed,- })+ updated, err = repo.UpdateActiveDeletingKnowledgeColumns(+ ctx,+ 1,+ "delete-kb",+ activeCompletedID,+ map[string]interface{}{+ "parse_status": types.ParseStatusFailed,+ },+ )require.NoError(t, err)assert.False(t, updated)- updated, err = repo.UpdateActiveDeletingKnowledgeColumns(ctx, deletedDeletingID, map[string]interface{}{- "parse_status": types.ParseStatusFailed,- })+ updated, err = repo.UpdateActiveDeletingKnowledgeColumns(+ ctx,+ 1,+ "delete-kb",+ deletedDeletingID,+ map[string]interface{}{+ "parse_status": types.ParseStatusFailed,+ },+ )require.NoError(t, err)assert.False(t, updated)diff --git a/internal/application/repository/knowledge_list_filter_test.go b/internal/application/repository/knowledge_list_filter_test.goindex a32836221..364e7b6ef 100644--- a/internal/application/repository/knowledge_list_filter_test.go+++ b/internal/application/repository/knowledge_list_filter_test.go@@ -84,7 +84,7 @@ func TestGetKnowledgeBatch_TracksDeletionUntilSoftDelete(t *testing.T) {assert.Equal(t, id, rows[0].ID)assert.Equal(t, types.ParseStatusDeleting, rows[0].ParseStatus)- updated, err := repo.UpdateActiveDeletingKnowledgeColumns(ctx, id, map[string]interface{}{+ updated, err := repo.UpdateActiveDeletingKnowledgeColumns(ctx, 1, kbID, id, map[string]interface{}{"parse_status": types.ParseStatusFailed,})require.NoError(t, err)diff --git a/internal/application/repository/knowledge_transfer.go b/internal/application/repository/knowledge_transfer.gonew file mode 100644index 000000000..99b120786--- /dev/null+++ b/internal/application/repository/knowledge_transfer.go@@ -0,0 +1,74 @@+package repository++import (+ "context"+ "fmt"+ "time"++ "github.com/Tencent/WeKnora/internal/types"+ "gorm.io/gorm"+)++// UpdateKnowledgeForTransfer is a compare-and-swap checkpoint. Full-row Save+// could resurrect a deleted document or overwrite a concurrently moved row.+// Accounting changes are committed with the checkpoint, making retry cleanup+// safe even if the worker crashes between the database and queue operations.+func (r *knowledgeRepository) UpdateKnowledgeForTransfer(ctx context.Context, before, after *types.Knowledge) error {+ if before == nil || after == nil || before.ID == "" || before.ID != after.ID || before.TenantID == 0 ||+ before.TenantID != after.TenantID {+ return fmt.Errorf("invalid knowledge transfer checkpoint")+ }+ // PostgreSQL persists timestamps at microsecond precision. Keep the returned+ // checkpoint identical to storage so the next CAS in this task can match it.+ after.UpdatedAt = time.Now().UTC().Truncate(time.Microsecond)+ var storedUpdatedAt time.Time+ err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ result := tx.Model(&types.Knowledge{}).+ Where("id = ? AND tenant_id = ? AND knowledge_base_id = ? AND parse_status = ? AND "++ "updated_at = ?",+ before.ID,+ before.TenantID,+ before.KnowledgeBaseID,+ before.ParseStatus,+ before.UpdatedAt).+ Updates(map[string]any{+ "knowledge_base_id": after.KnowledgeBaseID, "parse_status": after.ParseStatus,+ "metadata": after.Metadata, "storage_size": after.StorageSize, "updated_at": after.UpdatedAt,+ "enable_status": after.EnableStatus, "embedding_model_id": after.EmbeddingModelID,+ "description": after.Description,+ "processed_at": after.ProcessedAt,+ "error_message": after.ErrorMessage,+ })+ if result.Error != nil {+ return result.Error+ }+ if result.RowsAffected != 1 {+ return fmt.Errorf("knowledge changed during transfer")+ }+ delta := after.StorageSize - before.StorageSize+ if delta != 0 {+ result := tx.Model(&types.Tenant{}).Where("id = ?", before.TenantID).+ UpdateColumn("storage_used",+ gorm.Expr("CASE WHEN storage_used + ? < 0 THEN 0 ELSE storage_used + ? END",+ delta,+ delta))+ if result.Error != nil {+ return result.Error+ }+ if result.RowsAffected != 1 {+ return fmt.Errorf("transfer tenant not found")+ }+ }+ var stored struct{ UpdatedAt time.Time }+ if err := tx.Model(&types.Knowledge{}).Select("updated_at").+ Where("id = ? AND tenant_id = ?", after.ID, after.TenantID).Take(&stored).Error; err != nil {+ return err+ }+ storedUpdatedAt = stored.UpdatedAt+ return nil+ })+ if err == nil {+ after.UpdatedAt = storedUpdatedAt+ }+ return err+}diff --git a/internal/application/repository/knowledge_transfer_test.go b/internal/application/repository/knowledge_transfer_test.gonew file mode 100644index 000000000..d5664f094--- /dev/null+++ b/internal/application/repository/knowledge_transfer_test.go@@ -0,0 +1,30 @@+package repository++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++func TestTransferCheckpointReturnsStoredTimestampPrecision(t *testing.T) {+ db := setupKnowledgeTestDB(t)+ // Emulate a database that stores fewer fractional digits than time.Now.+ require.NoError(t, db.Exec(`CREATE TRIGGER truncate_checkpoint_time AFTER UPDATE ON knowledges+ BEGIN UPDATE knowledges SET updated_at = strftime('%Y-%m-%d %H:%M:%S', NEW.updated_at) || '+00:00'+ WHERE id = NEW.id; END`).Error)+ row := &types.Knowledge{ID: "doc", TenantID: 7, KnowledgeBaseID: "source", ParseStatus: types.ParseStatusCompleted}+ require.NoError(t, db.Omit("custom_metadata").Create(row).Error)+ repo := NewKnowledgeRepository(db)+ before, err := repo.GetKnowledgeByID(context.Background(), 7, "doc")+ require.NoError(t, err)+ after := *before+ after.ParseStatus = types.ParseStatusProcessing+ require.NoError(t, repo.UpdateKnowledgeForTransfer(context.Background(), before, &after))+ require.Zero(t, after.UpdatedAt.Nanosecond())+ final := after+ final.KnowledgeBaseID = "target"+ final.ParseStatus = types.ParseStatusCompleted+ require.NoError(t, repo.UpdateKnowledgeForTransfer(context.Background(), &after, &final))+}diff --git a/internal/application/repository/resource_references.go b/internal/application/repository/resource_references.gonew file mode 100644index 000000000..baf32ee12--- /dev/null+++ b/internal/application/repository/resource_references.go@@ -0,0 +1,57 @@+package repository++import (+ "context"++ "github.com/Tencent/WeKnora/internal/types"+)++// IsReferencedByKnowledgeBase accepts only explicit bindings to live documents.+// Text mentioning a handle or physical path is never ownership evidence.+func (r *resourceRepository) IsReferencedByKnowledgeBase(+ ctx context.Context, tenantID uint64, kbID, resourceID string,+) (bool, error) {+ if tenantID == 0 || kbID == "" || resourceID == "" {+ return false, nil+ }+ var count int64+ err := r.db.WithContext(ctx).Table("resource_bindings AS b").+ Joins("JOIN knowledges AS k ON k.id = b.owner_id AND k.tenant_id = b.tenant_id").+ Joins("JOIN knowledge_bases AS kb ON kb.id = k.knowledge_base_id "++ "AND kb.tenant_id = k.tenant_id AND kb.deleted_at IS NULL").+ Where("b.resource_id = ? AND b.owner_type = ? AND b.tenant_id = ? "++ "AND k.knowledge_base_id = ? AND k.deleted_at IS NULL",+ resourceID, types.ResourceOwnerKnowledge, tenantID, kbID).Count(&count).Error+ return count > 0, err+}++func (r *resourceRepository) GetMessageFileBindings(+ ctx context.Context, tenantID uint64, resourceID, messageID string,+) (*types.MessageFileBindings, error) {+ result := &types.MessageFileBindings{}+ if tenantID == 0 || resourceID == "" {+ return result, nil+ }+ err := r.db.WithContext(ctx).Table("resource_bindings AS b").+ Joins("JOIN knowledges AS k ON k.id = b.owner_id AND k.tenant_id = b.tenant_id").+ Joins("JOIN knowledge_bases AS kb ON kb.id = k.knowledge_base_id "++ "AND kb.tenant_id = k.tenant_id AND kb.deleted_at IS NULL").+ Where("b.resource_id = ? AND b.owner_type = ? AND b.tenant_id = ? AND k.deleted_at IS NULL",+ resourceID, types.ResourceOwnerKnowledge, tenantID).+ Distinct("k.knowledge_base_id").Pluck("k.knowledge_base_id", &result.KnowledgeBaseIDs).Error+ if err != nil {+ return nil, err+ }+ if messageID != "" {+ var count int64+ err = r.db.WithContext(ctx).Model(&types.ResourceBinding{}).+ Where("resource_id = ? AND tenant_id = ? AND owner_type = ? AND owner_id = ? AND relation = ?",+ resourceID, tenantID, types.ResourceOwnerMessage, messageID, types.ResourceRelationArtifact).+ Count(&count).Error+ if err != nil {+ return nil, err+ }+ result.MessageArtifact = count > 0+ }+ return result, nil+}diff --git a/internal/application/repository/retriever/doris/move.go b/internal/application/repository/retriever/doris/move.gonew file mode 100644index 000000000..1b745d558--- /dev/null+++ b/internal/application/repository/retriever/doris/move.go@@ -0,0 +1,41 @@+package doris++import (+ "context"+ "fmt"+)++func (r *dorisRepository) ValidateKnowledgeIndexMove(ctx context.Context) error {+ mode, err := r.resolveCompatMode(ctx)+ if err != nil {+ return err+ }+ if mode.usesRewriteChunkUpdates() {+ // ANN DUPLICATE KEY tables implement replacement as DELETE + INSERT.+ // A failed insert would lose the only vector copy; changing physical IDs+ // would break the stable source-ID identity used by subsequent edits.+ return fmt.Errorf("reuse_vectors move is not supported by Doris ANN tables; use reparse mode")+ }+ return nil+}++func (r *dorisRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ dimension int,+ _ string,+) error {+ if err := r.ValidateKnowledgeIndexMove(ctx); err != nil {+ return err+ }+ if dimension <= 0 {+ return fmt.Errorf("invalid embedding dimension")+ }+ query := fmt.Sprintf(+ "UPDATE `%s` SET knowledge_base_id = ?, tag_id = '' WHERE knowledge_base_id = ? AND knowledge_id = ?",+ r.getTableName(dimension),+ )+ _, err := r.db.ExecContext(ctx, query, targetKB, sourceKB, knowledgeID)+ return err+}diff --git a/internal/application/repository/retriever/doris/move_test.go b/internal/application/repository/retriever/doris/move_test.gonew file mode 100644index 000000000..a22c521f1--- /dev/null+++ b/internal/application/repository/retriever/doris/move_test.go@@ -0,0 +1,36 @@+package doris++import (+ "context"+ "testing"++ "github.com/DATA-DOG/go-sqlmock"+ "github.com/stretchr/testify/require"+)++func TestMoveIndicesRejectsNonAtomicANNReplacement(t *testing.T) {+ repo, mock, _, cleanup := newTestRepo(t)+ defer cleanup()+ primeCompatMode(repo, dorisCompatModeInnerProductDuplicate, nil)+ require.ErrorContains(+ t,+ repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", []string{"chunk"}, 2, "document"),+ "use reparse mode",+ )+ require.NoError(t, mock.ExpectationsWereMet(), "rejection must issue no vector delete or insert")+}++func TestMoveIndicesLegacyUpdatesOnlyExactSourceDocument(t *testing.T) {+ repo, mock, _, cleanup := newTestRepo(t)+ defer cleanup()+ primeCompatMode(repo, dorisCompatModeLegacy, nil)+ mock.ExpectExec("UPDATE `weknora_embeddings_2` SET knowledge_base_id = \\?, tag_id = '' WHERE "++ "knowledge_base_id = \\? AND knowledge_id = \\?").+ WithArgs("target", "source", "doc").+ WillReturnResult(sqlmock.NewResult(0, 3))+ require.NoError(+ t,+ repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", []string{"chunk"}, 2, "document"),+ )+ require.NoError(t, mock.ExpectationsWereMet())+}diff --git a/internal/application/repository/retriever/elasticsearch/v7/move.go b/internal/application/repository/retriever/elasticsearch/v7/move.gonew file mode 100644index 000000000..3e85a08ed--- /dev/null+++ b/internal/application/repository/retriever/elasticsearch/v7/move.go@@ -0,0 +1,59 @@+package v7++import (+ "bytes"+ "context"+ "encoding/json"+ "fmt"+)++func (e *elasticsearchRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ _ int,+ _ string,+) error {+ body, err := json.Marshal(map[string]any{+ "query": map[string]any{"bool": map[string]any{"filter": []any{+ map[string]any{"term": map[string]any{e.idField("knowledge_base_id"): sourceKB}},+ map[string]any{"term": map[string]any{e.idField("knowledge_id"): knowledgeID}},+ }}},+ "script": map[string]any{+ "lang": "painless",+ "source": "ctx._source.knowledge_base_id = params.target; ctx._source.tag_id = ''",+ "params": map[string]any{"target": targetKB},+ },+ })+ if err != nil {+ return err+ }+ resp, err := e.client.UpdateByQuery(+ []string{e.index},+ e.client.UpdateByQuery.WithContext(ctx),+ e.client.UpdateByQuery.WithBody(bytes.NewReader(body)),+ e.client.UpdateByQuery.WithRefresh(true),+ )+ if err != nil {+ return err+ }+ defer func() { _ = resp.Body.Close() }()+ if resp.IsError() {+ return fmt.Errorf("move indices: %s", resp.String())+ }+ var result struct {+ Total *int64 `json:"total"`+ Updated *int64 `json:"updated"`+ TimedOut bool `json:"timed_out"`+ Conflicts int `json:"version_conflicts"`+ Failures []json.RawMessage `json:"failures"`+ }+ if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {+ return err+ }+ if result.Total == nil || result.Updated == nil || *result.Total < 0 || *result.Total != *result.Updated ||+ result.TimedOut || result.Conflicts != 0 || len(result.Failures) != 0 {+ return fmt.Errorf("move indices was incomplete")+ }+ return nil+}diff --git a/internal/application/repository/retriever/elasticsearch/v7/move_test.go b/internal/application/repository/retriever/elasticsearch/v7/move_test.gonew file mode 100644index 000000000..6f1d63a2a--- /dev/null+++ b/internal/application/repository/retriever/elasticsearch/v7/move_test.go@@ -0,0 +1,59 @@+package v7++import (+ "context"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/elastic/go-elasticsearch/v7"+ "github.com/stretchr/testify/require"+)++func TestMoveIndicesRequiresCompleteCounts(t *testing.T) {+ for _, tt := range []struct {+ name, body string+ fails bool+ }{+ {"complete", `{"total":100,"updated":100}`, false},+ {"empty retry", `{"total":0,"updated":0}`, false},+ {"partial", `{"total":100,"updated":40}`, true},+ {"missing total", `{"updated":40}`, true},+ {"missing updated", `{"total":40}`, true},+ {"missing counts", `{}`, true},+ {"negative", `{"total":-1,"updated":-1}`, true},+ {"conflict", `{"total":1,"updated":1,"version_conflicts":1}`, true},+ {"timeout", `{"total":1,"updated":1,"timed_out":true}`, true},+ } {+ t.Run(tt.name, func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ w.Header().Set("X-Elastic-Product", "Elasticsearch")+ if r.URL.Path == "/" {+ _, _ = w.Write(+ []byte(+ `{"version":{"number":"7.17.0","build_flavor":"default"},"tagline":"You Know, for Search"}`,+ ),+ )+ return+ }+ if r.URL.Path != "/vectors/_update_by_query" {+ t.Errorf("unexpected path: %s", r.URL.Path)+ }+ _, _ = w.Write([]byte(tt.body))+ }))+ defer server.Close()+ client, err := elasticsearch.NewClient(+ elasticsearch.Config{Addresses: []string{server.URL}, DisableRetry: true},+ )+ require.NoError(t, err)+ repo := &elasticsearchRepository{client: client, index: "vectors"}+ err = repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", nil, 3, "file")+ if tt.fails {+ require.Error(t, err)+ } else {+ require.NoError(t, err)+ }+ })+ }+}diff --git a/internal/application/repository/retriever/elasticsearch/v8/move.go b/internal/application/repository/retriever/elasticsearch/v8/move.gonew file mode 100644index 000000000..547b87bb6--- /dev/null+++ b/internal/application/repository/retriever/elasticsearch/v8/move.go@@ -0,0 +1,48 @@+// Package v8 implements retrieval against its configured vector backend.+package v8++import (+ "context"+ "encoding/json"+ "fmt"++ "github.com/elastic/go-elasticsearch/v8/typedapi/types"+)++func (e *elasticsearchRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ _ int,+ _ string,+) error {+ query := &types.Query{Bool: &types.BoolQuery{Filter: []types.Query{+ {+ Terms: &types.TermsQuery{+ TermsQuery: map[string]types.TermsQueryField{e.idField("knowledge_base_id"): []string{sourceKB}},+ },+ },+ {+ Terms: &types.TermsQuery{+ TermsQuery: map[string]types.TermsQueryField{e.idField("knowledge_id"): []string{knowledgeID}},+ },+ },+ }}}+ source := "ctx._source.knowledge_base_id = params.target; ctx._source.tag_id = ''"+ target, err := json.Marshal(targetKB)+ if err != nil {+ return err+ }+ script := &types.Script{Source: &source, Params: map[string]json.RawMessage{"target": target}}+ result, err := e.client.UpdateByQuery(e.index).Query(query).Script(script).Refresh(true).Do(ctx)+ if err != nil {+ return err+ }+ if result == nil || result.Total == nil || result.Updated == nil ||+ *result.Total < 0 || *result.Total != *result.Updated || (result.TimedOut != nil && *result.TimedOut) ||+ (result.VersionConflicts != nil && *result.VersionConflicts != 0) ||+ len(result.Failures) != 0 {+ return fmt.Errorf("move indices was incomplete")+ }+ return nil+}diff --git a/internal/application/repository/retriever/elasticsearch/v8/move_test.go b/internal/application/repository/retriever/elasticsearch/v8/move_test.gonew file mode 100644index 000000000..c27630065--- /dev/null+++ b/internal/application/repository/retriever/elasticsearch/v8/move_test.go@@ -0,0 +1,59 @@+package v8++import (+ "context"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/elastic/go-elasticsearch/v8"+ "github.com/stretchr/testify/require"+)++func TestMoveIndicesRequiresCompleteCounts(t *testing.T) {+ for _, tt := range []struct {+ name, body string+ fails bool+ }{+ {"complete", `{"total":100,"updated":100}`, false},+ {"empty retry", `{"total":0,"updated":0}`, false},+ {"partial", `{"total":100,"updated":40}`, true},+ {"missing total", `{"updated":40}`, true},+ {"missing updated", `{"total":40}`, true},+ {"missing counts", `{}`, true},+ {"negative", `{"total":-1,"updated":-1}`, true},+ {"conflict", `{"total":1,"updated":1,"version_conflicts":1}`, true},+ {"timeout", `{"total":1,"updated":1,"timed_out":true}`, true},+ } {+ t.Run(tt.name, func(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ w.Header().Set("X-Elastic-Product", "Elasticsearch")+ if r.URL.Path == "/" {+ _, _ = w.Write(+ []byte(+ `{"version":{"number":"7.17.0","build_flavor":"default"},"tagline":"You Know, for Search"}`,+ ),+ )+ return+ }+ if r.URL.Path != "/vectors/_update_by_query" {+ t.Errorf("unexpected path: %s", r.URL.Path)+ }+ _, _ = w.Write([]byte(tt.body))+ }))+ defer server.Close()+ client, err := elasticsearch.NewTypedClient(+ elasticsearch.Config{Addresses: []string{server.URL}, DisableRetry: true},+ )+ require.NoError(t, err)+ repo := &elasticsearchRepository{client: client, index: "vectors"}+ err = repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", nil, 3, "file")+ if tt.fails {+ require.Error(t, err)+ } else {+ require.NoError(t, err)+ }+ })+ }+}diff --git a/internal/application/repository/retriever/milvus/move.go b/internal/application/repository/retriever/milvus/move.gonew file mode 100644index 000000000..cd981b793--- /dev/null+++ b/internal/application/repository/retriever/milvus/move.go@@ -0,0 +1,61 @@+package milvus++import (+ "context"+ "fmt"+)++func (m *milvusRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ dimension int,+ _ string,+) error {+ collection := m.getCollectionName(dimension)+ filter := &universalFilterCondition{Operator: operatorAnd, Value: []*universalFilterCondition{+ {Field: fieldKnowledgeBaseID, Operator: operatorEqual, Value: sourceKB},+ {Field: fieldKnowledgeID, Operator: operatorEqual, Value: knowledgeID},+ }}+ size, offset := 100, 0+ return drainMoveRows(ctx, targetKB, func(ctx context.Context) ([]*MilvusVectorEmbeddingWithScore, error) {+ rows, _, err := m.searchByFilter(ctx, collection, filter, &size, &offset)+ return rows, err+ }, func(ctx context.Context, rows []*MilvusVectorEmbedding) error {+ _, err := m.client.Upsert(ctx, createUpsert(collection, rows))+ return err+ })+}++// Drain the source predicate without offset windows. A repeated ID means the+// backend has not made the acknowledged update visible; fail for retry instead+// of advancing the document checkpoint or silently omitting remaining vectors.+func drainMoveRows(ctx context.Context, targetKB string,+ read func(context.Context) ([]*MilvusVectorEmbeddingWithScore, error),+ write func(context.Context, []*MilvusVectorEmbedding) error,+) error {+ seen := map[string]bool{}+ for {+ rows, err := read(ctx)+ if err != nil {+ return err+ }+ if len(rows) == 0 {+ return nil+ }+ batch := make([]*MilvusVectorEmbedding, 0, len(rows))+ for _, row := range rows {+ if row == nil || row.ID == "" || seen[row.ID] {+ return fmt.Errorf("invalid or repeated move index")+ }+ seen[row.ID] = true+ copyOfRow := row.MilvusVectorEmbedding+ copyOfRow.KnowledgeBaseID = targetKB+ copyOfRow.TagID = ""+ batch = append(batch, ©OfRow)+ }+ if err := write(ctx, batch); err != nil {+ return err+ }+ }+}diff --git a/internal/application/repository/retriever/milvus/move_test.go b/internal/application/repository/retriever/milvus/move_test.gonew file mode 100644index 000000000..93b3afb12--- /dev/null+++ b/internal/application/repository/retriever/milvus/move_test.go@@ -0,0 +1,82 @@+package milvus++import (+ "context"+ "errors"+ "fmt"+ "testing"++ "github.com/stretchr/testify/require"+)++func TestMoveRowsDrainsPagesAndRetriesPartialUpsert(t *testing.T) {+ remaining := map[string]*MilvusVectorEmbeddingWithScore{}+ moved := map[string]*MilvusVectorEmbedding{}+ for i := range 205 {+ id := fmt.Sprint(i)+ remaining[id] = &MilvusVectorEmbeddingWithScore{MilvusVectorEmbedding: MilvusVectorEmbedding{+ ID: id,+ KnowledgeID: "doc",+ KnowledgeBaseID: "source",+ TagID: "old-tag",+ ChunkID: "chunk-" + id,+ Content: "text",+ Embedding: []float32{1, 2, 3},+ IsEnabled: i%2 == 0,+ }}+ }+ reads, writes := 0, 0+ failure := errors.New("partial upsert")+ read := func(context.Context) ([]*MilvusVectorEmbeddingWithScore, error) {+ reads+++ var rows []*MilvusVectorEmbeddingWithScore+ for _, row := range remaining {+ rows = append(rows, row)+ if len(rows) == 100 {+ break+ }+ }+ return rows, nil+ }+ write := func(_ context.Context, rows []*MilvusVectorEmbedding) error {+ writes+++ for i, row := range rows {+ original := remaining[row.ID]+ require.NotNil(t, original)+ require.Equal(t, "source", original.KnowledgeBaseID, "read rows must not be mutated before acknowledgement")+ require.Equal(t, "target", row.KnowledgeBaseID)+ require.Empty(t, row.TagID)+ expected := original.MilvusVectorEmbedding+ expected.KnowledgeBaseID = "target"+ expected.TagID = ""+ require.Equal(t, expected, *row)+ moved[row.ID] = row+ delete(remaining, row.ID)+ if writes == 2 && i == 16 {+ return failure+ }+ }+ return nil+ }+ require.ErrorIs(t, drainMoveRows(context.Background(), "target", read, write), failure)+ require.Len(t, remaining, 88)+ require.NoError(t, drainMoveRows(context.Background(), "target", read, write))+ require.Empty(t, remaining)+ require.Len(t, moved, 205)+ require.Equal(t, 4, reads, "retry must verify an empty source predicate")+}++func TestMoveRowsRejectsUnacknowledgedProgress(t *testing.T) {+ row := &MilvusVectorEmbeddingWithScore{+ MilvusVectorEmbedding: MilvusVectorEmbedding{ID: "id", KnowledgeBaseID: "source"},+ }+ err := drainMoveRows(+ context.Background(),+ "target",+ func(context.Context) ([]*MilvusVectorEmbeddingWithScore, error) {+ return []*MilvusVectorEmbeddingWithScore{row}, nil+ },+ func(context.Context, []*MilvusVectorEmbedding) error { return nil },+ )+ require.ErrorContains(t, err, "repeated")+}diff --git a/internal/application/repository/retriever/opensearch/byquery.go b/internal/application/repository/retriever/opensearch/byquery.goindex 912fcaacf..1c0f06e6c 100644--- a/internal/application/repository/retriever/opensearch/byquery.go+++ b/internal/application/repository/retriever/opensearch/byquery.go@@ -17,8 +17,15 @@ import (// bounded id + type. A non-zero version_conflicts count with no hard failures// is logged as a warning but not treated as an error.func inspectByQueryResponse(body io.Reader) error {+ return inspectByQueryResult(body, false)+}++func inspectByQueryResult(body io.Reader, requireComplete bool) error {var r struct {- VersionConflicts int `json:"version_conflicts"`+ Total *int64 `json:"total"`+ Updated *int64 `json:"updated"`+ TimedOut bool `json:"timed_out"`+ VersionConflicts int `json:"version_conflicts"`Failures []struct {ID string `json:"id"`Cause struct {@@ -30,6 +37,13 @@ func inspectByQueryResponse(body io.Reader) error {if err := json.NewDecoder(body).Decode(&r); err != nil {return fmt.Errorf("opensearch: parse by-query response: %w", ErrTransport)}+ if requireComplete && (r.TimedOut || r.VersionConflicts != 0) {+ return fmt.Errorf("opensearch: incomplete move (timed_out=%t, version_conflicts=%d): %w",+ r.TimedOut, r.VersionConflicts, ErrTransport)+ }+ if requireComplete && (r.Total == nil || r.Updated == nil || *r.Total < 0 || *r.Updated != *r.Total) {+ return fmt.Errorf("opensearch: incomplete move document counts: %w", ErrTransport)+ }log := logger.GetLogger(context.Background())if len(r.Failures) == 0 {if r.VersionConflicts > 0 {diff --git a/internal/application/repository/retriever/opensearch/move.go b/internal/application/repository/retriever/opensearch/move.gonew file mode 100644index 000000000..5e12238a4--- /dev/null+++ b/internal/application/repository/retriever/opensearch/move.go@@ -0,0 +1,49 @@+package opensearch++import (+ "bytes"+ "context"+ "encoding/json"+ "fmt"+ "io"++ osapi "github.com/opensearch-project/opensearch-go/v4/opensearchapi"+)++// MoveKnowledgeIndices changes every vector for the source document, including+// historical vectors whose chunks no longer exist, while preserving vector IDs.+func (r *Repository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ _ int,+ _ string,+) error {+ body, err := json.Marshal(map[string]any{+ "query": map[string]any{"bool": map[string]any{"filter": []any{+ map[string]any{"term": map[string]any{"knowledge_base_id": sourceKB}},+ map[string]any{"term": map[string]any{"knowledge_id": knowledgeID}},+ }}},+ "script": map[string]any{+ "lang": "painless",+ "source": "ctx._source.knowledge_base_id = params.target; ctx._source.tag_id = '';",+ "params": map[string]any{"target": targetKB},+ },+ })+ if err != nil {+ return fmt.Errorf("opensearch: marshal move: %w", err)+ }+ refresh := true+ resp, err := r.client.UpdateByQuery(ctx, osapi.UpdateByQueryReq{+ Indices: []string{r.baseIndex + "_*"}, Body: bytes.NewReader(body),+ Params: osapi.UpdateByQueryParams{Refresh: &refresh},+ })+ if err != nil {+ return wrapTransport(err)+ }+ if resp == nil {+ return fmt.Errorf("opensearch: missing move response: %w", ErrTransport)+ }+ defer drainAndClose(resp.Inspect().Response.Body)+ return inspectByQueryResult(io.LimitReader(resp.Inspect().Response.Body, 16<<20), true)+}diff --git a/internal/application/repository/retriever/opensearch/move_test.go b/internal/application/repository/retriever/opensearch/move_test.gonew file mode 100644index 000000000..1570e9ad4--- /dev/null+++ b/internal/application/repository/retriever/opensearch/move_test.go@@ -0,0 +1,61 @@+package opensearch++import (+ "context"+ "encoding/json"+ "net/http"+ "testing"++ "github.com/stretchr/testify/require"+)++func TestMoveIndicesRequiresCompleteResult(t *testing.T) {+ for _, tt := range []struct {+ name, response string+ fails bool+ }{+ {"complete", `{"total":2,"updated":2,"version_conflicts":0,"failures":[]}`, false},+ {"partial", `{"total":100,"updated":40,"failures":[]}`, true},+ {"empty", `{"total":0,"updated":0,"failures":[]}`, false},+ {"missing counts", `{"failures":[]}`, true},+ {"missing total", `{"updated":2,"failures":[]}`, true},+ {"missing updated", `{"total":2,"failures":[]}`, true},+ {"negative", `{"total":-1,"updated":-1,"failures":[]}`, true},+ {"conflict", `{"updated":1,"version_conflicts":1,"failures":[]}`, true},+ {"timeout", `{"timed_out":true,"version_conflicts":0,"failures":[]}`, true},+ {"failure", `{"failures":[{"id":"doc","cause":{"type":"unavailable"}}]}`, true},+ } {+ t.Run(tt.name, func(t *testing.T) {+ repo, server := newTestRepo(t, func(w http.ResponseWriter, _ *http.Request) {+ _, _ = w.Write([]byte(tt.response))+ })+ defer server.Close()+ err := repo.MoveKnowledgeIndices(+ context.Background(), "source", "target", "doc", []string{"chunk"}, 1, "file",+ )+ if tt.fails {+ require.ErrorIs(t, err, ErrTransport)+ } else {+ require.NoError(t, err)+ }+ })+ }+}++func TestMoveIndicesIncludesOrphansEvenWithoutDatabaseChunks(t *testing.T) {+ var body map[string]any+ repo, server := newTestRepo(t, func(w http.ResponseWriter, r *http.Request) {+ if err := json.NewDecoder(r.Body).Decode(&body); err != nil {+ t.Errorf("decode move request: %v", err)+ }+ _, _ = w.Write([]byte(`{"total":1,"updated":1,"failures":[]}`))+ })+ defer server.Close()+ require.NoError(t, repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", nil, 1, "file"))+ want := `{"bool":{"filter":[{"term":{"knowledge_base_id":"source"}},{"term":{"knowledge_id":"doc"}}]}}`+ query, err := json.Marshal(body["query"])+ require.NoError(t, err)+ require.JSONEq(t, want, string(query), "all vectors for this exact source document must be selected")+ script := body["script"].(map[string]any)+ require.Equal(t, map[string]any{"target": "target"}, script["params"])+}diff --git a/internal/application/repository/retriever/postgres/move.go b/internal/application/repository/retriever/postgres/move.gonew file mode 100644index 000000000..dd4800910--- /dev/null+++ b/internal/application/repository/retriever/postgres/move.go@@ -0,0 +1,16 @@+// Package postgres implements retrieval against its configured vector backend.+package postgres++import "context"++func (g *pgRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ _ int,+ _ string,+) error {+ return g.db.WithContext(ctx).Model(&pgVector{}).+ Where("knowledge_base_id = ? AND knowledge_id = ?", sourceKB, knowledgeID).+ Updates(map[string]any{"knowledge_base_id": targetKB, "tag_id": ""}).Error+}diff --git a/internal/application/repository/retriever/qdrant/move.go b/internal/application/repository/retriever/qdrant/move.gonew file mode 100644index 000000000..731a5374f--- /dev/null+++ b/internal/application/repository/retriever/qdrant/move.go@@ -0,0 +1,26 @@+// Package qdrant implements vector retrieval and metadata updates in Qdrant.+package qdrant++import (+ "context"++ "github.com/qdrant/go-client/qdrant"+)++func (q *qdrantRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ dimension int,+ _ string,+) error {+ wait := true+ _, err := q.client.SetPayload(ctx, &qdrant.SetPayloadPoints{+ CollectionName: q.getCollectionName(dimension), Wait: &wait,+ Payload: newQdrantValueMap(map[string]any{fieldKnowledgeBaseID: targetKB, fieldTagID: ""}),+ PointsSelector: qdrant.NewPointsSelectorFilter(&qdrant.Filter{Must: []*qdrant.Condition{+ qdrant.NewMatch(fieldKnowledgeBaseID, sourceKB), qdrant.NewMatch(fieldKnowledgeID, knowledgeID),+ }}),+ })+ return err+}diff --git a/internal/application/repository/retriever/sqlite/move.go b/internal/application/repository/retriever/sqlite/move.gonew file mode 100644index 000000000..a91c483c1--- /dev/null+++ b/internal/application/repository/retriever/sqlite/move.go@@ -0,0 +1,17 @@+// Package sqlite implements local retrieval with SQLite FTS and vectors.+package sqlite++import "context"++func (r *sqliteRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ _ int,+ _ string,+) error {+ // FTS and vector rows keep their IDs. Queries join them to this metadata row.+ return r.db.WithContext(ctx).Model(&sqliteEmbedding{}).+ Where("knowledge_base_id = ? AND knowledge_id = ?", sourceKB, knowledgeID).+ Updates(map[string]any{"knowledge_base_id": targetKB, "tag_id": ""}).Error+}diff --git a/internal/application/repository/retriever/sqlite/move_test.go b/internal/application/repository/retriever/sqlite/move_test.gonew file mode 100644index 000000000..45e72f8d2--- /dev/null+++ b/internal/application/repository/retriever/sqlite/move_test.go@@ -0,0 +1,72 @@+package sqlite++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++func TestMoveIndicesPreservesVectorsAndExactScopeAcrossRetry(t *testing.T) {+ repo := newSQLiteRetrieverTestRepository(t)+ ctx := context.Background()+ for _, row := range []struct{ chunk, kb, doc string }{+ {+ "text",+ "source",+ "doc",+ },+ {+ "image",+ "source",+ "doc",+ },+ {+ "other",+ "source",+ "other-doc",+ },+ {+ "foreign",+ "third",+ "doc",+ },+ } {+ saveSQLiteTestVector(t, repo, sqliteTestIndex(row.chunk, row.kb, row.doc, "old-tag", true), []float32{1, 0})+ }+ var before []sqliteEmbedding+ require.NoError(t, repo.db.Order("id").Find(&before).Error)+ for range 2 {+ require.NoError(+ t,+ repo.MoveKnowledgeIndices(ctx, "source", "target", "doc", []string{"text", "image"}, 2, "document"),+ )+ }+ var after []sqliteEmbedding+ require.NoError(t, repo.db.Order("id").Find(&after).Error)+ require.Len(t, after, len(before))+ for i, row := range after {+ require.Equal(t, before[i].ID, row.ID)+ require.Equal(t, before[i].SourceID, row.SourceID)+ if row.KnowledgeID == "doc" && before[i].KnowledgeBaseID == "source" {+ require.Equal(t, "target", row.KnowledgeBaseID)+ require.Empty(t, row.TagID)+ } else {+ require.Equal(t, before[i].KnowledgeBaseID, row.KnowledgeBaseID)+ require.Equal(t, "old-tag", row.TagID)+ }+ }+ results, err := repo.vectorRetrieve(+ ctx,+ types.RetrieveParams{+ Embedding: []float32{1, 0},+ TopK: 10,+ KnowledgeBaseIDs: []string{"target"},+ RetrieverType: types.VectorRetrieverType,+ },+ )+ require.NoError(t, err)+ require.Len(t, results, 1)+ require.Len(t, results[0].Results, 2, "target vectors remain searchable after an identity-preserving move")+}diff --git a/internal/application/repository/retriever/tencentvectordb/move.go b/internal/application/repository/retriever/tencentvectordb/move.gonew file mode 100644index 000000000..f05579d76--- /dev/null+++ b/internal/application/repository/retriever/tencentvectordb/move.go@@ -0,0 +1,33 @@+// Package tencentvectordb implements retrieval against its configured vector backend.+package tencentvectordb++import (+ "context"++ "github.com/tencent/vectordatabase-sdk-go/tcvectordb"+)++func (r *repository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ dimension int,+ _ string,+) error {+ filter := tcvectordb.NewFilter(+ tcvectordb.In(+ fieldKnowledgeBaseID,+ []string{sourceKB},+ ) + " and " + tcvectordb.In(+ fieldKnowledgeID,+ []string{knowledgeID},+ ),+ )+ _, err := r.client.Database(r.databaseName).+ Collection(r.collectionName(dimension)).+ Update(ctx, tcvectordb.UpdateDocumentParams{+ QueryFilter: filter,+ UpdateFields: map[string]tcvectordb.Field{fieldKnowledgeBaseID: {Val: targetKB}, fieldTagID: {Val: ""}},+ })+ return err+}diff --git a/internal/application/repository/retriever/weaviate/move.go b/internal/application/repository/retriever/weaviate/move.gonew file mode 100644index 000000000..0410c409e--- /dev/null+++ b/internal/application/repository/retriever/weaviate/move.go@@ -0,0 +1,77 @@+// Package weaviate implements retrieval and metadata updates in Weaviate.+package weaviate++import (+ "context"+ "fmt"++ "github.com/weaviate/weaviate-go-client/v5/weaviate/filters"+ "github.com/weaviate/weaviate-go-client/v5/weaviate/graphql"+)++func (w *weaviateRepository) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ _ []string,+ dimension int,+ _ string,+) error {+ collection := w.getCollectionName(dimension)+ where := filters.Where().WithOperator(filters.And).WithOperands([]*filters.WhereBuilder{+ filters.Where().WithPath([]string{fieldKnowledgeBaseID}).WithOperator(filters.Equal).WithValueString(sourceKB),+ filters.Where().WithPath([]string{fieldKnowledgeID}).WithOperator(filters.Equal).WithValueString(knowledgeID),+ })+ seen := make(map[string]bool)+ for {+ result, err := w.client.GraphQL().Get().WithClassName(collection).WithWhere(where).WithLimit(100).+ WithFields(graphql.Field{Name: "_additional", Fields: []graphql.Field{{Name: "id"}}}).+ Do(ctx)+ if err != nil {+ return err+ }+ if result == nil || len(result.Errors) != 0 {+ return fmt.Errorf("failed to list move indices")+ }+ get, ok := result.Data["Get"].(map[string]interface{})+ if !ok {+ return fmt.Errorf("invalid move index response")+ }+ rows, ok := get[collection].([]interface{})+ if !ok {+ return fmt.Errorf("invalid move index collection")+ }+ if len(rows) == 0 {+ return nil+ }+ var ids []string+ for _, row := range rows {+ data, ok := row.(map[string]interface{})+ if !ok {+ return fmt.Errorf("invalid move index row")+ }+ additional, ok := data["_additional"].(map[string]interface{})+ if !ok {+ return fmt.Errorf("missing move index ID")+ }+ id, ok := additional["id"].(string)+ if !ok || id == "" {+ return fmt.Errorf("invalid move index ID")+ }+ if seen[id] {+ return fmt.Errorf("move indices made no progress for %s", id)+ }+ seen[id] = true+ ids = append(ids, id)+ }+ // Drain the first filtered page; after+where is unsupported by Weaviate.+ // Successful updates remove these IDs from the predicate. Only an empty+ // follow-up query proves completion, including after partial-page updates.+ for _, id := range ids {+ if err := w.client.Data().Updater().WithClassName(collection).WithID(id).WithMerge().+ WithProperties(map[string]interface{}{fieldKnowledgeBaseID: targetKB, fieldTagID: ""}).+ Do(ctx); err != nil {+ return err+ }+ }+ }+}diff --git a/internal/application/repository/retriever/weaviate/move_test.go b/internal/application/repository/retriever/weaviate/move_test.gonew file mode 100644index 000000000..eabc2ad35--- /dev/null+++ b/internal/application/repository/retriever/weaviate/move_test.go@@ -0,0 +1,130 @@+package weaviate++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "net/http/httptest"+ "path"+ "strings"+ "sync"+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+ sdk "github.com/weaviate/weaviate-go-client/v5/weaviate"+)++func TestMoveKnowledgeIndicesDrainsBeyondOffsetLimitAndRetries(t *testing.T) {+ const count = 10005+ var mu sync.Mutex+ remaining := make(map[string]bool, count)+ for i := range count {+ remaining[fmt.Sprintf("00000000-0000-0000-0000-%012d", i)] = true+ }+ failed := false+ patches, queries := 0, 0+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ mu.Lock()+ defer mu.Unlock()+ w.Header().Set("Content-Type", "application/json")+ switch {+ case r.URL.Path == "/v1/graphql":+ queries+++ var body struct {+ Query string `json:"query"`+ }+ if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&body)) {+ w.WriteHeader(400)+ return+ }+ assert.Contains(t, body.Query, "knowledge_base_id")+ assert.Contains(t, body.Query, "knowledge_id")+ assert.Contains(t, body.Query, "source")+ assert.Contains(t, body.Query, "doc")+ if strings.Contains(body.Query, "offset") || strings.Contains(body.Query, "after") {+ _ = json.NewEncoder(w).+ Encode(map[string]any{"errors": []any{map[string]any{"message": "pagination unsupported"}}})+ return+ }+ rows := make([]any, 0, 100)+ for id := range remaining {+ rows = append(rows, map[string]any{"_additional": map[string]any{"id": id}})+ if len(rows) == 100 {+ break+ }+ }+ _ = json.NewEncoder(w).Encode(map[string]any{"data": map[string]any{"Get": map[string]any{"Move_3": rows}}})+ case r.Method == http.MethodPatch:+ id := path.Base(r.URL.Path)+ assert.True(t, remaining[id], "only source-filtered IDs should be moved")+ var body struct {+ Properties map[string]any `json:"properties"`+ Vector []float32 `json:"vector"`+ }+ if !assert.NoError(t, json.NewDecoder(r.Body).Decode(&body)) {+ w.WriteHeader(400)+ return+ }+ assert.Equal(t, map[string]any{fieldKnowledgeBaseID: "target", fieldTagID: ""}, body.Properties)+ assert.Empty(t, body.Vector, "metadata merge must preserve existing vectors")+ if patches == 137 && !failed {+ failed = true+ w.WriteHeader(http.StatusServiceUnavailable)+ return+ }+ patches+++ delete(remaining, id)+ w.WriteHeader(http.StatusNoContent)+ default:+ // SDK probes the server version before object writes.+ if r.URL.Path == "/v1/meta" {+ _, _ = w.Write([]byte(`{"version":"1.30.0"}`))+ return+ }+ t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)+ w.WriteHeader(http.StatusNotFound)+ }+ }))+ defer server.Close()+ client, err := sdk.NewClient(sdk.Config{Scheme: "http", Host: strings.TrimPrefix(server.URL, "http://")})+ require.NoError(t, err)+ repo := &weaviateRepository{client: client, collectionBaseName: "Move"}+ require.Error(t, repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", nil, 3, ""))+ mu.Lock()+ left := len(remaining)+ mu.Unlock()+ require.Equal(t, count-137, left)+ require.NoError(t, repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", nil, 3, ""))+ mu.Lock()+ defer mu.Unlock()+ require.Empty(t, remaining)+ require.Equal(t, count, patches)+ require.Greater(t, queries, 100)+}++func TestMoveKnowledgeIndicesRejectsNoProgress(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ w.Header().Set("Content-Type", "application/json")+ switch r.URL.Path {+ case "/v1/graphql":+ _, _ = w.Write(+ []byte(`{"data":{"Get":{"Move_3":[{"_additional":{"id":"00000000-0000-0000-0000-000000000001"}}]}}}`),+ )+ case "/v1/meta":+ _, _ = w.Write([]byte(`{"version":"1.30.0"}`))+ default:+ w.WriteHeader(http.StatusNoContent)+ }+ }))+ defer server.Close()+ client, err := sdk.NewClient(sdk.Config{Scheme: "http", Host: strings.TrimPrefix(server.URL, "http://")})+ require.NoError(t, err)+ repo := &weaviateRepository{client: client, collectionBaseName: "Move"}+ require.ErrorContains(+ t,+ repo.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", nil, 3, ""),+ "no progress",+ )+}diff --git a/internal/application/service/agent_share.go b/internal/application/service/agent_share.goindex eec993d63..9e30ed295 100644--- a/internal/application/service/agent_share.go+++ b/internal/application/service/agent_share.go@@ -512,27 +512,9 @@ func (s *agentShareService) TenantCanAccessKBViaSomeSharedAgent(ctx context.Contreturn false, err}for _, info := range list {- if info.Agent == nil {- continue- }- agent := info.Agent- if agent.TenantID != kb.TenantID {- continue- }- mode := agent.Config.KBSelectionMode- if mode == "none" {- continue- }- if mode == "all" {+ if types.SharedAgentIncludesKB(info.Agent, kb) {return true, nil}- if mode == "selected" {- for _, id := range agent.Config.KnowledgeBases {- if id == kb.ID {- return true, nil- }- }- }}return false, nil}diff --git a/internal/application/service/chunk.go b/internal/application/service/chunk.goindex de8ac9513..8727ca040 100644--- a/internal/application/service/chunk.go+++ b/internal/application/service/chunk.go@@ -86,6 +86,9 @@ func (s *chunkService) GetRepository() interfaces.ChunkRepository {// Returns:// - error: Any error encountered during chunk creationfunc (s *chunkService) CreateChunks(ctx context.Context, chunks []*types.Chunk) error {+ if err := s.validateChunkWrites(ctx, chunks, true); err != nil {+ return err+ }err := s.chunkRepository.CreateChunks(ctx, chunks)if err != nil {logger.ErrorWithFields(ctx, err, map[string]interface{}{@@ -217,6 +220,9 @@ func (s *chunkService) ListPagedChunksByKnowledgeID(ctx context.Context,//// This method handles the actual update logic for a chunk, including updating the vector database representationfunc (s *chunkService) UpdateChunk(ctx context.Context, chunk *types.Chunk) error {+ if err := s.validateChunkWrites(ctx, []*types.Chunk{chunk}, false); err != nil {+ return err+ }logger.Infof(ctx, "Updating chunk, ID: %s, knowledge ID: %s", chunk.ID, chunk.KnowledgeID)// Update the chunk in the repository@@ -235,6 +241,9 @@ func (s *chunkService) UpdateChunk(ctx context.Context, chunk *types.Chunk) erro// UpdateChunks updates chunks in batchfunc (s *chunkService) UpdateChunks(ctx context.Context, chunks []*types.Chunk) error {+ if err := s.validateChunkWrites(ctx, chunks, false); err != nil {+ return err+ }if len(chunks) == 0 {return nil}@@ -262,6 +271,9 @@ func (s *chunkService) UpdateChunks(ctx context.Context, chunks []*types.Chunk)// Returns:// - error: Any error encountered during deletionfunc (s *chunkService) DeleteChunk(ctx context.Context, id string) error {+ if _, err := s.writableChunk(ctx, id); err != nil {+ return err+ }tenantID := types.MustTenantIDFromContext(ctx)err := s.chunkRepository.DeleteChunk(ctx, tenantID, id)if err != nil {@@ -289,10 +301,15 @@ func (s *chunkService) DeleteChunks(ctx context.Context, ids []string) error {logger.Info(ctx, "Start deleting chunks in batch")logger.Infof(ctx, "Deleting %d chunks", len(ids))+ checkedIDs, err := s.writableChunkIDs(ctx, ids)+ if err != nil {+ return err+ }+ ids = checkedIDstenantID := types.MustTenantIDFromContext(ctx)logger.Infof(ctx, "Tenant ID: %d", tenantID)- err := s.chunkRepository.DeleteChunks(ctx, tenantID, ids)+ err = s.chunkRepository.DeleteChunks(ctx, tenantID, ids)if err != nil {logger.ErrorWithFields(ctx, err, map[string]interface{}{"chunk_ids": ids,@@ -314,6 +331,9 @@ func (s *chunkService) DeleteChunks(ctx context.Context, ids []string) error {// Returns:// - error: Any error encountered during bulk deletionfunc (s *chunkService) DeleteChunksByKnowledgeID(ctx context.Context, knowledgeID string) error {+ if _, err := loadKnowledgeWriteBatch(ctx, s.knowledgeRepo, s.kbRepository, []string{knowledgeID}); err != nil {+ return err+ }logger.Info(ctx, "Start deleting all chunks by knowledge ID")logger.Infof(ctx, "Knowledge ID: %s", knowledgeID)@@ -334,6 +354,9 @@ func (s *chunkService) DeleteChunksByKnowledgeID(ctx context.Context, knowledgeI}func (s *chunkService) DeleteByKnowledgeList(ctx context.Context, ids []string) error {+ if _, err := loadKnowledgeWriteBatch(ctx, s.knowledgeRepo, s.kbRepository, ids); err != nil {+ return err+ }logger.Info(ctx, "Start deleting all chunks by knowledge IDs")logger.Infof(ctx, "Knowledge IDs: %v", ids)@@ -382,14 +405,16 @@ func (s *chunkService) ListChunkByParentID(func (s *chunkService) UpdateDocumentChunk(ctx context.Context, chunkID string, content *string, isEnabled *bool, expectedRevision *int,) (*types.Chunk, error) {- tenantID := types.MustTenantIDFromContext(ctx)- chunk, err := s.chunkRepository.GetChunkByID(ctx, tenantID, chunkID)+ chunk, err := s.writableChunk(ctx, chunkID)if err != nil {return nil, err}if chunk.ChunkType != types.ChunkTypeText {return nil, fmt.Errorf("only text chunks can be edited")}+ if err := s.validateDocumentChunkRelations(ctx, chunk); err != nil {+ return nil, err+ }if expectedRevision != nil && *expectedRevision != chunk.ContentRevision {return nil, ErrChunkRevisionConflict}@@ -481,7 +506,7 @@ func (s *chunkService) UpdateDocumentChunk(}}if bodyChanged || newEnabled != revision.IsEnabled {- knowledge, getErr := s.knowledgeRepo.GetKnowledgeByID(ctx, tenantID, chunk.KnowledgeID)+ knowledge, getErr := s.knowledgeRepo.GetKnowledgeByID(ctx, chunk.TenantID, chunk.KnowledgeID)if getErr == nil {if err := enqueueSummaryRefresh(ctx, s.knowledgeRepo, s.task, s.kbRepository, s.spanTracker, knowledge,@@ -700,7 +725,7 @@ func (s *chunkService) UpsertGeneratedQuestion(if question == "" {return nil, fmt.Errorf("question cannot be empty")}- chunk, err := s.chunkRepository.GetChunkByID(ctx, types.MustTenantIDFromContext(ctx), chunkID)+ chunk, err := s.writableChunk(ctx, chunkID)if err != nil {return nil, err}@@ -756,7 +781,7 @@ func (s *chunkService) DeleteGeneratedQuestion(ctx context.Context, chunkID stritenantID := types.MustTenantIDFromContext(ctx)// 1. Get the chunk- chunk, err := s.chunkRepository.GetChunkByID(ctx, tenantID, chunkID)+ chunk, err := s.writableChunk(ctx, chunkID)if err != nil {logger.ErrorWithFields(ctx, err, map[string]interface{}{"chunk_id": chunkID,diff --git a/internal/application/service/chunk_edit_parent_test.go b/internal/application/service/chunk_edit_parent_test.goindex 846dfdc2f..1d06f7d6a 100644--- a/internal/application/service/chunk_edit_parent_test.go+++ b/internal/application/service/chunk_edit_parent_test.go@@ -3,11 +3,11 @@ package serviceimport ("context""encoding/json"- "errors""strings""testing""time"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces")@@ -49,7 +49,7 @@ type editableChunkKBRepo struct {}func (editableChunkKBRepo) GetKnowledgeBaseByID(context.Context, string) (*types.KnowledgeBase, error) {- return &types.KnowledgeBase{}, nil+ return &types.KnowledgeBase{ID: "kb", TenantID: 1}, nil}type editableChunkKnowledgeRepo struct {@@ -57,7 +57,7 @@ type editableChunkKnowledgeRepo struct {}func (editableChunkKnowledgeRepo) GetKnowledgeByID(context.Context, uint64, string) (*types.Knowledge, error) {- return nil, errors.New("summary refresh not configured in unit test")+ return &types.Knowledge{ID: "knowledge", TenantID: 1, KnowledgeBaseID: "kb"}, nil}type imageSyncChunkRepo struct {@@ -165,6 +165,17 @@ func TestUpdateDocumentChunkPreservesGeneratedQuestionsAcrossRevision(t *testingkbRepository: editableChunkKBRepo{},}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(1))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb",+ TenantID: 1,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 1,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )newContent := "new body"updated, err := service.UpdateDocumentChunk(ctx, "chunk", &newContent, nil, nil)diff --git a/internal/application/service/chunk_write.go b/internal/application/service/chunk_write.gonew file mode 100644index 000000000..5006e8d0e--- /dev/null+++ b/internal/application/service/chunk_write.go@@ -0,0 +1,143 @@+package service++import (+ "context"++ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+)++func (s *chunkService) writableChunk(ctx context.Context, id string) (*types.Chunk, error) {+ tenant, err := writeExecutionTenant(ctx)+ if err != nil {+ return nil, err+ }+ chunk, err := s.chunkRepository.GetChunkByID(ctx, tenant, id)+ if err != nil {+ return nil, err+ }+ if chunk == nil || chunk.ID != id || chunk.TenantID != tenant {+ return nil, apperrors.NewNotFoundError("chunk not found")+ }+ knowledge, _, err := loadKnowledgeWrite(ctx, s.knowledgeRepo, s.kbRepository, chunk.KnowledgeID)+ if err != nil {+ return nil, err+ }+ if chunk.KnowledgeBaseID != knowledge.KnowledgeBaseID {+ return nil, apperrors.NewForbiddenError("chunk does not belong to its knowledge base")+ }+ copyOfChunk := *chunk+ return ©OfChunk, nil+}++func sameChunkDocument(a, b *types.Chunk) bool {+ return a != nil && b != nil && a.TenantID == b.TenantID &&+ a.KnowledgeBaseID == b.KnowledgeBaseID && a.KnowledgeID == b.KnowledgeID+}++// Batch validation is completed before calling the repository. Supplied full+// rows cannot reparent an existing chunk to a different authorized document.+func (s *chunkService) validateChunkWrites(ctx context.Context, chunks []*types.Chunk, create bool) error {+ ids := make([]string, 0, len(chunks))+ for _, chunk := range chunks {+ if chunk == nil || chunk.ID == "" {+ return apperrors.NewBadRequestError("chunk ID cannot be empty")+ }+ ids = append(ids, chunk.KnowledgeID)+ }+ knowledge, err := loadKnowledgeWriteBatch(ctx, s.knowledgeRepo, s.kbRepository, ids)+ if err != nil {+ return err+ }+ parents := make(map[string]*types.Knowledge, len(knowledge))+ for _, row := range knowledge {+ parents[row.ID] = row+ }+ storedByID := make(map[string]*types.Chunk)+ if !create && len(chunks) > 0 {+ chunkIDs := make([]string, 0, len(chunks))+ for _, chunk := range chunks {+ chunkIDs = append(chunkIDs, chunk.ID)+ }+ stored, err := s.chunkRepository.ListChunksByID(ctx, knowledge[0].TenantID, chunkIDs)+ if err != nil {+ return err+ }+ for _, chunk := range stored {+ if chunk != nil {+ storedByID[chunk.ID] = chunk+ }+ }+ }+ for _, chunk := range chunks {+ parent := parents[chunk.KnowledgeID]+ if parent == nil || parent.TenantID != chunk.TenantID || parent.KnowledgeBaseID != chunk.KnowledgeBaseID {+ return apperrors.NewForbiddenError("chunk does not belong to its knowledge document")+ }+ if !create {+ stored := storedByID[chunk.ID]+ if stored == nil || stored.ID != chunk.ID || !sameChunkDocument(stored, chunk) {+ return apperrors.NewForbiddenError("chunk ownership cannot be changed")+ }+ }+ }+ return nil+}++func (s *chunkService) writableChunkIDs(ctx context.Context, ids []string) ([]string, error) {+ ids, err := writeResourceIDs(ids)+ if err != nil || len(ids) == 0 {+ return ids, err+ }+ tenant, err := writeExecutionTenant(ctx)+ if err != nil {+ return nil, err+ }+ chunks, err := s.chunkRepository.ListChunksByID(ctx, tenant, ids)+ if err != nil {+ return nil, err+ }+ byID := make(map[string]*types.Chunk, len(chunks))+ for _, chunk := range chunks {+ if chunk != nil {+ byID[chunk.ID] = chunk+ }+ }+ ordered := make([]*types.Chunk, 0, len(ids))+ for _, id := range ids {+ if byID[id] == nil {+ return nil, apperrors.NewNotFoundError("chunk not found")+ }+ ordered = append(ordered, byID[id])+ }+ // Rows were loaded from storage already; only their parent grants remain.+ return ids, s.validateChunkWrites(ctx, ordered, true)+}++// Editing a text chunk may also rewrite its parent and image children. Validate+// those persisted relationships before saving the first revision.+func (s *chunkService) validateDocumentChunkRelations(ctx context.Context, chunk *types.Chunk) error {+ parents := []*types.Chunk{chunk}+ if chunk.ParentChunkID != "" {+ parent, err := s.chunkRepository.GetChunkByID(ctx, chunk.TenantID, chunk.ParentChunkID)+ if err != nil {+ return err+ }+ if parent == nil || parent.ID != chunk.ParentChunkID || !sameChunkDocument(chunk, parent) {+ return apperrors.NewForbiddenError("parent chunk does not belong to its document")+ }+ parents = append(parents, parent)+ }+ for _, parent := range parents {+ children, err := s.chunkRepository.ListChunkByParentID(ctx, chunk.TenantID, parent.ID)+ if err != nil {+ return err+ }+ for _, child := range children {+ if !sameChunkDocument(chunk, child) || child.ParentChunkID != parent.ID {+ return apperrors.NewForbiddenError("child chunk does not belong to its document")+ }+ }+ }+ return nil+}diff --git a/internal/application/service/custom_agent.go b/internal/application/service/custom_agent.goindex 02be0a10e..714b91abf 100644--- a/internal/application/service/custom_agent.go+++ b/internal/application/service/custom_agent.go@@ -8,6 +8,7 @@ import ("time""github.com/Tencent/WeKnora/internal/agent/tools"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/types"@@ -579,7 +580,7 @@ func (s *customAgentService) getSuggestedQuestions(resolvedTags := resolvedSuggestionTagScopes{}if len(scopeTagIDs) > 0 {var err error- resolvedTags, err = s.resolveSuggestionTagScopes(ctx, tenantID, tagScopes)+ resolvedTags, err = s.resolveSuggestionTagScopes(ctx, tagScopes)if err != nil {logger.ErrorWithFields(ctx, err, map[string]interface{}{"agent_id": agentID,@@ -673,7 +674,7 @@ func (s *customAgentService) getSuggestedQuestions(// querying a KB shared from tenant B would hit `tenant_id = A` and get zero// rows back — the symptom is "suggested questions never appear for shared KBs".scopeKBIDs := mergeUniqueStrings(queryKBIDs, resolvedTags.KnowledgeBaseIDs)- kbGroups := s.groupKBIDsByEffectiveTenant(ctx, tenantID, scopeKBIDs)+ kbGroups := s.groupKBIDsByEffectiveTenant(ctx, scopeKBIDs)// Always keep the caller's tenant in the iteration so knowledge_ids-only// requests (no kbIDs) still execute one query under the caller's tenant.if len(scopeKBIDs) == 0 {@@ -834,7 +835,6 @@ type resolvedSuggestionTagScopes struct {// source tenant that owns the tag and chunk rows.func (s *customAgentService) resolveSuggestionTagScopes(ctx context.Context,- callerTenantID uint64,tagScopes []types.TagScope,) (resolvedSuggestionTagScopes, error) {result := resolvedSuggestionTagScopes{TagIDsByTenant: make(map[uint64][]string)}@@ -862,7 +862,7 @@ func (s *customAgentService) resolveSuggestionTagScopes(for kbID := range byKB {kbIDs = append(kbIDs, kbID)}- kbGroups := s.groupKBIDsByEffectiveTenant(ctx, callerTenantID, kbIDs)+ kbGroups := s.groupKBIDsByEffectiveTenant(ctx, kbIDs)for tenantID, groupKBIDs := range kbGroups {for _, kbID := range groupKBIDs {requested := mergeUniqueStrings(nil, byKB[kbID])@@ -1083,9 +1083,9 @@ func wikiSuggestionFromPage(page *types.WikiPage, locale string) string {// kbIDs is empty.func (s *customAgentService) groupKBIDsByEffectiveTenant(ctx context.Context,- callerTenantID uint64,kbIDs []string,) map[uint64][]string {+ callerTenantID := types.CallerFromContext(ctx).TenantIDout := make(map[uint64][]string)if len(kbIDs) == 0 {return out@@ -1106,20 +1106,13 @@ func (s *customAgentService) groupKBIDsByEffectiveTenant(kbByID[kb.ID] = kb}}- callerRole := types.TenantRoleFromContext(ctx)+ permissions := access.NewKBPermissions(ctx, s.kbShareService)for _, kbID := range kbIDs {kb := kbByID[kbID]if kb == nil {continue}- if kb.TenantID == callerTenantID {- out[callerTenantID] = append(out[callerTenantID], kbID)- continue- }- if s.kbShareService == nil {- continue- }- ok, err := s.kbShareService.HasTenantKBPermission(ctx, kbID, callerTenantID, callerRole, types.OrgRoleViewer)+ ok, err := permissions.Check(kbID, kb.TenantID, types.OrgRoleViewer)if err != nil || !ok {continue}diff --git a/internal/application/service/custom_agent_suggestion_scope_test.go b/internal/application/service/custom_agent_suggestion_scope_test.goindex a87a51d8c..215325ee5 100644--- a/internal/application/service/custom_agent_suggestion_scope_test.go+++ b/internal/application/service/custom_agent_suggestion_scope_test.go@@ -66,14 +66,13 @@ type suggestionKBShareService struct {allowed map[string]bool}-func (s *suggestionKBShareService) HasTenantKBPermission(+func (s *suggestionKBShareService) CheckTenantKBPermission(_ context.Context,kbID string,_ uint64,_ types.TenantRole,- _ types.OrgMemberRole,-) (bool, error) {- return s.allowed[kbID], nil+) (types.OrgMemberRole, bool, error) {+ return types.OrgRoleViewer, s.allowed[kbID], nil}func TestResolveSuggestionTagScopes_UsesSourceTenantForSharedKB(t *testing.T) {@@ -97,8 +96,7 @@ func TestResolveSuggestionTagScopes_UsesSourceTenantForSharedKB(t *testing.T) {}resolved, err := svc.resolveSuggestionTagScopes(- context.Background(),- callerTenant,+ context.WithValue(context.Background(), types.TenantIDContextKey, callerTenant),[]types.TagScope{{KnowledgeBaseID: kbID, TagIDs: []string{tagID}}},)require.NoError(t, err)diff --git a/internal/application/service/datasource_service.go b/internal/application/service/datasource_service.goindex 61ec2d279..950c0aa39 100644--- a/internal/application/service/datasource_service.go+++ b/internal/application/service/datasource_service.go@@ -13,6 +13,7 @@ import ("strings""time"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/datasource""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/tracing/langfuse"@@ -513,8 +514,10 @@ func (s *DataSourceService) ManualSync(ctx context.Context, dsID string) (*typeslogger.Infof(ctx, "sync task enqueued: ds=%s syncLog=%s", dsID, syncLog.ID)recordKBActivity(ctx, s.audit, ds.TenantID, ds.KnowledgeBaseID, types.AuditActionDataSourceSyncStarted,"data_source", ds.ID, types.AuditOutcomeAccepted,- map[string]any{"name": ds.Name, "type": ds.Type, "sync_log_id": syncLog.ID,- "task_id": info.ID, "trigger": "manual", "processing_status": "pending"})+ map[string]any{+ "name": ds.Name, "type": ds.Type, "sync_log_id": syncLog.ID,+ "task_id": info.ID, "trigger": "manual", "processing_status": "pending",+ })return syncLog, nil}@@ -627,6 +630,10 @@ func (s *DataSourceService) ProcessSync(ctx context.Context, task *asynq.Task) ereturn nil}+ ctx, err = access.WithKBTaskWrite(ctx, kb, ds.TenantID)+ if err != nil {+ return fmt.Errorf("%w: data source KB does not belong to its tenant", asynq.SkipRetry)+ }wasPaused := ds.Status == types.DataSourceStatusPaused// Get connector@@ -719,7 +726,7 @@ func (s *DataSourceService) ProcessSync(ctx context.Context, task *asynq.Task) e}// Process fetched items and write to knowledge base- var result = &types.SyncResult{+ result := &types.SyncResult{Total: len(items),}diff --git a/internal/application/service/datasource_service_test.go b/internal/application/service/datasource_service_test.goindex 4a64723a6..bc90b9953 100644--- a/internal/application/service/datasource_service_test.go+++ b/internal/application/service/datasource_service_test.go@@ -254,9 +254,15 @@ func (r *processSyncTenantRepo) GetTenantByID(context.Context, uint64) (*types.Ttype processSyncTagService struct {interfaces.KnowledgeTagService+ ctx context.Context}-func (*processSyncTagService) FindOrCreateTagByName(context.Context, string, string) (*types.KnowledgeTag, error) {+func (s *processSyncTagService) FindOrCreateTagByName(+ ctx context.Context,+ _ string,+ _ string,+) (*types.KnowledgeTag, error) {+ s.ctx = ctxreturn nil, nil}diff --git a/internal/application/service/document_write_access_test.go b/internal/application/service/document_write_access_test.gonew file mode 100644index 000000000..f2fdf8806--- /dev/null+++ b/internal/application/service/document_write_access_test.go@@ -0,0 +1,660 @@+package service++import (+ "context"+ "encoding/json"+ "errors"+ "path/filepath"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/hibiken/asynq"+ "github.com/stretchr/testify/require"+ "gorm.io/driver/sqlite"+ "gorm.io/gorm"+)++type documentKBLookup struct {+ interfaces.KnowledgeBaseService+ values map[string]*types.KnowledgeBase+ err error+}++func (r *documentKBLookup) GetKnowledgeBaseByID(_ context.Context, id string) (*types.KnowledgeBase, error) {+ if r.err != nil {+ return nil, r.err+ }+ if r.values[id] == nil {+ return nil, repository.ErrKnowledgeBaseNotFound+ }+ return r.values[id], nil+}++type documentKBRepo struct {+ interfaces.KnowledgeBaseRepository+ lookup *documentKBLookup+}++func (r documentKBRepo) GetKnowledgeBaseByID(ctx context.Context, id string) (*types.KnowledgeBase, error) {+ return r.lookup.GetKnowledgeBaseByID(ctx, id)+}++type documentKnowledgeSpy struct {+ interfaces.KnowledgeRepository+ writes int+}++func (r *documentKnowledgeSpy) UpdateKnowledge(ctx context.Context, k *types.Knowledge) error {+ r.writes+++ return r.KnowledgeRepository.UpdateKnowledge(ctx, k)+}++func (r *documentKnowledgeSpy) SetKnowledgeTags(ctx context.Context, id string, tags []string) error {+ r.writes+++ return r.KnowledgeRepository.SetKnowledgeTags(ctx, id, tags)+}++func (r *documentKnowledgeSpy) DeleteKnowledgeList(ctx context.Context, tenant uint64, ids []string) error {+ r.writes+++ return r.KnowledgeRepository.DeleteKnowledgeList(ctx, tenant, ids)+}++type documentChunkSpy struct {+ interfaces.ChunkRepository+ writes int+ imageErr error+}++func (r *documentChunkSpy) CreateChunks(ctx context.Context, chunks []*types.Chunk) error {+ r.writes+++ return r.ChunkRepository.CreateChunks(ctx, chunks)+}++func (r *documentChunkSpy) UpdateChunks(ctx context.Context, chunks []*types.Chunk) error {+ r.writes+++ return r.ChunkRepository.UpdateChunks(ctx, chunks)+}++func (r *documentChunkSpy) UpdateChunk(ctx context.Context, chunk *types.Chunk) error {+ r.writes+++ return r.ChunkRepository.UpdateChunk(ctx, chunk)+}++func (r *documentChunkSpy) DeleteChunks(ctx context.Context, tenant uint64, ids []string) error {+ r.writes+++ return r.ChunkRepository.DeleteChunks(ctx, tenant, ids)+}++func (r *documentChunkSpy) DeleteChunk(ctx context.Context, tenant uint64, id string) error {+ r.writes+++ return r.ChunkRepository.DeleteChunk(ctx, tenant, id)+}++func (r *documentChunkSpy) DeleteByKnowledgeList(ctx context.Context, tenant uint64, ids []string) error {+ r.writes+++ return r.ChunkRepository.DeleteByKnowledgeList(ctx, tenant, ids)+}++func (r *documentChunkSpy) DeleteChunksByKnowledgeID(ctx context.Context, tenant uint64, id string) error {+ r.writes+++ return r.ChunkRepository.DeleteChunksByKnowledgeID(ctx, tenant, id)+}++func (r *documentChunkSpy) SaveChunkRevision(+ ctx context.Context,+ chunk *types.Chunk,+ rev *types.ChunkRevision,+ expected int,+) error {+ r.writes+++ return r.ChunkRepository.SaveChunkRevision(ctx, chunk, rev, expected)+}++func (r *documentChunkSpy) ListImageInfoByKnowledgeIDs(+ ctx context.Context,+ tenant uint64,+ ids []string,+) ([]interfaces.ChunkImageInfo, error) {+ if r.imageErr != nil {+ return nil, r.imageErr+ }+ return r.ChunkRepository.ListImageInfoByKnowledgeIDs(ctx, tenant, ids)+}++type documentGraphSpy struct {+ interfaces.RetrieveGraphRepository+ err error+ calls int+}++func (r *documentGraphSpy) DelGraph(context.Context, []types.NameSpace) error {+ r.calls+++ return r.err+}++type documentTenantSpy struct {+ interfaces.TenantRepository+ adjustments []int64+}++func (r *documentTenantSpy) GetTenantByID(_ context.Context, id uint64) (*types.Tenant, error) {+ return &types.Tenant{ID: id}, nil+}++func (r *documentTenantSpy) AdjustStorageUsed(_ context.Context, _ uint64, delta int64) error {+ r.adjustments = append(r.adjustments, delta)+ return nil+}++type documentFileSpy struct {+ interfaces.FileService+ deleted []string+ beforeDelete func()+}++func (r *documentFileSpy) DeleteFile(_ context.Context, path string) error {+ if r.beforeDelete != nil {+ r.beforeDelete()+ }+ r.deleted = append(r.deleted, path)+ return nil+}++type documentWriteFixture struct {+ svc *knowledgeService+ chunks *chunkService+ repo *documentKnowledgeSpy+ chunkRepo *documentChunkSpy+ kbs *documentKBLookup+ graph *documentGraphSpy+ files *documentFileSpy+ tenants *documentTenantSpy+ db *gorm.DB+ ctx context.Context+}++func newDocumentWriteFixture(t *testing.T) *documentWriteFixture {+ t.Helper()+ db, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "document.db")), &gorm.Config{})+ require.NoError(t, err)+ sqlDB, err := db.DB()+ require.NoError(t, err)+ sqlDB.SetMaxOpenConns(1)+ t.Cleanup(func() { require.NoError(t, sqlDB.Close()) })+ require.NoError(+ t,+ db.AutoMigrate(+ &types.Knowledge{},+ &types.Chunk{},+ &types.KnowledgeTag{},+ &types.KnowledgeTagRelation{},+ &types.ChunkRevision{},+ ),+ )+ repo := &documentKnowledgeSpy{KnowledgeRepository: repository.NewKnowledgeRepository(db)}+ chunkRepo := &documentChunkSpy{ChunkRepository: repository.NewChunkRepository(db)}+ kbs := &documentKBLookup{values: map[string]*types.KnowledgeBase{+ "kb": {ID: "kb", TenantID: 7}, "other": {ID: "other", TenantID: 7},+ }}+ for _, row := range []*types.Knowledge{+ {+ ID: "doc",+ TenantID: 7,+ KnowledgeBaseID: "kb",+ Title: "original",+ Type: types.KnowledgeTypeManual,+ ParseStatus: types.ManualKnowledgeStatusDraft,+ StorageSize: 5,+ },++ {+ ID: "other-doc",+ TenantID: 7,+ KnowledgeBaseID: "other",+ Title: "other",+ ParseStatus: types.ParseStatusCompleted,+ },+ } {+ require.NoError(t, db.Create(row).Error)+ }+ for _, row := range []*types.Chunk{+ {+ ID: "chunk",+ TenantID: 7,+ KnowledgeID: "doc",+ KnowledgeBaseID: "kb",+ ChunkType: types.ChunkTypeText,+ Content: "original",+ IndexStatus: "ready",+ },++ {+ ID: "other-chunk",+ TenantID: 7,+ KnowledgeID: "other-doc",+ KnowledgeBaseID: "other",+ ChunkType: types.ChunkTypeText,+ },+ } {+ require.NoError(t, db.Create(row).Error)+ }+ require.NoError(t, db.Create(&types.KnowledgeTag{ID: "tag", TenantID: 7, KnowledgeBaseID: "kb", Name: "tag"}).Error)+ graph, files, tenants := &documentGraphSpy{}, &documentFileSpy{}, &documentTenantSpy{}+ chunks := &chunkService{chunkRepository: chunkRepo, knowledgeRepo: repo, kbRepository: documentKBRepo{lookup: kbs}}+ svc := &knowledgeService{+ repo: repo,+ chunkRepo: chunkRepo,+ chunkService: chunks,+ kbService: kbs,+ graphEngine: graph,+ fileSvc: files,+ tenantRepo: tenants,+ tagRepo: repository.NewKnowledgeTagRepository(db),+ }+ ctx := types.WithCaller(+ context.Background(),+ types.Caller{TenantID: 1, UserID: "editor", Role: types.TenantRoleAdmin},+ )+ grant := &access.KBAccess{+ KnowledgeBase: kbs.values["kb"],+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }+ ctx = grant.Context(ctx)+ ctx = context.WithValue(ctx, types.TenantInfoContextKey, &types.Tenant{ID: 7})+ return &documentWriteFixture{+ svc: svc,+ chunks: chunks,+ repo: repo,+ chunkRepo: chunkRepo,+ kbs: kbs,+ graph: graph,+ files: files,+ tenants: tenants,+ db: db,+ ctx: ctx,+ }+}++func requireForbiddenWrite(t *testing.T, err error) {+ t.Helper()+ var appErr *apperrors.AppError+ require.ErrorAs(t, err, &appErr)+ require.Equal(t, 403, appErr.HTTPCode)+}++func (f *documentWriteFixture) requireNoWrites(t *testing.T) {+ t.Helper()+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.chunkRepo.writes)+ require.Zero(t, f.graph.calls)+ require.Empty(t, f.files.deleted)+}++func TestDocumentAndChunkWritesRequireOperationGrant(t *testing.T) {+ f := newDocumentWriteFixture(t)+ ctx := types.WithExecutionTenant(+ types.WithCaller(context.Background(), types.Caller{TenantID: 7, Role: types.TenantRoleAdmin}),+ 7,+ )+ // Even an owner read resolution projects Admin without authorizing writes.+ grant, err := access.ResolveKB(+ ctx,+ access.KBRequest{Caller: types.CallerFromContext(ctx)},+ f.kbs.values["kb"],+ types.OrgRoleViewer,+ nil,+ nil,+ )+ require.NoError(t, err)+ ctx = grant.Context(ctx)+ row, _ := f.chunkRepo.GetChunkByID(f.ctx, 7, "chunk")+ ops := map[string]func() error{+ "set tags": func() error { return f.svc.SetKnowledgeTags(ctx, "doc", nil) },+ "move folder": func() error {+ _,+ err := f.svc.MoveKnowledgeToFolder(ctx,+ "kb",+ []string{"doc"},+ "folder")+ return err+ },++ "rename folder": func() error {+ _,+ err := f.svc.RenameKnowledgeFolder(ctx,+ "kb",+ "folder",+ "next")+ return err+ },++ "metadata": func() error { return f.svc.UpdateKnowledge(ctx, &types.Knowledge{ID: "doc", Title: "new"}) },+ "manual": func() error {+ _, err := f.svc.UpdateManualKnowledge(+ ctx,+ "doc",+ &types.ManualKnowledgePayload{Content: "body", Status: "draft"},+ )+ return err+ },+ "tag": func() error { return f.svc.UpdateKnowledgeTag(ctx, "doc", []string{"tag"}) },+ "batch tags": func() error {+ return f.svc.UpdateKnowledgeTagBatch(ctx,+ "",+ map[string][]string{"doc": {"tag"}})+ },++ "delete document": func() error { return f.svc.DeleteKnowledge(ctx, "doc") },+ "delete documents": func() error { return f.svc.DeleteKnowledgeList(ctx, []string{"doc"}) },+ "create chunks": func() error { return f.chunks.CreateChunks(ctx, []*types.Chunk{row}) },+ "update chunk": func() error { return f.chunks.UpdateChunk(ctx, row) },+ "update chunks": func() error { return f.chunks.UpdateChunks(ctx, []*types.Chunk{row}) },+ "edit chunk": func() error {+ body := "new"+ _, err := f.chunks.UpdateDocumentChunk(ctx, "chunk", &body, nil, nil)+ return err+ },+ "upsert question": func() error {+ _,+ err := f.chunks.UpsertGeneratedQuestion(ctx,+ "chunk",+ "",+ "new question")+ return err+ },++ "delete question": func() error { return f.chunks.DeleteGeneratedQuestion(ctx, "chunk", "q") },+ "regenerate questions": func() error {+ _,+ err := f.svc.RegenerateChunkQuestions(ctx,+ "chunk")+ return err+ },++ "update image": func() error { return f.svc.UpdateImageInfo(ctx, "doc", "chunk", "[]") },+ "delete chunk": func() error { return f.chunks.DeleteChunk(ctx, "chunk") },+ "delete chunks": func() error { return f.chunks.DeleteChunks(ctx, []string{"chunk"}) },+ "delete document chunks": func() error { return f.chunks.DeleteChunksByKnowledgeID(ctx, "doc") },+ "delete batch document chunks": func() error { return f.chunks.DeleteByKnowledgeList(ctx, []string{"doc"}) },+ }+ for name, op := range ops {+ t.Run(name, func(t *testing.T) { requireForbiddenWrite(t, op()); f.requireNoWrites(t) })+ }+ require.NoError(t, f.svc.UpdateKnowledge(f.ctx, &types.Knowledge{ID: "doc", Title: "shared edit"}))+ stored, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, "shared edit", stored.Title)+}++func TestDocumentBatchPreflightDoesNotPartiallyMutate(t *testing.T) {+ for _, invalid := range []string{"other-doc", "missing", ""} {+ t.Run(invalid, func(t *testing.T) {+ f := newDocumentWriteFixture(t)+ require.Error(t, f.svc.DeleteKnowledgeList(f.ctx, []string{"doc", invalid}))+ f.requireNoWrites(t)+ require.Error(+ t,+ f.svc.UpdateKnowledgeTagBatch(f.ctx, "", map[string][]string{"doc": {"tag"}, invalid: nil}),+ )+ f.requireNoWrites(t)+ _, err := f.svc.MoveKnowledgeToFolder(f.ctx, "kb", []string{"doc", invalid}, "next")+ require.Error(t, err)+ f.requireNoWrites(t)+ require.Error(t, f.chunks.DeleteByKnowledgeList(f.ctx, []string{"doc", invalid}))+ f.requireNoWrites(t)+ })+ }+ for _, invalid := range []string{"other-chunk", "missing", ""} {+ t.Run("chunks/"+invalid, func(t *testing.T) {+ f := newDocumentWriteFixture(t)+ require.Error(t, f.chunks.DeleteChunks(f.ctx, []string{"chunk", invalid}))+ f.requireNoWrites(t)+ good, err := f.chunkRepo.GetChunkByID(f.ctx, 7, "chunk")+ require.NoError(t, err)+ forged := *good+ forged.ID = invalid+ require.Error(t, f.chunks.UpdateChunks(f.ctx, []*types.Chunk{good, &forged}))+ f.requireNoWrites(t)+ })+ }+}++func TestDeletePreflightResolvesKBAndImagesBeforeChangingStatus(t *testing.T) {+ for _, stage := range []string{"KB lookup", "KB owner", "image lookup"} {+ t.Run(stage, func(t *testing.T) {+ f := newDocumentWriteFixture(t)+ switch stage {+ case "KB lookup":+ f.kbs.err = errors.New("database unavailable")+ case "KB owner":+ f.kbs.values["kb"].TenantID = 9+ case "image lookup":+ f.chunkRepo.imageErr = errors.New("database unavailable")+ }+ require.Error(t, f.svc.DeleteKnowledge(f.ctx, "doc"))+ f.requireNoWrites(t)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, types.ManualKnowledgeStatusDraft, row.ParseStatus)+ })+ }+}++func deleteDocumentTask(t *testing.T, payload types.KnowledgeListDeletePayload) *asynq.Task {+ t.Helper()+ data, err := json.Marshal(payload)+ require.NoError(t, err)+ return asynq.NewTask(types.TypeKnowledgeListDelete, data)+}++func TestDeleteTaskScopeRejectsMovedDocumentsBeforeAnyMutation(t *testing.T) {+ f := newDocumentWriteFixture(t)+ task := deleteDocumentTask(+ t,+ types.KnowledgeListDeletePayload{+ TenantID: 7,+ KnowledgeBaseID: "kb",+ KnowledgeIDs: []string{"doc", "other-doc"},+ },+ )+ require.ErrorIs(t, f.svc.ProcessKnowledgeListDelete(context.Background(), task), asynq.SkipRetry)+ f.requireNoWrites(t)+ task = deleteDocumentTask(+ t,+ types.KnowledgeListDeletePayload{TenantID: 7, KnowledgeIDs: []string{"doc", "other-doc"}},+ )+ require.ErrorIs(t, f.svc.ProcessKnowledgeListDelete(context.Background(), task), asynq.SkipRetry)+ f.requireNoWrites(t)+}++func TestDeleteTaskRetriesAfterPartialCleanupAndAlreadyDeletedRows(t *testing.T) {+ f := newDocumentWriteFixture(t)+ require.NoError(t, f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("file_path", "local://doc").Error)+ task := deleteDocumentTask(+ t,+ types.KnowledgeListDeletePayload{+ TenantID: 7,+ KnowledgeBaseID: "kb",+ KnowledgeIDs: []string{"doc", "doc", "already-gone"},+ },+ )+ f.graph.err = errors.New("graph unavailable")+ err := f.svc.ProcessKnowledgeListDelete(context.Background(), task)+ require.ErrorContains(t, err, "graph unavailable")+ require.NotErrorIs(t, err, asynq.SkipRetry)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, types.ParseStatusDeleting, row.ParseStatus)+ require.Empty(t, f.files.deleted)+ require.Empty(t, f.tenants.adjustments)+ f.graph.err = nil+ f.files.beforeDelete = func() { _, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc"); require.Error(t, err) }+ require.NoError(t, f.svc.ProcessKnowledgeListDelete(context.Background(), task))+ require.Equal(t, []string{"local://doc"}, f.files.deleted)+ require.Equal(t, []int64{-5}, f.tenants.adjustments)+ // A completed task does not need live KB metadata or current user grants.+ delete(f.kbs.values, "kb")+ writes, calls := f.repo.writes, f.graph.calls+ require.NoError(t, f.svc.ProcessKnowledgeListDelete(context.Background(), task))+ require.Equal(t, writes, f.repo.writes)+ require.Equal(t, calls, f.graph.calls)+}++func TestKnowledgeCleanupScopeCannotAuthorizeGeneralWritesOrExtraIDs(t *testing.T) {+ f := newDocumentWriteFixture(t)+ ctx := withKnowledgeCleanup(context.Background(), 7, map[string]string{"doc": "kb"})+ require.Zero(t, types.CallerFromContext(ctx).TenantID)+ requireForbiddenWrite(t, f.svc.UpdateKnowledge(ctx, &types.Knowledge{ID: "doc", Title: "no"}))+ requireForbiddenWrite(t, f.svc.DeleteKnowledgeList(ctx, []string{"doc", "other-doc"}))+ requireForbiddenWrite(+ t,+ f.svc.DeleteKnowledgeList(types.WithCaller(ctx, types.Caller{TenantID: 7}), []string{"doc"}),+ )+ f.requireNoWrites(t)+ require.NoError(t, f.svc.DeleteKnowledge(ctx, "doc"))+}++func TestReferencedKnowledgeCleanupPinsItsIndependentKB(t *testing.T) {+ f := newDocumentWriteFixture(t)+ requireForbiddenWrite(t, deleteReferencedKnowledge(f.ctx, f.svc, "kb", []string{"doc", "other-doc"}))+ f.requireNoWrites(t)+ // Session cleanup authority comes from exact persisted references and can+ // continue even when the caller has no permission to edit the history KB.+ ctx := types.WithExecutionTenant(types.WithCaller(context.Background(), types.Caller{TenantID: 7}), 7)+ require.NoError(t, deleteReferencedKnowledge(ctx, f.svc, "kb", []string{"doc", "already-gone"}))+}++func TestChunkEditRejectsCrossDocumentParentBeforeSavingRevision(t *testing.T) {+ f := newDocumentWriteFixture(t)+ require.NoError(+ t,+ f.db.Model(&types.Chunk{}).Where("id = ?", "chunk").Update("parent_chunk_id", "other-chunk").Error,+ )+ body := "edit"+ _, err := f.chunks.UpdateDocumentChunk(f.ctx, "chunk", &body, nil, nil)+ requireForbiddenWrite(t, err)+ f.requireNoWrites(t)+}++func TestChunkEditRejectsCrossDocumentChildBeforeSavingRevision(t *testing.T) {+ f := newDocumentWriteFixture(t)+ require.NoError(+ t,+ f.db.Model(&types.Chunk{}).Where("id = ?", "other-chunk").Update("parent_chunk_id", "chunk").Error,+ )+ body := "edit"+ _, err := f.chunks.UpdateDocumentChunk(f.ctx, "chunk", &body, nil, nil)+ requireForbiddenWrite(t, err)+ f.requireNoWrites(t)+}++func TestChunkBatchWriteAllowsOnlyStoredOwnership(t *testing.T) {+ f := newDocumentWriteFixture(t)+ row, err := f.chunkRepo.GetChunkByID(f.ctx, 7, "chunk")+ require.NoError(t, err)+ row.Content = "updated"+ require.NoError(t, f.chunks.UpdateChunks(f.ctx, []*types.Chunk{row}))+ stored, err := f.chunkRepo.GetChunkByID(f.ctx, 7, "chunk")+ require.NoError(t, err)+ require.Equal(t, "updated", stored.Content)+ require.NoError(t, f.chunks.DeleteChunks(f.ctx, []string{"chunk", "chunk"}))+ _, err = f.chunkRepo.GetChunkByID(f.ctx, 7, "chunk")+ require.ErrorIs(t, err, repository.ErrChunkNotFound)+}++func TestDocumentWriteTaskAndAPIKeyScopesStayNarrow(t *testing.T) {+ f := newDocumentWriteFixture(t)+ ctx, err := access.WithKBTaskWrite(context.Background(), f.kbs.values["kb"], 7)+ require.NoError(t, err)+ require.NoError(t, f.svc.UpdateKnowledge(ctx, &types.Knowledge{ID: "doc", Title: "worker edit"}))+ requireForbiddenWrite(t, f.svc.UpdateKnowledge(ctx, &types.Knowledge{ID: "other-doc", Title: "no"}))+ scope := types.TenantAPIKeyScope{+ KnowledgeBaseIDs: types.StringArray{"kb"},+ Capabilities: types.StringArray{string(types.APIKeyCapabilityRetrieve)},+ }+ requireForbiddenWrite(+ t,+ f.svc.UpdateKnowledge(types.WithTenantAPIKeyScope(f.ctx, scope), &types.Knowledge{ID: "doc", Title: "no"}),+ )+ require.Zero(t, types.CallerFromContext(ctx).TenantID)+}++func TestLegacySingleKBDeleteTaskRemainsExecutable(t *testing.T) {+ f := newDocumentWriteFixture(t)+ task := deleteDocumentTask(+ t,+ types.KnowledgeListDeletePayload{TenantID: 7, KnowledgeIDs: []string{"doc", "already-gone"}},+ )+ require.NoError(t, f.svc.ProcessKnowledgeListDelete(context.Background(), task))+ _, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.Error(t, err)+}++func TestMultiKBDeleteRequiresAndAcceptsEveryKBGrant(t *testing.T) {+ f := newDocumentWriteFixture(t)+ grant := &access.KBAccess{+ KnowledgeBase: f.kbs.values["other"],+ Caller: types.CallerFromContext(f.ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }+ require.NoError(t, f.svc.DeleteKnowledgeList(grant.Context(f.ctx), []string{"doc", "other-doc"}))+ rows, err := f.repo.GetKnowledgeBatch(f.ctx, 7, []string{"doc", "other-doc"})+ require.NoError(t, err)+ require.Empty(t, rows)+}++func TestDeleteCheckpointRejectsChangedOrDeletedDocument(t *testing.T) {+ for _, action := range []string{"moved", "deleted"} {+ t.Run(action, func(t *testing.T) {+ f := newDocumentWriteFixture(t)+ plan, err := f.svc.planKnowledgeDelete(f.ctx, []string{"doc"})+ require.NoError(t, err)+ if action == "moved" {+ require.NoError(+ t,+ f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("knowledge_base_id", "other").Error,+ )+ } else {+ require.NoError(t, f.db.Where("id = ?", "doc").Delete(&types.Knowledge{}).Error)+ }+ require.Error(t, f.svc.executeKnowledgeDelete(plan, true))+ require.Zero(t, f.graph.calls)+ require.Zero(t, f.chunkRepo.writes)+ require.Empty(t, f.files.deleted)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ if action == "moved" {+ require.NoError(t, err)+ require.Equal(t, "other", row.KnowledgeBaseID)+ require.Equal(t, types.ManualKnowledgeStatusDraft, row.ParseStatus)+ } else {+ require.Error(t, err)+ }+ })+ }+}++func TestDocumentWritesRejectMoveInProgress(t *testing.T) {+ f := newDocumentWriteFixture(t)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(t, setTransferState(row, knowledgeTransferState{Operation: access.KBTransferMove, Phase: "moving"}))+ require.NoError(t, f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("metadata", row.Metadata).Error)+ for _, op := range []func() error{+ func() error { return f.svc.DeleteKnowledge(f.ctx, "doc") },+ func() error { return f.svc.UpdateKnowledge(f.ctx, &types.Knowledge{ID: "doc", Title: "changed"}) },+ func() error { return f.chunks.DeleteChunk(f.ctx, "chunk") },+ func() error { return f.svc.DeleteKnowledgeList(f.ctx, []string{"doc"}) },+ } {+ var appErr *apperrors.AppError+ require.ErrorAs(t, op(), &appErr)+ require.Equal(t, 409, appErr.HTTPCode)+ }+ f.requireNoWrites(t)+}diff --git a/internal/application/service/evaluation.go b/internal/application/service/evaluation.goindex 184613f25..4a3844cb4 100644--- a/internal/application/service/evaluation.go+++ b/internal/application/service/evaluation.go@@ -363,7 +363,10 @@ func (e *EvaluationService) EvalDataset(ctx context.Context, detail *types.Evalu// Setup cleanup of temporary resourcesdefer func() {logger.Infof(ctx, "Cleaning up resources - deleting knowledge: %s", knowledge.ID)- if err := e.knowledgeService.DeleteKnowledge(ctx, knowledge.ID); err != nil {+ if err := deleteReferencedKnowledge(ctx,+ e.knowledgeService,+ knowledgeBaseID,+ []string{knowledge.ID}); err != nil {logger.Errorf(ctx, "Failed to delete knowledge: %v, knowledge ID: %s", err, knowledge.ID)}diff --git a/internal/application/service/extract.go b/internal/application/service/extract.goindex 3d789d6d2..d43afe01b 100644--- a/internal/application/service/extract.go+++ b/internal/application/service/extract.go@@ -10,6 +10,7 @@ import ("time""github.com/Tencent/WeKnora/internal/agent/tools"+ "github.com/Tencent/WeKnora/internal/application/access"chatpipeline "github.com/Tencent/WeKnora/internal/application/service/chat_pipeline""github.com/Tencent/WeKnora/internal/application/service/retriever""github.com/Tencent/WeKnora/internal/config"@@ -468,7 +469,7 @@ func (s *DataTableSummaryService) Handle(ctx context.Context, t *asynq.Task) errctx = logger.WithRequestID(ctx, uuid.New().String())ctx = logger.WithField(ctx, "knowledge", payload.KnowledgeID)- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)logger.Infof(ctx, "Processing table extraction for knowledge: %s", payload.KnowledgeID)@@ -478,6 +479,12 @@ func (s *DataTableSummaryService) Handle(ctx context.Context, t *asynq.Task) errreturn err}+ ctx, err = access.WithKBTaskWrite(ctx, resources.knowledgeBase, payload.TenantID)+ if err != nil {+ return err+ }+ ctx = context.WithValue(ctx, types.TenantInfoContextKey, resources.tenant)+// 3. 加载表格数据并生成摘要chunks, err := s.processTableData(ctx, resources)if err != nil {@@ -508,12 +515,20 @@ type extractionResources struct {// 思路:集中加载所有依赖,统一错误处理,避免分散的资源获取逻辑func (s *DataTableSummaryService) prepareResources(ctx context.Context, payload DataTableSummaryPayload) (*extractionResources, error) {// 获取并验证知识文件- knowledge, err := s.knowledgeService.GetKnowledgeByID(ctx, payload.KnowledgeID)+ knowledge, err := s.knowledgeService.GetRepository().GetKnowledgeByID(ctx, payload.TenantID, payload.KnowledgeID)if err != nil {logger.Errorf(ctx, "failed to get knowledge: %v", err)return nil, err}+ if knowledge == nil || knowledge.ID != payload.KnowledgeID || knowledge.TenantID != payload.TenantID {+ return nil, fmt.Errorf("invalid table summary knowledge scope")+ }+ kb, err := knowledgeWriteKB(ctx, s.knowledgeBaseService, knowledge)+ if err != nil {+ return nil, err+ }+// 验证文件类型fileType := strings.ToLower(knowledge.FileType)if fileType != "csv" && fileType != "xlsx" && fileType != "xls" {@@ -542,13 +557,6 @@ func (s *DataTableSummaryService) prepareResources(ctx context.Context, payloadreturn nil, err}- // Load the KB to discover its VectorStoreID binding so the factory can- // route to the bound store (or fall back to tenant engines if unbound).- kb, err := s.knowledgeBaseService.GetKnowledgeBaseByID(ctx, knowledge.KnowledgeBaseID)- if err != nil {- logger.Errorf(ctx, "failed to get knowledge base for vector store lookup: %v", err)- return nil, err- }var vectorStoreID *stringif kb != nil {vectorStoreID = kb.VectorStoreID@@ -774,12 +782,12 @@ func (s *DataTableSummaryService) cleanupOnFailure(ctx context.Context, resourcelogger.Warnf(ctx, "Starting cleanup due to failure: %v", indexErr)// 1. 更新知识状态为失败- resources.knowledge.ParseStatus = types.ParseStatusFailed- resources.knowledge.ErrorMessage = indexErr.Error()- if err := s.knowledgeService.UpdateKnowledge(ctx, resources.knowledge); err != nil {- logger.Errorf(ctx, "Failed to update knowledge status: %v", err)- } else {- logger.Infof(ctx, "Updated knowledge %s status to failed", resources.knowledge.ID)+ before, after := *resources.knowledge, *resources.knowledge+ after.ParseStatus = types.ParseStatusFailed+ after.ErrorMessage = indexErr.Error()+ if err := s.knowledgeService.GetRepository().UpdateKnowledgeForTransfer(ctx, &before, &after); err != nil {+ logger.Warnf(ctx, "Table summary cleanup skipped after knowledge changed: %v", err)+ return}// 提取chunk IDs@@ -790,7 +798,7 @@ func (s *DataTableSummaryService) cleanupOnFailure(ctx context.Context, resource// 删除已创建的chunksif len(chunkIDs) > 0 {- if err := s.chunkService.DeleteChunks(ctx, chunkIDs); err != nil {+ if err := s.chunkService.GetRepository().DeleteChunks(ctx, resources.knowledge.TenantID, chunkIDs); err != nil {logger.Errorf(ctx, "Failed to delete chunks: %v", err)} else {logger.Infof(ctx, "Deleted %d chunks", len(chunkIDs))diff --git a/internal/application/service/file/resolve_tenant.go b/internal/application/service/file/resolve_tenant.gonew file mode 100644index 000000000..fe67ec9fb--- /dev/null+++ b/internal/application/service/file/resolve_tenant.go@@ -0,0 +1,69 @@+package file++import (+ "context"+ "net/http"+ "os"+ "strings"++ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+)++// ResolveTenantFileServiceWithFallback applies the storage resolution and+// fallback rule shared by file proxies and artifact downloads: when tenant-level+// resolution fails and the requested provider matches the process-global+// STORAGE_TYPE, serve through the global file service instead of failing.+// Returns ok=false (already logged) when no service can be resolved; the+// caller decides the HTTP status.+func ResolveTenantFileServiceWithFallback(+ ctx context.Context,+ logTag string,+ tenant *types.Tenant,+ backendID, provider, absDir string,+ storageResolver interfaces.StorageBackendResolver,+ globalFileService interfaces.FileService,+) (fileSvc interfaces.FileService, resolvedProvider string, ok bool) {+ var err error+ if storageResolver != nil {+ fileSvc, resolvedProvider, err = storageResolver.ResolveFileService(ctx, tenant, backendID, provider, absDir)+ } else if tenant.StorageEngineConfig != nil {+ fileSvc, resolvedProvider, err = NewFileServiceFromStorageConfig(provider, tenant.StorageEngineConfig, absDir)+ } else {+ err = http.ErrMissingFile+ }+ if err == nil {+ return fileSvc, resolvedProvider, true+ }++ globalStorageType := strings.ToLower(strings.TrimSpace(os.Getenv("STORAGE_TYPE")))+ if globalStorageType == "" {+ globalStorageType = "local"+ }+ if provider == globalStorageType && globalFileService != nil {+ logger.Warnf(+ ctx,+ "[Router] %s tenant storage config missing or invalid, fallback to global file "++ "service: tenant_id=%d provider=%s err=%v",++ logTag,+ tenant.ID,+ provider,+ err,+ )+ return globalFileService, globalStorageType, true+ }+ logger.Warnf(+ ctx,+ "[Router] %s resolve file service failed without fallback: tenant_id=%d "++ "provider=%s global_storage_type=%s err=%v",++ logTag,+ tenant.ID,+ provider,+ globalStorageType,+ err,+ )+ return nil, "", false+}diff --git a/internal/application/service/image_multimodal.go b/internal/application/service/image_multimodal.goindex 46b4d892c..aedd671c7 100644--- a/internal/application/service/image_multimodal.go+++ b/internal/application/service/image_multimodal.go@@ -342,7 +342,7 @@ func (s *ImageMultimodalService) Handle(ctx context.Context, task *asynq.Task) e}// Persist chunks- if err := s.chunkService.CreateChunks(ctx, newChunks); err != nil {+ if err := s.chunkService.GetRepository().CreateChunks(ctx, newChunks); err != nil {handleErr = fmt.Errorf("create multimodal chunks: %w", err)return handleErr}@@ -446,7 +446,7 @@ func (s *ImageMultimodalService) indexChunks(ctx context.Context, payload types.continue}dbChunk.Status = int(types.ChunkStatusIndexed)- if uerr := s.chunkService.UpdateChunk(ctx, dbChunk); uerr != nil {+ if uerr := s.chunkService.GetRepository().UpdateChunk(ctx, dbChunk); uerr != nil {logger.Warnf(ctx, "[ImageMultimodal] Failed to update chunk %s status to indexed: %v", chunk.ID, uerr)}}@@ -503,7 +503,7 @@ func (s *ImageMultimodalService) indexChunks(ctx context.Context, payload types.continue}dbChunk.Status = int(types.ChunkStatusIndexed)- if err := s.chunkService.UpdateChunk(ctx, dbChunk); err != nil {+ if err := s.chunkService.GetRepository().UpdateChunk(ctx, dbChunk); err != nil {logger.Warnf(ctx, "[ImageMultimodal] Failed to update chunk %s status to indexed: %v", chunk.ID, err)}}diff --git a/internal/application/service/kbshare.go b/internal/application/service/kbshare.goindex 1b5033fe8..a17676cbf 100644--- a/internal/application/service/kbshare.go+++ b/internal/application/service/kbshare.go@@ -5,6 +5,7 @@ import ("errors""time"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/types"@@ -489,14 +490,7 @@ func (s *kbShareService) CheckTenantKBPermission(ctx context.Context, kbID strin// HasTenantKBPermission is a thin "do I have at least N" wrapper over// CheckTenantKBPermission for callers that don't need the granular role.func (s *kbShareService) HasTenantKBPermission(ctx context.Context, kbID string, callerTenantID uint64, callerTenantRole types.TenantRole, requiredRole types.OrgMemberRole) (bool, error) {- role, isShared, err := s.CheckTenantKBPermission(ctx, kbID, callerTenantID, callerTenantRole)- if err != nil {- return false, err- }- if !isShared {- return false, nil- }- return role.HasPermission(requiredRole), nil+ return access.NewKBSharePermissions(ctx, s, callerTenantID, callerTenantRole).Check(kbID, requiredRole)}// GetKBSourceTenant gets the source tenant ID for a shared knowledge basediff --git a/internal/application/service/knowledge.go b/internal/application/service/knowledge.goindex 7a5139138..16f148b7e 100644--- a/internal/application/service/knowledge.go+++ b/internal/application/service/knowledge.go@@ -7,6 +7,7 @@ import ("fmt""io""reflect"+ "sort""strings""sync""time"@@ -592,7 +593,18 @@ func (s *knowledgeService) MoveKnowledgeToFolder(ctx context.Context,if err != nil {return 0, err}- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)+ rows, err := loadKnowledgeWriteBatch(ctx, s.repo, s.kbService, ids)+ if err != nil {+ return 0, err+ }+ ids = make([]string, 0, len(rows))+ for _, row := range rows {+ if row.KnowledgeBaseID != kbID {+ return 0, werrors.NewForbiddenError("knowledge outside target KB")+ }+ ids = append(ids, row.ID)+ }+ tenantID := rows[0].TenantIDaffected, err := s.repo.UpdateKnowledgeFolderPath(ctx, tenantID, kbID, ids, normalized)if err != nil {logger.Errorf(ctx, "Failed to move knowledge to folder %q: %v", normalized, err)@@ -627,7 +639,18 @@ func (s *knowledgeService) RenameKnowledgeFolder(ctx context.Context,return 0, werrors.NewBadRequestError("不能将文件夹移动到它自己的子目录下")}- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)+ kb, err := s.kbService.GetKnowledgeBaseByID(ctx, kbID)+ if err != nil {+ return 0, err+ }+ if kb == nil || kb.ID != kbID {+ return 0, werrors.NewNotFoundError("knowledge base not found")+ }+ ctx, err = requireKBWrite(ctx, kb)+ if err != nil {+ return 0, err+ }+ tenantID := kb.TenantIDaffected, err := s.repo.RenameKnowledgeFolderPath(ctx, tenantID, kbID, source, target)if err != nil {logger.Errorf(ctx, "Failed to rename folder %q to %q: %v", source, target, err)@@ -689,7 +712,10 @@ func (s *knowledgeService) GetKnowledgeFile(ctx context.Context, id string) (io.}func (s *knowledgeService) UpdateKnowledge(ctx context.Context, knowledge *types.Knowledge) error {- record, err := s.repo.GetKnowledgeByID(ctx, ctx.Value(types.TenantIDContextKey).(uint64), knowledge.ID)+ if knowledge == nil {+ return werrors.NewBadRequestError("knowledge cannot be nil")+ }+ record, _, err := loadKnowledgeWrite(ctx, s.repo, s.kbService, knowledge.ID)if err != nil {logger.Errorf(ctx, "Failed to get knowledge record: %v", err)return err@@ -769,48 +795,48 @@ func (s *knowledgeService) GetKnowledgeBatchWithSharedAccess(ctx context.Contextif len(ids) == 0 {return nil, nil}- ownList, err := s.repo.GetKnowledgeBatch(ctx, tenantID, ids)+ permissions := kbReadPermissions(ctx, s.kbShareService)+ rows, err := s.repo.GetKnowledgeBatch(ctx, tenantID, ids)if err != nil {return nil, err}+ ownList := make([]*types.Knowledge, 0, len(rows))foundSet := make(map[string]bool)- for _, k := range ownList {- if k != nil {+ appendAllowed := func(k *types.Knowledge) {+ if k == nil || foundSet[k.ID] {+ return+ }+ allowed, err := permissions.Check(k.KnowledgeBaseID, k.TenantID, types.OrgRoleViewer)+ if err == nil && allowed {+ ownList = append(ownList, k)foundSet[k.ID] = true}}- userIDVal := ctx.Value(types.UserIDContextKey)- if userIDVal == nil {- return ownList, nil- }- userID, ok := userIDVal.(string)- if !ok || userID == "" {- return ownList, nil+ for _, k := range rows {+ appendAllowed(k)+ if k != nil {+ foundSet[k.ID] = true+ }}- // Plan 3: shared-KB permission is keyed on (tenant, tenant_role)- // rather than user. callerTenantRole drives the 3-D cap.- callerTenantRole := types.TenantRoleFromContext(ctx)for _, id := range ids {if foundSet[id] {continue}k, err := s.repo.GetKnowledgeByIDOnly(ctx, id)- if err != nil || k == nil || k.KnowledgeBaseID == "" {- continue+ if err != nil && !errors.Is(err, repository.ErrKnowledgeNotFound) {+ return nil, err}- hasPermission, err := s.kbShareService.HasTenantKBPermission(ctx, k.KnowledgeBaseID, tenantID, callerTenantRole, types.OrgRoleViewer)- if err != nil || !hasPermission {- continue+ if err == nil {+ appendAllowed(k)}- foundSet[k.ID] = true- ownList = append(ownList, k)+ foundSet[id] = true}return ownList, nil}// SetKnowledgeTags replaces all tags for a single knowledge entry.func (s *knowledgeService) SetKnowledgeTags(ctx context.Context, knowledgeID string, tagIDs []string) error {- return s.repo.SetKnowledgeTags(ctx, knowledgeID, tagIDs)+ return s.UpdateKnowledgeTag(ctx, knowledgeID, tagIDs)}// ListKnowledgeIDsByTagIDs returns document knowledge IDs carrying any of the@@ -909,11 +935,11 @@ func (s *knowledgeService) GetKnowledgeTags(ctx context.Context, knowledgeIDs []// UpdateKnowledgeTag updates the tags assigned to a knowledge document.func (s *knowledgeService) UpdateKnowledgeTag(ctx context.Context, knowledgeID string, tagIDs []string) error {- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)- knowledge, err := s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID)+ knowledge, _, err := loadKnowledgeWrite(ctx, s.repo, s.kbService, knowledgeID)if err != nil {return err}+ tenantID := knowledge.TenantID// Validate all tag IDsif err := s.validateKnowledgeTagIDs(ctx, tenantID, knowledge.KnowledgeBaseID, tagIDs); err != nil {@@ -925,29 +951,25 @@ func (s *knowledgeService) UpdateKnowledgeTag(ctx context.Context, knowledgeID s// UpdateKnowledgeTagBatch updates tags for document knowledge items in batch.// authorizedKBID restricts all updates to knowledge items belonging to this KB;-// pass empty string to skip the check (caller must ensure authorization by other means).-func (s *knowledgeService) UpdateKnowledgeTagBatch(ctx context.Context, authorizedKBID string, updates map[string][]string) error {+// an empty value allows multiple KBs only when every KB has an explicit write grant.+func (s *knowledgeService) UpdateKnowledgeTagBatch(+ ctx context.Context,+ authorizedKBID string,+ updates map[string][]string,+) error {if len(updates) == 0 {return nil}- tenantIDVal := ctx.Value(types.TenantIDContextKey)- if tenantIDVal == nil {- return werrors.NewUnauthorizedError("workspace ID not found in context")- }- tenantID, ok := tenantIDVal.(uint64)- if !ok {- return werrors.NewUnauthorizedError("invalid workspace ID in context")- }-- // Get all knowledge items in batchknowledgeIDs := make([]string, 0, len(updates))- for knowledgeID := range updates {- knowledgeIDs = append(knowledgeIDs, knowledgeID)+ for id := range updates {+ knowledgeIDs = append(knowledgeIDs, id)}- knowledgeList, err := s.repo.GetKnowledgeBatch(ctx, tenantID, knowledgeIDs)+ sort.Strings(knowledgeIDs)+ knowledgeList, err := loadKnowledgeWriteBatch(ctx, s.repo, s.kbService, knowledgeIDs)if err != nil {return err}+ tenantID := knowledgeList[0].TenantID// Validate all requested IDs were found and belong to the authorized KBif authorizedKBID != "" {@@ -1002,15 +1024,15 @@ func (s *knowledgeService) UpdateKnowledgeTagBatch(ctx context.Context, authorizif !ok {return werrors.NewBadRequestError(fmt.Sprintf("标签 %s 不存在", tagID))}- if tag.KnowledgeBaseID != knowledge.KnowledgeBaseID {+ if tag.TenantID != tenantID || tag.KnowledgeBaseID != knowledge.KnowledgeBaseID {return werrors.NewBadRequestError(fmt.Sprintf("标签 %s 不属于知识库 %s", tagID, knowledge.KnowledgeBaseID))}}}// Set tags for each knowledge- for knowledgeID, tagIDs := range updates {- if err := s.repo.SetKnowledgeTags(ctx, knowledgeID, tagIDs); err != nil {+ for _, knowledgeID := range knowledgeIDs {+ if err := s.repo.SetKnowledgeTags(ctx, knowledgeID, updates[knowledgeID]); err != nil {return err}}@@ -1021,10 +1043,12 @@ func (s *knowledgeService) UpdateKnowledgeTagBatch(ctx context.Context, authoriz// SearchKnowledge searches knowledge items by keyword across the tenant and shared knowledge bases.// fileTypes: optional list of file extensions to filter by (e.g., ["csv", "xlsx"])func (s *knowledgeService) SearchKnowledge(ctx context.Context, keyword string, offset, limit int, fileTypes []string) ([]*types.Knowledge, bool, int64, error) {- tenantID, ok := ctx.Value(types.TenantIDContextKey).(uint64)- if !ok {+ caller := types.CallerFromContext(ctx)+ tenantID := caller.TenantID+ if tenantID == 0 {return nil, false, 0, werrors.NewUnauthorizedError("Workspace ID not found in context")}+ ctx = types.WithExecutionTenant(ctx, tenantID)scopes := make([]types.KnowledgeSearchScope, 0)@@ -1041,9 +1065,9 @@ func (s *knowledgeService) SearchKnowledge(ctx context.Context, keyword string,// Shared knowledge bases (document type only). Plan 3 of #1303 keys// the share lookup on (tenantID, callerTenantRole); userID is no// longer load-bearing for org-share access.- if userIDVal := ctx.Value(types.UserIDContextKey); userIDVal != nil {- if userID, ok := userIDVal.(string); ok && userID != "" {- callerTenantRole := types.TenantRoleFromContext(ctx)+ if s.kbShareService != nil {+ if caller.UserID != "" {+ callerTenantRole := caller.RolesharedList, err := s.kbShareService.ListSharedKnowledgeBases(ctx, tenantID, callerTenantRole)if err == nil {for _, info := range sharedList {diff --git a/internal/application/service/knowledge_auto_tag.go b/internal/application/service/knowledge_auto_tag.goindex a2459fe8f..87ab729e5 100644--- a/internal/application/service/knowledge_auto_tag.go+++ b/internal/application/service/knowledge_auto_tag.go@@ -7,6 +7,7 @@ import ("sort""strings"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/common""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/models/chat"@@ -113,7 +114,7 @@ func (s *KnowledgeAutoTagService) Handle(ctx context.Context, task *asynq.Task)if err := json.Unmarshal(task.Payload(), &payload); err != nil {return fmt.Errorf("unmarshal knowledge auto tag payload: %w", err)}- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)if payload.Language != "" {ctx = context.WithValue(ctx, types.LanguageContextKey, payload.Language)}@@ -153,6 +154,10 @@ func (s *KnowledgeAutoTagService) Handle(ctx context.Context, task *asynq.Task)if kb == nil || kb.TenantID != payload.TenantID || kb.Type != types.KnowledgeBaseTypeDocument {return skip("knowledge_base_not_eligible", nil)}+ ctx, err = access.WithKBTaskWrite(ctx, kb, payload.TenantID)+ if err != nil {+ return err+ }config := kb.AutoTagConfigif config == nil || !config.Enabled {return skip("auto_tag_disabled", nil)@@ -251,6 +256,9 @@ func (s *KnowledgeAutoTagService) Handle(ctx context.Context, task *asynq.Task)if len(added) == 0 {return skip("all_matches_already_attached", types.JSONMap{"matched_tag_count": len(validIDs)})}+ if err := access.RequireKBWrite(ctx, kb); err != nil {+ return err+ }if err := s.knowledgeRepo.AddKnowledgeTagRelations(ctx,payload.TenantID,diff --git a/internal/application/service/knowledge_auto_tag_test.go b/internal/application/service/knowledge_auto_tag_test.goindex 4a2145295..2e662edc5 100644--- a/internal/application/service/knowledge_auto_tag_test.go+++ b/internal/application/service/knowledge_auto_tag_test.go@@ -7,6 +7,7 @@ import ("strings""testing"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/models/chat""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces"@@ -36,6 +37,7 @@ type autoTagKnowledgeRepo struct {existing map[string][]*types.KnowledgeTagadded []stringaddErr error+ writeCtx context.Context}func (r *autoTagKnowledgeRepo) GetKnowledgeByIDOnly(context.Context, string) (*types.Knowledge, error) {@@ -49,8 +51,9 @@ func (r *autoTagKnowledgeRepo) GetKnowledgeTags(}func (r *autoTagKnowledgeRepo) AddKnowledgeTagRelations(- _ context.Context, _ uint64, _, _ string, tagIDs []string,+ ctx context.Context, _ uint64, _, _ string, tagIDs []string,) error {+ r.writeCtx = ctxif r.addErr != nil {return r.addErr}@@ -173,6 +176,9 @@ func TestAutoTagHandleAttachesMatchedTags(t *testing.T) {fixture := newAutoTagFixture(t, `{"matches":[{"index":1,"confidence":0.9}]}`)require.NoError(t, fixture.handle(t))assert.Equal(t, []string{"tag-a"}, fixture.repo.added)+ require.Zero(t, types.CallerFromContext(fixture.repo.writeCtx).TenantID)+ require.NoError(t, access.RequireKBWrite(fixture.repo.writeCtx, &types.KnowledgeBase{ID: "kb", TenantID: 7}))+ require.Error(t, access.RequireKBWrite(fixture.repo.writeCtx, &types.KnowledgeBase{ID: "other", TenantID: 7}))}// A missing confidence must not be read as zero: models frequently omit thediff --git a/internal/application/service/knowledge_batch_reparse_test.go b/internal/application/service/knowledge_batch_reparse_test.goindex 5babdab62..c4efc0082 100644--- a/internal/application/service/knowledge_batch_reparse_test.go+++ b/internal/application/service/knowledge_batch_reparse_test.go@@ -5,6 +5,7 @@ import ("errors""testing"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces""github.com/hibiken/asynq"@@ -81,18 +82,21 @@ func TestReparseKnowledgeManualEnqueueFailureIsVisible(t *testing.T) {repo := &reparseFailureKnowledgeRepo{knowledge: knowledge}svc := &knowledgeService{repo: repo,- kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{ID: "kb-1"}},+ kbService: &reparseFailureKBService{kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 7}},task: failingReparseTaskEnqueuer{err: enqueueErr},}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx, grantErr := access.WithKBTaskWrite(ctx, &types.KnowledgeBase{ID: "kb-1", TenantID: 7}, 7)+ require.NoError(t, grantErr)+got, err := svc.ReparseKnowledge(ctx, knowledge.ID, nil)require.Error(t, err)- require.Same(t, knowledge, got)- require.Equal(t, types.ParseStatusFailed, knowledge.ParseStatus)- require.Equal(t, "disabled", knowledge.EnableStatus)- require.Equal(t, "Failed to enqueue processing task", knowledge.ErrorMessage)+ require.NotNil(t, got)+ require.Equal(t, types.ParseStatusFailed, got.ParseStatus)+ require.Equal(t, "disabled", got.EnableStatus)+ require.Equal(t, "Failed to enqueue processing task", got.ErrorMessage)require.GreaterOrEqual(t, repo.updateCalls, 2, "pending and failed states must both be persisted")}diff --git a/internal/application/service/knowledge_caller_scope_test.go b/internal/application/service/knowledge_caller_scope_test.gonew file mode 100644index 000000000..af680ad8a--- /dev/null+++ b/internal/application/service/knowledge_caller_scope_test.go@@ -0,0 +1,186 @@+package service++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++type callerScopeShares struct {+ interfaces.KBShareService+ callers []uint64+}++func (s *callerScopeShares) CheckTenantKBPermission(+ _ context.Context,+ kbID string,+ caller uint64,+ _ types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ s.callers = append(s.callers, caller)+ // Tenant 2 has access to a third tenant's KB; caller 1 does not.+ return types.OrgRoleViewer, kbID == "onward" && caller == 2, nil+}++func TestSharedExecutionFiltersDocumentsChunksAndSearchScope(t *testing.T) {+ shares := &callerScopeShares{}+ svc, db := newKnowledgeSharedAccessService(t, shares)+ require.NoError(t, db.AutoMigrate(&types.Chunk{}))+ kbs := []*types.KnowledgeBase{+ {ID: "own", TenantID: 1},+ {ID: "granted", TenantID: 2},+ {ID: "private", TenantID: 2},+ {ID: "onward", TenantID: 3},+ }+ var ids []string+ for _, kb := range kbs {+ ids = append(ids, kb.ID)+ seedKnowledge(t, db, &types.Knowledge{ID: kb.ID, TenantID: kb.TenantID, KnowledgeBaseID: kb.ID, Type: "file"})+ require.NoError(+ t,+ db.Create(+ &types.Chunk{+ ID: kb.ID,+ TenantID: kb.TenantID,+ KnowledgeBaseID: kb.ID,+ KnowledgeID: kb.ID,+ Content: kb.ID,+ },+ ).Error,+ )+ }+ search := &knowledgeBaseService{+ kgRepo: svc.repo,+ chunkRepo: repository.NewChunkRepository(db),+ kbShareService: shares,+ }+ kbService := &suggestionKBService{kbs: make(map[string]*types.KnowledgeBase)}+ for _, kb := range kbs {+ kbService.kbs[kb.ID] = kb+ }+ session := &sessionService{knowledgeBaseService: kbService, knowledgeService: svc, kbShareService: shares}+ base := newSharedAccessContext()+ grant := &access.KBAccess{+ KnowledgeBase: kbs[1],+ Caller: types.CallerFromContext(base),+ EffectiveTenantID: 2,+ Permission: types.OrgRoleViewer,+ }+ for _, execution := range []uint64{1, 2, 3} {+ ctx := logger.CloneContext(types.WithExecutionTenant(grant.Context(base), execution))+ rows, err := svc.GetKnowledgeBatchWithSharedAccess(ctx, execution, ids)+ require.NoError(t, err)+ got := make([]string, 0, len(rows))+ for _, row := range rows {+ got = append(got, row.ID)+ }+ require.ElementsMatch(t, []string{"own", "granted"}, got)+ knowledgeMap, err := search.fetchKnowledgeDataWithShared(ctx, execution, ids)+ require.NoError(t, err)+ require.Len(t, knowledgeMap, 2)+ require.NotNil(t, knowledgeMap["own"])+ require.NotNil(t, knowledgeMap["granted"])+ chunks, err := search.listChunksByIDWithShared(ctx, execution, ids)+ require.NoError(t, err)+ got = got[:0]+ for _, chunk := range chunks {+ got = append(got, chunk.ID)+ }+ require.ElementsMatch(t, []string{"own", "granted"}, got)+ require.NoError(t, search.authorizeKBAccess(ctx, kbs[:2]))+ require.Error(t, search.authorizeKBAccess(ctx, kbs[2:3]), "execution tenant is not ownership")+ require.Error(t, search.authorizeKBAccess(ctx, kbs[3:]), "source tenant shares are not inherited")+ targets, err := session.buildSearchTargets(+ ctx,+ execution,+ ids,+ nil,+ []types.TagScope{{KnowledgeBaseID: "private", TagIDs: []string{"tag"}}},+ )+ require.NoError(t, err)+ require.Len(t, targets, 2, "denied KBs must not become search or tag targets")+ got = got[:0]+ for _, target := range targets {+ got = append(got, target.KnowledgeBaseID)+ }+ require.ElementsMatch(t, []string{"own", "granted"}, got)+ _, err = resolveKBReadTenant(ctx, kbs[1], shares)+ require.NoError(t, err, "FAQ/tag reads accept the exact upstream grant")+ _, err = resolveKBReadTenant(ctx, kbs[2], shares)+ require.Error(t, err, "FAQ/tag reads cannot access another KB in the execution tenant")+ }+ for _, caller := range shares.callers {+ require.Equal(t, uint64(1), caller)+ }+}++type callerScopeKBList struct {+ interfaces.KnowledgeBaseService+ tenant uint64+}++func (s *callerScopeKBList) ListKnowledgeBases(ctx context.Context) ([]*types.KnowledgeBase, error) {+ s.tenant = types.MustTenantIDFromContext(ctx)+ return []*types.KnowledgeBase{{ID: "own", TenantID: s.tenant, Type: types.KnowledgeBaseTypeDocument}}, nil+}++type callerScopeSearchRepo struct {+ interfaces.KnowledgeRepository+ scopes []types.KnowledgeSearchScope+}++func (r *callerScopeSearchRepo) SearchKnowledgeInScopes(+ _ context.Context,+ scopes []types.KnowledgeSearchScope,+ _ string,+ _, _ int,+ _ []string,+) ([]*types.Knowledge, bool, int64, error) {+ r.scopes = scopes+ return nil, false, 0, nil+}++func TestDocumentSearchListsCallerTenantAfterExecutionSwitch(t *testing.T) {+ kbs := &callerScopeKBList{}+ repo := &callerScopeSearchRepo{}+ svc := &knowledgeService{kbService: kbs, repo: repo}+ ctx := types.WithExecutionTenant(newSharedAccessContext(), 2)+ _, _, _, err := svc.SearchKnowledge(ctx, "query", 0, 10, nil)+ require.NoError(t, err)+ require.Equal(t, uint64(1), kbs.tenant)+ require.Equal(t, []types.KnowledgeSearchScope{{TenantID: 1, KBID: "own"}}, repo.scopes)+ require.Equal(t, uint64(2), types.MustTenantIDFromContext(ctx), "search must not mutate the parent context")+}++func TestSharedAgentBatchUsesGrantInsteadOfSourceTenantOwnership(t *testing.T) {+ svc, db := newKnowledgeSharedAccessService(t, &callerScopeShares{})+ for _, kbID := range []string{"selected", "private"} {+ seedKnowledge(t, db, &types.Knowledge{ID: kbID, TenantID: 2, KnowledgeBaseID: kbID, Type: "file"})+ }+ agent := &types.CustomAgent{+ TenantID: 2,+ Config: types.CustomAgentConfig{KBSelectionMode: "selected", KnowledgeBases: []string{"selected"}},+ }+ ctx := logger.CloneContext(access.WithSharedAgent(newSharedAccessContext(), agent))+ rows, err := svc.GetKnowledgeBatchWithSharedAccess(ctx, 2, []string{"selected", "private"})+ require.NoError(t, err)+ require.Len(t, rows, 1)+ require.Equal(t, "selected", rows[0].ID)+ ctx = types.WithTenantAPIKeyScope(ctx, types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"private"}})+ search := &knowledgeBaseService{}+ app, ok := apperrors.IsAppError(+ search.authorizeKBAccess(ctx, []*types.KnowledgeBase{{ID: "selected", TenantID: 2}}),+ )+ require.True(t, ok)+ require.Equal(t, apperrors.ErrForbidden, app.Code, "API-key scope denial must not become a lookup failure")+ rows, err = svc.GetKnowledgeBatchWithSharedAccess(ctx, 2, []string{"selected", "private"})+ require.NoError(t, err)+ require.Empty(t, rows)+}diff --git a/internal/application/service/knowledge_cleanup_regression_test.go b/internal/application/service/knowledge_cleanup_regression_test.gonew file mode 100644index 000000000..035e75346--- /dev/null+++ b/internal/application/service/knowledge_cleanup_regression_test.go@@ -0,0 +1,133 @@+package service++import (+ "context"+ "encoding/json"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/hibiken/asynq"+ "github.com/stretchr/testify/require"+)++func TestDeleteTaskMovingConflictStopsRetries(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(t, setTransferState(row, knowledgeTransferState{Operation: access.KBTransferMove, Phase: "moving"}))+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ beforeWrites := f.repo.writes+ raw, err := json.Marshal(+ types.KnowledgeListDeletePayload{TenantID: 7, KnowledgeBaseID: "kb", KnowledgeIDs: []string{"doc"}},+ )+ require.NoError(t, err)+ err = f.svc.ProcessKnowledgeListDelete(context.Background(), asynq.NewTask(types.TypeKnowledgeListDelete, raw))+ require.ErrorIs(t, err, asynq.SkipRetry)+ require.ErrorContains(t, err, "unfinished move")+ require.Equal(t, beforeWrites, f.repo.writes)+ require.Zero(t, f.chunkRepo.writes)+ require.Zero(t, f.graph.calls)+}++func TestDeleteWikiRemovesEveryChunkType(t *testing.T) {+ f := newDocumentWriteFixture(t)+ f.kbs.values["kb"].IndexingStrategy.WikiEnabled = true+ refs := types.StringArray{"chunk"}+ chunkTypes := []string{+ types.ChunkTypeParentText, types.ChunkTypeImageOCR, types.ChunkTypeImageCaption, types.ChunkTypeSummary,+ }+ for _, typ := range chunkTypes {+ require.NoError(+ t,+ f.db.Create(+ &types.Chunk{ID: typ, TenantID: 7, KnowledgeID: "doc", KnowledgeBaseID: "kb", ChunkType: typ},+ ).Error,+ )+ refs = append(refs, typ)+ }+ refs = append(refs, "other-chunk")+ page := &types.WikiPage{+ ID: "page",+ Slug: "concept/shared",+ SourceRefs: types.StringArray{"doc", "other-doc"},+ ChunkRefs: refs,+ }+ wiki := &moveWikiPageRepo{pages: []*types.WikiPage{page}}+ meta := &moveWikiMetaService{}+ f.svc.wikiRepo = wiki+ f.svc.wikiService = meta+ f.svc.taskPendingRepo = &moveWikiPendingRepo{}+ f.svc.task = &transferQueue{}+ require.NoError(t, f.svc.DeleteKnowledge(f.ctx, "doc"))+ require.Len(t, meta.updated, 1)+ require.Equal(t, types.StringArray{"other-chunk"}, meta.updated[0].ChunkRefs)+ require.Equal(t, types.StringArray{"other-doc"}, meta.updated[0].SourceRefs)+}++type cleanupKBFailure struct {+ interfaces.KnowledgeBaseService+ value *types.KnowledgeBase+ err error+}++func (s *cleanupKBFailure) GetKnowledgeBaseByID(context.Context, string) (*types.KnowledgeBase, error) {+ return s.value, s.err+}++func TestCleanupStopsBeforeSideEffectsWhenKBUnavailable(t *testing.T) {+ for _, scenario := range []string{"storage error", "nil KB", "wrong KB", "wrong tenant"} {+ t.Run(scenario, func(t *testing.T) {+ f := newDocumentWriteFixture(t)+ lookup := &cleanupKBFailure{}+ switch scenario {+ case "storage error":+ lookup.err = errors.New("database unavailable")+ case "wrong KB":+ lookup.value = &types.KnowledgeBase{ID: "other", TenantID: 7}+ case "wrong tenant":+ lookup.value = &types.KnowledgeBase{ID: "kb", TenantID: 8}+ }+ f.svc.kbService = lookup+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ row.EmbeddingModelID = "bound-model"+ // Engine/model dependencies remain absent: touching a fallback backend+ // would panic instead of preserving the lookup error and original data.+ err = f.svc.cleanupKnowledgeResources(f.ctx, row)+ require.Error(t, err)+ if lookup.err != nil {+ require.ErrorIs(t, err, lookup.err)+ }+ require.Zero(t, f.chunkRepo.writes)+ require.Zero(t, f.graph.calls)+ require.Empty(t, f.files.deleted)+ require.Empty(t, f.tenants.adjustments)+ })+ }+}++func TestMoveReparseKBLookupFailurePreservesSourceCheckpoint(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(+ t,+ row.SetManualMetadata(types.NewManualKnowledgeMetadata("content", types.ManualKnowledgeStatusPublish, 1)),+ )+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ failure := errors.New("source KB load failed")+ f.svc.kbService = &cleanupKBFailure{err: failure}+ err = f.svc.moveOneKnowledge(f.ctx, "doc", f.kbs.values["kb"], f.kbs.values["other"], "reparse")+ require.ErrorIs(t, err, failure)+ row, err = f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, "kb", row.KnowledgeBaseID)+ state, err := transferState(row)+ require.NoError(t, err)+ require.Equal(t, "moving", state.Phase)+ require.Zero(t, f.chunkRepo.writes)+ require.Zero(t, f.graph.calls)+}diff --git a/internal/application/service/knowledge_clone_move.go b/internal/application/service/knowledge_clone_move.goindex 1742c5343..3add25139 100644--- a/internal/application/service/knowledge_clone_move.go+++ b/internal/application/service/knowledge_clone_move.go@@ -12,6 +12,7 @@ import ("strings""time"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/application/service/retriever"werrors "github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/logger"@@ -21,7 +22,6 @@ import ("github.com/google/uuid""github.com/hibiken/asynq""github.com/redis/go-redis/v9"- "golang.org/x/sync/errgroup")// copyOwnedObject copies srcPath into a NEW object owned by the destination@@ -202,67 +202,15 @@ func cleanupCopiedObjects(ctx context.Context, svc interfaces.FileService, paths}func (s *knowledgeService) CloneKnowledgeBase(ctx context.Context, srcID, dstID string) error {- srcKB, dstKB, err := s.kbService.CopyKnowledgeBase(ctx, srcID, dstID)+ source, target, err := s.kbService.CopyKnowledgeBase(ctx, srcID, dstID)if err != nil {- logger.Errorf(ctx, "Failed to copy knowledge base: %v", err)return err}-- addKnowledge, err := s.repo.AminusB(ctx, srcKB.TenantID, srcKB.ID, dstKB.TenantID, dstKB.ID)- if err != nil {- logger.Errorf(ctx, "Failed to get knowledge: %v", err)- return err- }-- delKnowledge, err := s.repo.AminusB(ctx, dstKB.TenantID, dstKB.ID, srcKB.TenantID, srcKB.ID)- if err != nil {- logger.Errorf(ctx, "Failed to get knowledge: %v", err)- return err- }- logger.Infof(ctx, "Knowledge after update to add: %d, delete: %d", len(addKnowledge), len(delKnowledge))-- batch := 10- g, gctx := errgroup.WithContext(ctx)- for ids := range slices.Chunk(delKnowledge, batch) {- g.Go(func() error {- err := s.DeleteKnowledgeList(gctx, ids)- if err != nil {- logger.Errorf(gctx, "delete partial knowledge %v: %v", ids, err)- return err- }- return nil- })- }- err = g.Wait()- if err != nil {- logger.Errorf(ctx, "delete total knowledge %d: %v", len(delKnowledge), err)- return err- }-- // Copy context out of auto-stop task- g, gctx = errgroup.WithContext(ctx)- g.SetLimit(batch)- for _, knowledge := range addKnowledge {- g.Go(func() error {- srcKn, err := s.repo.GetKnowledgeByID(gctx, srcKB.TenantID, knowledge)- if err != nil {- logger.Errorf(gctx, "get knowledge %s: %v", knowledge, err)- return err- }- err = s.cloneKnowledge(gctx, srcKn, dstKB)- if err != nil {- logger.Errorf(gctx, "clone knowledge %s: %v", knowledge, err)- return err- }- return nil- })+ if source.Type == types.KnowledgeBaseTypeFAQ {+ p := &types.KBCloneProgress{TaskID: access.TransferTaskID(ctx), SourceID: source.ID, TargetID: target.ID}+ return s.cloneFAQKnowledgeBase(ctx, source, target, p, func(*types.KBCloneProgress, error, string) {})}- err = g.Wait()- if err != nil {- logger.Errorf(ctx, "add total knowledge %d: %v", len(addKnowledge), err)- return err- }- return nil+ return s.executeKnowledgeClone(ctx, source, target, nil)}// CloneChunk clone chunks from one knowledge to another@@ -281,15 +229,33 @@ func (s *knowledgeService) CloneKnowledgeBase(ctx context.Context, srcID, dstID// It also ensures that the chunk's relationships (like pre and next chunk IDs) are maintained// by mapping the source chunk IDs to the new target chunk IDs.func (s *knowledgeService) CloneChunk(ctx context.Context, src, dst *types.Knowledge) (err error) {- chunkPage := 1+ sourceKB, err := knowledgeWriteKB(ctx, s.kbService, src)+ if err != nil {+ return err+ }+ targetKB, err := knowledgeWriteKB(ctx, s.kbService, dst)+ if err != nil {+ return err+ }+ if err := access.RequireKBTransfer(ctx, sourceKB, targetKB, access.KBTransferClone); err != nil {+ return err+ }+ stored, err := s.repo.GetKnowledgeByID(ctx, dst.TenantID, dst.ID)+ if err != nil {+ return err+ }+ if stored == nil || stored.ID != dst.ID || stored.TenantID != dst.TenantID ||+ stored.KnowledgeBaseID != targetKB.ID {+ return access.ErrForbidden+ }+ sourceChunks, err := s.transferChunks(ctx, src, sourceKB.ID)+ if err != nil {+ return err+ }chunkPageSize := 100srcTodst := map[string]string{}tagIDMapping := map[string]string{} // srcTagID -> dstTagIDtargetChunks := make([]*types.Chunk, 0, 10)- chunkType := []types.ChunkType{- types.ChunkTypeText, types.ChunkTypeParentText, types.ChunkTypeSummary,- types.ChunkTypeImageCaption, types.ChunkTypeImageOCR,- }// Resolve the destination FileService so extracted images can be copied// into objects owned by the destination knowledge. urlCache dedups identical@@ -302,89 +268,96 @@ func (s *knowledgeService) CloneChunk(ctx context.Context, src, dst *types.KnowldstSvc := s.resolveFileService(ctx, dstKB)urlCache := map[string]string{}var copiedURLs []string+ chunksAttempted := false+ var rollbackIndices func() errordefer func() {- if err != nil {- cleanupCopiedObjects(ctx, dstSvc, copiedURLs)- }- }()-- for {- sourceChunks, _, err := s.chunkRepo.ListPagedChunksByKnowledgeID(ctx,- src.TenantID,- src.ID,- &types.Pagination{- Page: chunkPage,- PageSize: chunkPageSize,- },- chunkType,- nil,- "",- "",- "",- "",- nil,- )- chunkPage++- if err != nil {- return err+ if err == nil {+ return}- if len(sourceChunks) == 0 {- break- }- now := time.Now()- for _, sourceChunk := range sourceChunks {- // Map TagID to target knowledge base- targetTagID := ""- if sourceChunk.TagID != "" {- if mappedTagID, ok := tagIDMapping[sourceChunk.TagID]; ok {- targetTagID = mappedTagID- } else {- // Try to find or create the tag in target knowledge base- targetTagID = s.getOrCreateTagInTarget(ctx, src.TenantID, dst.TenantID, dst.KnowledgeBaseID, sourceChunk.TagID, tagIDMapping)+ if chunksAttempted {+ // A failed create may have committed before losing its acknowledgement.+ // Claim the original destination before removing any persisted data.+ before, after := *stored, *stored+ after.ParseStatus = types.ParseStatusFailed+ after.ErrorMessage = err.Error()+ if checkpointErr := s.repo.UpdateKnowledgeForTransfer(ctx, &before, &after); checkpointErr != nil {+ err = errors.Join(err, fmt.Errorf("claim failed clone cleanup: %w", checkpointErr))+ return+ }+ if rollbackIndices != nil {+ if cleanupErr := rollbackIndices(); cleanupErr != nil {+ err = errors.Join(err, fmt.Errorf("clean failed clone indices: %w", cleanupErr))+ return}}-- // Deep-copy extracted images into objects owned by the destination- // knowledge so deleting the source never breaks this clone. Content- // URL rewriting happens in a final pass below, once urlCache holds- // the complete old->new mapping (image objects live in independent- // child chunks, so a parent text chunk's  reference cannot be- // rewritten until its child image chunk has been processed).- newImageInfo, copied, copyErr := cloneChunkImageInfo(- ctx, dstSvc, sourceChunk.ImageInfo, dst.TenantID, dst.ID, urlCache)- if copyErr != nil {- err = fmt.Errorf("clone chunk image copy failed: %w", copyErr)- return err+ if cleanupErr := s.chunkRepo.DeleteChunksByKnowledgeID(ctx, dst.TenantID, dst.ID); cleanupErr != nil {+ err = errors.Join(err, fmt.Errorf("clean failed clone chunks: %w", cleanupErr))+ return}- copiedURLs = append(copiedURLs, copied...)+ }+ cleanupCopiedObjects(ctx, dstSvc, copiedURLs)+ }()- targetChunk := &types.Chunk{- ID: uuid.New().String(),- TenantID: dst.TenantID,- KnowledgeID: dst.ID,- KnowledgeBaseID: dst.KnowledgeBaseID,- TagID: targetTagID,- Content: sourceChunk.Content,- ChunkIndex: sourceChunk.ChunkIndex,- IsEnabled: sourceChunk.IsEnabled,- Flags: sourceChunk.Flags,- Status: sourceChunk.Status,- StartAt: sourceChunk.StartAt,- EndAt: sourceChunk.EndAt,- PreChunkID: sourceChunk.PreChunkID,- NextChunkID: sourceChunk.NextChunkID,- ChunkType: sourceChunk.ChunkType,- ParentChunkID: sourceChunk.ParentChunkID,- Metadata: sourceChunk.Metadata,- ContentHash: sourceChunk.ContentHash,- ImageInfo: newImageInfo,- CreatedAt: now,- UpdatedAt: now,+ now := time.Now()+ for _, sourceChunk := range sourceChunks {+ // Map TagID to target knowledge base+ targetTagID := ""+ if sourceChunk.TagID != "" {+ if mappedTagID, ok := tagIDMapping[sourceChunk.TagID]; ok {+ targetTagID = mappedTagID+ } else {+ // Try to find or create the tag in target knowledge base+ targetTagID = s.getOrCreateTagInTarget(ctx,+ src.TenantID,+ dst.TenantID,+ dst.KnowledgeBaseID,+ sourceChunk.TagID,+ tagIDMapping)}- targetChunks = append(targetChunks, targetChunk)- srcTodst[sourceChunk.ID] = targetChunk.ID}++ // Deep-copy extracted images into objects owned by the destination+ // knowledge so deleting the source never breaks this clone. Content+ // URL rewriting happens in a final pass below, once urlCache holds+ // the complete old->new mapping (image objects live in independent+ // child chunks, so a parent text chunk's  reference cannot be+ // rewritten until its child image chunk has been processed).+ newImageInfo, copied, copyErr := cloneChunkImageInfo(+ ctx, dstSvc, sourceChunk.ImageInfo, dst.TenantID, dst.ID, urlCache)+ copiedURLs = append(copiedURLs, copied...)+ if copyErr != nil {+ err = fmt.Errorf("clone chunk image copy failed: %w", copyErr)+ return err+ }++ targetChunk := &types.Chunk{+ ID: uuid.New().String(),+ TenantID: dst.TenantID,+ KnowledgeID: dst.ID,+ KnowledgeBaseID: dst.KnowledgeBaseID,+ TagID: targetTagID,+ Content: sourceChunk.Content,+ ChunkIndex: sourceChunk.ChunkIndex,+ IsEnabled: sourceChunk.IsEnabled,+ Flags: sourceChunk.Flags,+ Status: sourceChunk.Status,+ IndexStatus: sourceChunk.IndexStatus,+ StartAt: sourceChunk.StartAt,+ EndAt: sourceChunk.EndAt,+ PreChunkID: sourceChunk.PreChunkID,+ NextChunkID: sourceChunk.NextChunkID,+ ChunkType: sourceChunk.ChunkType,+ ParentChunkID: sourceChunk.ParentChunkID,+ Metadata: sourceChunk.Metadata,+ ContentHash: sourceChunk.ContentHash,+ ImageInfo: newImageInfo,+ CreatedAt: now,+ UpdatedAt: now,+ }+ targetChunks = append(targetChunks, targetChunk)+ srcTodst[sourceChunk.ID] = targetChunk.ID}+for _, targetChunk := range targetChunks {// Rewrite in-content Markdown image URLs now that urlCache holds the// complete old->new mapping across all chunks. This fixes parent text@@ -408,6 +381,7 @@ func (s *knowledgeService) CloneChunk(ctx context.Context, src, dst *types.Knowl}}for chunks := range slices.Chunk(targetChunks, chunkPageSize) {+ chunksAttempted = trueerr := s.chunkRepo.CreateChunks(ctx, chunks)if err != nil {return err@@ -420,10 +394,10 @@ func (s *knowledgeService) CloneChunk(ctx context.Context, src, dst *types.Knowl// VectorStore backends are not bit-compatible, so callers that allow// source/target KBs to bind to different stores must perform their own// cross-store migration before invoking this.- var sourceStoreID *string- if srcKB, loadErr := s.kbService.GetKnowledgeBaseByID(ctx, src.KnowledgeBaseID); loadErr == nil && srcKB != nil {- sourceStoreID = srcKB.VectorStoreID+ if len(srcTodst) == 0 || dst.EmbeddingModelID == "" {+ return nil}+ sourceStoreID := sourceKB.VectorStoreIDretrieveEngine, err := retriever.CreateRetrieveEngineForKB(ctx, s.retrieveEngine, s.ownership, tenantID, sourceStoreID)if err != nil {@@ -433,6 +407,9 @@ func (s *knowledgeService) CloneChunk(ctx context.Context, src, dst *types.Knowlif err != nil {return err}+ rollbackIndices = func() error {+ return retrieveEngine.DeleteByKnowledgeIDList(ctx, []string{dst.ID}, embeddingModel.GetDimensions(), dst.Type)+ }if err := retrieveEngine.CopyIndices(ctx, src.KnowledgeBaseID, dst.KnowledgeBaseID,map[string]string{src.ID: dst.ID},srcTodst,@@ -463,8 +440,47 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) erctx = payload.Initiator.Apply(ctx)ctx = withKBActivityTask(ctx, payload.TaskID, kbActivityTrigger(ctx))- // Add tenant ID to context- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)+ if payload.TenantID == 0 || payload.SourceID == "" || payload.TaskID == "" {+ return fmt.Errorf("invalid clone task: %w", asynq.SkipRetry)+ }+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)+ source, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.SourceID)+ if err != nil {+ return err+ }+ create := payload.CreateTarget || payload.TargetID == ""+ if payload.TargetID == "" {+ // Compatibility for tasks admitted before destination IDs were reserved at+ // enqueue time. The same legacy task always resolves the same target.+ payload.TargetID = uuid.NewSHA1(uuid.NameSpaceOID,+ []byte(fmt.Sprintf("kb-clone:%d:%s:%s",+ payload.TenantID,+ payload.SourceID,+ payload.TaskID))).+ String()+ }+ target := &types.KnowledgeBase{ID: payload.TargetID, TenantID: payload.TenantID, CreatorID: payload.CreatorID}+ if !create {+ target, err = s.kbService.GetKnowledgeBaseByID(ctx, payload.TargetID)+ if err != nil {+ return err+ }+ }+ if source == nil || source.ID != payload.SourceID || target == nil || target.ID != payload.TargetID {+ return fmt.Errorf("invalid clone binding: %w", asynq.SkipRetry)+ }+ ctx, err = access.WithKBTransferTask(+ ctx,+ source,+ target,+ payload.TenantID,+ access.KBTransferClone,+ payload.TaskID,+ create,+ )+ if err != nil {+ return fmt.Errorf("invalid clone scope: %v: %w", err, asynq.SkipRetry)+ }// Get tenant info and add to contexttenantInfo, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID)@@ -472,8 +488,36 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) erlogger.Errorf(ctx, "Failed to get tenant info: %v", err)return fmt.Errorf("failed to get tenant info: %w", err)}+ if tenantInfo == nil || tenantInfo.ID != payload.TenantID {+ return fmt.Errorf("invalid clone tenant: %w", asynq.SkipRetry)+ }ctx = context.WithValue(ctx, types.TenantInfoContextKey, tenantInfo)+ // Get source and target knowledge bases+ srcKB, dstKB, err := s.kbService.CopyKnowledgeBase(ctx, payload.SourceID, payload.TargetID)+ if err != nil {+ retry, maxRetry := 0, 0+ retry, _ = asynq.GetRetryCount(ctx)+ maxRetry, _ = asynq.GetMaxRetry(ctx)+ status := types.KBCloneStatusProcessing+ if retry >= maxRetry {+ status = types.KBCloneStatusFailed+ }+ _ = s.saveKBCloneProgress(+ ctx,+ &types.KBCloneProgress{+ TaskID: payload.TaskID,+ SourceID: payload.SourceID,+ TargetID: payload.TargetID,+ Status: status,+ Error: err.Error(),+ Message: "Clone preflight failed",+ UpdatedAt: time.Now().Unix(),+ },+ )+ return err+ }+// Check if this is the last retryretryCount, _ := asynq.GetRetryCount(ctx)maxRetry, _ := asynq.GetMaxRetry(ctx)@@ -510,13 +554,6 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) erlogger.Errorf(ctx, "Failed to update KB clone progress: %v", err)}- // Get source and target knowledge bases- srcKB, dstKB, err := s.kbService.CopyKnowledgeBase(ctx, payload.SourceID, payload.TargetID)- if err != nil {- logger.Errorf(ctx, "Failed to copy knowledge base: %v", err)- handleError(progress, err, "Failed to copy knowledge base configuration")- return err- }if retryCount == 0 {recordKBActivity(ctx, s.audit, payload.TenantID, payload.TargetID, types.AuditActionKBCloneStarted,"knowledge_base", payload.TargetID, types.AuditOutcomeAccepted,@@ -534,93 +571,21 @@ func (s *knowledgeService) ProcessKBClone(ctx context.Context, t *asynq.Task) erreturn nil}- // Document type: use Knowledge-level diff based on file_hash- addKnowledge, err := s.repo.AminusB(ctx, srcKB.TenantID, srcKB.ID, dstKB.TenantID, dstKB.ID)- if err != nil {- logger.Errorf(ctx, "Failed to get knowledge to add: %v", err)- handleError(progress, err, "Failed to calculate knowledge difference")- return err- }-- delKnowledge, err := s.repo.AminusB(ctx, dstKB.TenantID, dstKB.ID, srcKB.TenantID, srcKB.ID)+ err = s.executeKnowledgeClone(ctx, srcKB, dstKB, func(done, total int) {+ progress.Total = total+ progress.Processed = done+ if total > 0 {+ progress.Progress = done * 100 / total+ }+ progress.Message = fmt.Sprintf("Processed %d/%d clone operations", done, total)+ progress.UpdatedAt = time.Now().Unix()+ _ = s.saveKBCloneProgress(ctx, progress)+ })if err != nil {- logger.Errorf(ctx, "Failed to get knowledge to delete: %v", err)- handleError(progress, err, "Failed to calculate knowledge difference")- return err- }-- totalOperations := len(addKnowledge) + len(delKnowledge)- progress.Total = totalOperations- progress.Message = fmt.Sprintf("Found %d knowledge to add, %d to delete", len(addKnowledge), len(delKnowledge))- progress.UpdatedAt = time.Now().Unix()- _ = s.saveKBCloneProgress(ctx, progress)-- logger.Infof(ctx, "Knowledge after update to add: %d, delete: %d", len(addKnowledge), len(delKnowledge))-- processedCount := 0- batch := 10-- // Delete knowledge in target that doesn't exist in source- g, gctx := errgroup.WithContext(ctx)- for ids := range slices.Chunk(delKnowledge, batch) {- g.Go(func() error {- err := s.DeleteKnowledgeList(gctx, ids)- if err != nil {- logger.Errorf(gctx, "delete partial knowledge %v: %v", ids, err)- return err- }- return nil- })- }- if err := g.Wait(); err != nil {- logger.Errorf(ctx, "delete total knowledge %d: %v", len(delKnowledge), err)- handleError(progress, err, "Failed to delete knowledge")- return err- }-- processedCount += len(delKnowledge)- if totalOperations > 0 {- progress.Progress = processedCount * 100 / totalOperations- }- progress.Processed = processedCount- progress.Message = fmt.Sprintf("Deleted %d knowledge, cloning %d...", len(delKnowledge), len(addKnowledge))- progress.UpdatedAt = time.Now().Unix()- _ = s.saveKBCloneProgress(ctx, progress)-- // Clone knowledge from source to target- g, gctx = errgroup.WithContext(ctx)- g.SetLimit(batch)- for _, knowledge := range addKnowledge {- g.Go(func() error {- srcKn, err := s.repo.GetKnowledgeByID(gctx, srcKB.TenantID, knowledge)- if err != nil {- logger.Errorf(gctx, "get knowledge %s: %v", knowledge, err)- return err- }- err = s.cloneKnowledge(gctx, srcKn, dstKB)- if err != nil {- logger.Errorf(gctx, "clone knowledge %s: %v", knowledge, err)- return err- }-- // Update progress- processedCount++- if totalOperations > 0 {- progress.Progress = processedCount * 100 / totalOperations- }- progress.Processed = processedCount- progress.Message = fmt.Sprintf("Cloned %d/%d knowledge", processedCount-len(delKnowledge), len(addKnowledge))- progress.UpdatedAt = time.Now().Unix()- _ = s.saveKBCloneProgress(ctx, progress)-- return nil- })- }- if err := g.Wait(); err != nil {- logger.Errorf(ctx, "add total knowledge %d: %v", len(addKnowledge), err)handleError(progress, err, "Failed to clone knowledge")return err}+ totalOperations := progress.Total// Mark as completedprogress.Status = types.KBCloneStatusCompleted@@ -646,6 +611,11 @@ func (s *knowledgeService) cloneFAQKnowledgeBase(progress *types.KBCloneProgress,handleError func(*types.KBCloneProgress, error, string),) (retErr error) {+ srcByID, dstByID, err := s.preflightFAQClone(ctx, srcKB, dstKB)+ if err != nil {+ return err+ }+// Deep-copy extracted FAQ images into objects owned by the destination KB.// urlCache dedups identical source images across chunks; copiedURLs tracks// new objects for best-effort cleanup if the clone fails partway through.@@ -683,6 +653,33 @@ func (s *knowledgeService) cloneFAQKnowledgeBase(handleError(progress, err, "Failed to calculate FAQ chunk difference")return err}+ // Validate the complete diff, including matched status/tag updates, before+ // any tag creation, index deletion or chunk write. A stored-but-unindexed+ // destination from a failed delivery must be replaced, not counted as done.+ for _, id := range diff.ChunksToAdd {+ if srcByID[id] == nil {+ return fmt.Errorf("FAQ source diff escaped transfer scope")+ }+ }+ for _, id := range diff.ChunksToDelete {+ if dstByID[id] == nil {+ return fmt.Errorf("FAQ target diff escaped transfer scope")+ }+ }+ matched := make([]types.FAQChunkSyncPair, 0, len(diff.MatchedPairs))+ for _, pair := range diff.MatchedPairs {+ src, dst := srcByID[pair.SrcChunkID], dstByID[pair.DstChunkID]+ if src == nil || dst == nil {+ return fmt.Errorf("FAQ matched diff escaped transfer scope")+ }+ if dst.Status != int(types.ChunkStatusIndexed) {+ diff.ChunksToAdd = append(diff.ChunksToAdd, src.ID)+ diff.ChunksToDelete = append(diff.ChunksToDelete, dst.ID)+ } else {+ matched = append(matched, pair)+ }+ }+ diff.MatchedPairs = matchedchunksToAdd := diff.ChunksToAddchunksToDelete := diff.ChunksToDelete@@ -792,12 +789,9 @@ func (s *knowledgeService) cloneFAQKnowledgeBase(}batchIDs := chunksToAdd[i:end]- // Get source chunks- srcChunks, err := s.chunkRepo.ListChunksByID(ctx, srcKB.TenantID, batchIDs)- if err != nil {- logger.Errorf(ctx, "Failed to get source FAQ chunks: %v", err)- handleError(progress, err, "Failed to get source FAQ entries")- return err+ srcChunks := make([]*types.Chunk, 0, len(batchIDs))+ for _, id := range batchIDs {+ srcChunks = append(srcChunks, srcByID[id])}// Create new chunks for destination@@ -849,6 +843,10 @@ func (s *knowledgeService) cloneFAQKnowledgeBase(return err}+ // Saved rows now own these images, including when indexing later fails.+ // A later batch failure must not delete files from an earlier saved batch.+ copiedImageURLs = nil+// Index in vector store using existing method// This will index standard question + similar questions based on FAQConfigif err := s.indexFAQChunks(ctx, dstKB, dstKnowledge, newChunks, embeddingModel, false, false); err != nil {@@ -861,8 +859,8 @@ func (s *knowledgeService) cloneFAQKnowledgeBase(for _, chunk := range newChunks {chunk.Status = int(types.ChunkStatusIndexed)}- if err := s.chunkService.UpdateChunks(ctx, newChunks); err != nil {- logger.Warnf(ctx, "Failed to update FAQ chunks status: %v", err)+ if err := s.chunkRepo.UpdateChunks(ctx, newChunks); err != nil {+ return fmt.Errorf("failed to update FAQ chunks status: %w", err)// Don't fail the whole operation for status update failure}@@ -942,7 +940,17 @@ func (s *knowledgeService) getOrCreateFAQKnowledge(ctx context.Context, kb *typeknowledge.Description = srcKnowledge.Descriptionknowledge.Source = srcKnowledge.Sourceknowledge.Channel = srcKnowledge.Channel- knowledge.Metadata = srcKnowledge.Metadata+ fields := map[string]json.RawMessage{}+ if len(srcKnowledge.Metadata) > 0 {+ if err := json.Unmarshal(srcKnowledge.Metadata, &fields); err != nil {+ return nil, fmt.Errorf("decode source FAQ metadata: %w", err)+ }+ delete(fields, types.KnowledgeTransferMetadataKey)+ knowledge.Metadata, err = json.Marshal(fields)+ if err != nil {+ return nil, err+ }+ }}if err := s.repo.CreateKnowledge(ctx, knowledge); err != nil {@@ -963,7 +971,11 @@ func (s *knowledgeService) saveKBCloneProgress(ctx context.Context, progress *ty// SaveKBCloneProgress saves the KB clone progress to Redis (public method for handler use)func (s *knowledgeService) SaveKBCloneProgress(ctx context.Context, progress *types.KBCloneProgress) error {- return s.saveKBCloneProgress(ctx, progress)+ data, err := json.Marshal(progress)+ if err != nil {+ return err+ }+ return s.redisClient.SetNX(ctx, getKBCloneProgressKey(progress.TaskID), data, kbCloneProgressTTL).Err()}// GetKBCloneProgress retrieves the progress of a knowledge base clone task@@ -1004,7 +1016,11 @@ func (s *knowledgeService) saveKnowledgeMoveProgress(ctx context.Context, progre// SaveKnowledgeMoveProgress saves the knowledge move progress to Redis (public method for handler use)func (s *knowledgeService) SaveKnowledgeMoveProgress(ctx context.Context, progress *types.KnowledgeMoveProgress) error {- return s.saveKnowledgeMoveProgress(ctx, progress)+ data, err := json.Marshal(progress)+ if err != nil {+ return err+ }+ return s.redisClient.SetNX(ctx, getKnowledgeMoveProgressKey(progress.TaskID), data, knowledgeMoveProgressTTL).Err()}// GetKnowledgeMoveProgress retrieves the progress of a knowledge move task@@ -1029,135 +1045,140 @@ func (s *knowledgeService) GetKnowledgeMoveProgress(ctx context.Context, taskIDfunc (s *knowledgeService) ProcessKnowledgeMove(ctx context.Context, t *asynq.Task) error {var payload types.KnowledgeMovePayloadif err := json.Unmarshal(t.Payload(), &payload); err != nil {- return fmt.Errorf("failed to unmarshal knowledge move payload: %w", err)+ return fmt.Errorf("invalid move payload: %v: %w", err, asynq.SkipRetry)+ }+ if payload.TenantID == 0 || payload.TaskID == "" || payload.SourceKBID == "" || payload.TargetKBID == "" {+ return fmt.Errorf("invalid move scope: %w", asynq.SkipRetry)}ctx = payload.Initiator.Apply(ctx)ctx = withKBActivityTask(ctx, payload.TaskID, kbActivityTrigger(ctx))-- // Add tenant ID to context- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)-- // Get tenant info and add to context- tenantInfo, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID)- if err != nil {- logger.Errorf(ctx, "ProcessKnowledgeMove: failed to get tenant info: %v", err)- return fmt.Errorf("failed to get tenant info: %w", err)- }- ctx = context.WithValue(ctx, types.TenantInfoContextKey, tenantInfo)-- // Check if this is the last retry- retryCount, _ := asynq.GetRetryCount(ctx)- maxRetry, _ := asynq.GetMaxRetry(ctx)- isLastRetry := retryCount >= maxRetry-- logger.Infof(ctx, "ProcessKnowledgeMove: task=%s, source=%s, target=%s, mode=%s, count=%d, retry=%d/%d",- payload.TaskID, payload.SourceKBID, payload.TargetKBID, payload.Mode, len(payload.KnowledgeIDs), retryCount, maxRetry)-- // Helper function to handle errors - only mark as failed on last retry- handleError := func(progress *types.KnowledgeMoveProgress, err error, message string) {- if isLastRetry {- progress.Status = types.KBCloneStatusFailed- progress.Error = err.Error()- progress.Message = message- progress.UpdatedAt = time.Now().Unix()- _ = s.saveKnowledgeMoveProgress(ctx, progress)- for _, kbID := range []string{payload.SourceKBID, payload.TargetKBID} {- recordKBActivity(ctx, s.audit, payload.TenantID, kbID, types.AuditActionKnowledgeMoveFailed,- "knowledge_move", payload.TaskID, types.AuditOutcomeFailed,- map[string]any{"source_kb_id": payload.SourceKBID, "target_kb_id": payload.TargetKBID,- "task_id": payload.TaskID, "count": len(payload.KnowledgeIDs), "mode": payload.Mode})- }- }- }- if retryCount == 0 {- for _, kbID := range []string{payload.SourceKBID, payload.TargetKBID} {- recordKBActivity(ctx, s.audit, payload.TenantID, kbID, types.AuditActionKnowledgeMoveStarted,- "knowledge_move", payload.TaskID, types.AuditOutcomeAccepted,- map[string]any{"source_kb_id": payload.SourceKBID, "target_kb_id": payload.TargetKBID,- "task_id": payload.TaskID, "count": len(payload.KnowledgeIDs), "mode": payload.Mode})- }- }-- // Update progress to processing- progress := &types.KnowledgeMoveProgress{- TaskID: payload.TaskID,- SourceKBID: payload.SourceKBID,- TargetKBID: payload.TargetKBID,- Status: types.KBCloneStatusProcessing,- Total: len(payload.KnowledgeIDs),- Progress: 0,- Message: "Starting knowledge move...",- UpdatedAt: time.Now().Unix(),- }- _ = s.saveKnowledgeMoveProgress(ctx, progress)-- // Get source and target knowledge bases+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)sourceKB, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.SourceKBID)if err != nil {- handleError(progress, err, "Failed to get source knowledge base")return err}targetKB, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.TargetKBID)if err != nil {- handleError(progress, err, "Failed to get target knowledge base")return err}-- // Validate compatibility- if sourceKB.Type != targetKB.Type {- err := fmt.Errorf("type mismatch: source=%s, target=%s", sourceKB.Type, targetKB.Type)- handleError(progress, err, "Source and target knowledge bases must be the same type")+ if sourceKB == nil || sourceKB.ID != payload.SourceKBID || targetKB == nil || targetKB.ID != payload.TargetKBID {+ return fmt.Errorf("invalid move binding: %w", asynq.SkipRetry)+ }+ ctx, err = access.WithKBTransferTask(+ ctx,+ sourceKB,+ targetKB,+ payload.TenantID,+ access.KBTransferMove,+ payload.TaskID,+ false,+ )+ if err != nil {+ return fmt.Errorf("invalid move scope: %v: %w", err, asynq.SkipRetry)+ }+ tenant, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID)+ if err != nil {return err}- if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID {- err := fmt.Errorf("embedding model mismatch: source=%s, target=%s", sourceKB.EmbeddingModelID, targetKB.EmbeddingModelID)- handleError(progress, err, "Source and target must use the same embedding model")+ if tenant == nil || tenant.ID != payload.TenantID {+ return fmt.Errorf("invalid move tenant: %w", asynq.SkipRetry)+ }+ ctx = context.WithValue(ctx, types.TenantInfoContextKey, tenant)+ // No item is claimed and no failure callback can alter document state until+ // every requested document and its children passed the same pair preflight.+ retry, _ := asynq.GetRetryCount(ctx)+ maxRetry, _ := asynq.GetMaxRetry(ctx)+ items, err := s.planKnowledgeMove(ctx, sourceKB, targetKB, payload.KnowledgeIDs, payload.Mode)+ if err != nil {+ status := types.KBCloneStatusProcessing+ if retry >= maxRetry {+ status = types.KBCloneStatusFailed+ }+ _ = s.saveKnowledgeMoveProgress(+ ctx,+ &types.KnowledgeMoveProgress{+ TaskID: payload.TaskID,+ SourceKBID: sourceKB.ID,+ TargetKBID: targetKB.ID,+ Status: status,+ Error: err.Error(),+ Message: "Move preflight failed",+ UpdatedAt: time.Now().Unix(),+ },+ )return err}-- // Process each knowledge item- for i, knowledgeID := range payload.KnowledgeIDs {- err := s.moveOneKnowledge(ctx, knowledgeID, sourceKB, targetKB, payload.Mode)- if err != nil {- logger.Errorf(ctx, "ProcessKnowledgeMove: failed to move knowledge %s: %v", knowledgeID, err)- progress.Failed+++ progress := &types.KnowledgeMoveProgress{+ TaskID: payload.TaskID,+ SourceKBID: sourceKB.ID,+ TargetKBID: targetKB.ID,+ Status: types.KBCloneStatusProcessing,+ Total: len(items),+ UpdatedAt: time.Now().Unix(),+ }+ record := func(action types.AuditAction, outcome types.AuditOutcome) {+ for _, kbID := range []string{sourceKB.ID, targetKB.ID} {+ recordKBActivity(+ ctx,+ s.audit,+ payload.TenantID,+ kbID,+ action,+ "knowledge_move",+ payload.TaskID,+ outcome,+ map[string]any{+ "source_kb_id": sourceKB.ID,+ "target_kb_id": targetKB.ID,+ "task_id": payload.TaskID,+ "count": len(items),+ "mode": payload.Mode,+ },+ )}- progress.Processed = i + 1- if progress.Total > 0 {- progress.Progress = progress.Processed * 100 / progress.Total+ }+ if retry == 0 {+ record(types.AuditActionKnowledgeMoveStarted, types.AuditOutcomeAccepted)+ }+ var failures error+ for _, item := range items {+ if err := s.moveOneKnowledge(ctx, item.ID, sourceKB, targetKB, payload.Mode); err != nil {+ failures = errors.Join(failures, fmt.Errorf("knowledge %s: %w", item.ID, err))+ if retry >= maxRetry {+ s.markMoveItemFailed(ctx, item.ID, sourceKB, targetKB, payload.Mode, err)+ }+ progress.Failed++}- progress.Message = fmt.Sprintf("Moved %d/%d knowledge items", progress.Processed, progress.Total)+ progress.Processed+++ progress.Progress = progress.Processed * 100 / progress.Total+ progress.Message = fmt.Sprintf(+ "Moved %d/%d knowledge items",+ progress.Processed-progress.Failed,+ progress.Total,+ )progress.UpdatedAt = time.Now().Unix()_ = s.saveKnowledgeMoveProgress(ctx, progress)}-- // Mark as completed- if progress.Failed > 0 && progress.Failed == progress.Total {- progress.Status = types.KBCloneStatusFailed- progress.Message = fmt.Sprintf("Knowledge move failed: all %d items failed", progress.Total)- } else {- progress.Status = types.KBCloneStatusCompleted- progress.Message = fmt.Sprintf("Knowledge move completed: %d/%d succeeded", progress.Processed-progress.Failed, progress.Total)+ if failures != nil {+ progress.Error = failures.Error()+ if retry >= maxRetry {+ progress.Status = types.KBCloneStatusFailed+ outcome := types.AuditOutcomeFailed+ if progress.Failed < progress.Total {+ outcome = types.AuditOutcomePartial+ }+ record(types.AuditActionKnowledgeMoveFailed, outcome)+ }+ _ = s.saveKnowledgeMoveProgress(ctx, progress)+ // Return an error for partial failures too. Completed items are recognized+ // from their persisted task marker and skipped on the next delivery.+ return failures}+ progress.Status = types.KBCloneStatusCompletedprogress.Progress = 100- progress.UpdatedAt = time.Now().Unix()+ progress.Error = ""_ = s.saveKnowledgeMoveProgress(ctx, progress)-- logger.Infof(ctx, "ProcessKnowledgeMove: task=%s completed, processed=%d, failed=%d", payload.TaskID, progress.Processed, progress.Failed)- outcome := types.AuditOutcomeSuccess- action := types.AuditActionKnowledgeMoveCompleted- if progress.Failed == progress.Total && progress.Total > 0 {- outcome = types.AuditOutcomeFailed- action = types.AuditActionKnowledgeMoveFailed- } else if progress.Failed > 0 {- outcome = types.AuditOutcomePartial- }- for _, kbID := range []string{payload.SourceKBID, payload.TargetKBID} {- recordKBActivity(ctx, s.audit, payload.TenantID, kbID, action,- "knowledge_move", payload.TaskID, outcome,- map[string]any{"source_kb_id": payload.SourceKBID, "target_kb_id": payload.TargetKBID,- "task_id": payload.TaskID, "count": progress.Total, "failed": progress.Failed, "mode": payload.Mode})- }+ record(types.AuditActionKnowledgeMoveCompleted, types.AuditOutcomeSuccess)return nil}@@ -1168,45 +1189,76 @@ func (s *knowledgeService) moveOneKnowledge(sourceKB, targetKB *types.KnowledgeBase,mode string,) error {- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)-- // Get the knowledge item+ if err := access.RequireKBTransfer(ctx, sourceKB, targetKB, access.KBTransferMove); err != nil {+ return err+ }+ tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)+ if err := access.ValidateKBTransferCompatibility(sourceKB,+ targetKB,+ access.KBTransferMove,+ mode,+ tenant); err != nil {+ return err+ }+ tenantID := sourceKB.TenantIDknowledge, err := s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID)if err != nil {- return fmt.Errorf("failed to get knowledge %s: %w", knowledgeID, err)+ return err}-- // Only move completed items- if knowledge.ParseStatus != types.ParseStatusCompleted {- return fmt.Errorf("knowledge %s is not in completed status (current: %s)", knowledgeID, knowledge.ParseStatus)+ if knowledge == nil || knowledge.ID != knowledgeID {+ return access.ErrNotFound}-- // Reject a cross-store reuse_vectors move BEFORE mutating status, so a- // rejected move leaves the knowledge untouched (Completed) rather than- // stranded in Processing. reuse_vectors copies indices through the source- // store only; a cross-store copy would corrupt vector data. The handler- // rejects this synchronously — this is defense-in-depth for directly- // enqueued tasks. Cross-store moves must use reparse mode.- if mode == "reuse_vectors" && !sourceKB.SharesStoreWith(targetKB) {- return fmt.Errorf(- "reuse_vectors move across different vector stores is not supported "+- "(source KB %s, target KB %s); use reparse mode", sourceKB.ID, targetKB.ID)+ if err := validateMoveItem(ctx, knowledge, sourceKB, targetKB, mode); err != nil {+ return err}-- // Mark as processing during move- knowledge.ParseStatus = types.ParseStatusProcessing- if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {- return fmt.Errorf("failed to mark knowledge as processing: %w", err)+ copyOfKnowledge := *knowledge+ knowledge = ©OfKnowledge+ state, err := transferState(knowledge)+ if err != nil {+ return err}-- // From the source KB's point of view the document is leaving for good, so it- // needs the same wiki reconciliation a delete performs: wiki_pages carry- // source_refs back to this knowledge and are what the folder tree and the- // wiki graph are built from, and nothing below touches them. This must run- // while KnowledgeBaseID still points at the source and before any chunk is- // removed, since the cleanup matches pages by chunk_refs.- if sourceKB.IsWikiEnabled() {- s.cleanupWikiOnKnowledgeDelete(ctx, knowledge)+ if matchesTransfer(ctx, state, sourceKB, targetKB, access.KBTransferMove, knowledgeID, mode) {+ if state.Phase == "done" || state.Phase == "reparse_pending" {+ if err := s.cleanupMovedSourceWiki(ctx, knowledge, sourceKB, targetKB); err != nil {+ return err+ }+ if state.Phase == "reparse_pending" {+ return s.enqueueMovedKnowledge(ctx, knowledge, sourceKB, targetKB)+ }+ if mode == "reuse_vectors" && targetKB.IsWikiEnabled() {+ _, err := EnqueueWikiIngest(ctx, s.task, s.taskPendingRepo, tenantID, targetKB.ID, knowledge.ID)+ return err+ }+ return nil+ }+ } else {+ state = &knowledgeTransferState{+ TaskID: access.TransferTaskID(ctx),+ Operation: access.KBTransferMove,+ SourceKB: sourceKB.ID,+ TargetKB: targetKB.ID,+ SourceID: knowledge.ID,+ Mode: mode,+ Phase: "moving",+ }+ if sourceKB.IsWikiEnabled() {+ chunks, err := s.transferChunks(ctx, knowledge, sourceKB.ID)+ if err != nil {+ return err+ }+ for _, chunk := range chunks {+ state.WikiChunkIDs = append(state.WikiChunkIDs, chunk.ID)+ }+ state.WikiSummary = knowledge.Description+ }+ before := *knowledge+ knowledge.ParseStatus = types.ParseStatusProcessing+ if err := setTransferState(knowledge, *state); err != nil {+ return err+ }+ if err := s.repo.UpdateKnowledgeForTransfer(ctx, &before, knowledge); err != nil {+ return err+ }}switch mode {@@ -1214,11 +1266,15 @@ func (s *knowledgeService) moveOneKnowledge(if err := s.moveKnowledgeReuseVectors(ctx, knowledge, sourceKB, targetKB); err != nil {return err}+ if err := s.cleanupMovedSourceWiki(ctx, knowledge, sourceKB, targetKB); err != nil {+ return err+ }// reparse re-ingests through KnowledgePostProcess once the new chunks// land; reuse_vectors keeps the existing chunks and never re-enters that// pipeline, so the target KB has to be told about the document here.if targetKB.IsWikiEnabled() {- EnqueueWikiIngest(ctx, s.task, s.taskPendingRepo, tenantID, targetKB.ID, knowledge.ID)+ _, err := EnqueueWikiIngest(ctx, s.task, s.taskPendingRepo, tenantID, targetKB.ID, knowledge.ID)+ return err}return nilcase "reparse":@@ -1228,7 +1284,7 @@ func (s *knowledgeService) moveOneKnowledge(}}-// moveKnowledgeReuseVectors moves knowledge by copying vector indices and updating DB references.+// moveKnowledgeReuseVectors relocates vector metadata while retaining physical IDs.func (s *knowledgeService) moveKnowledgeReuseVectors(ctx context.Context,knowledge *types.Knowledge,@@ -1236,65 +1292,62 @@ func (s *knowledgeService) moveKnowledgeReuseVectors() error {tenantID := ctx.Value(types.TenantIDContextKey).(uint64)- // reuse_vectors copies index entries directly between KBs, which only works- // inside the same VectorStore backend (CopyIndices is routed through the- // source store). A cross-store reuse_vectors move would write target-KB rows- // into the source store and then delete the source indices, corrupting data.- // The MoveKnowledge handler rejects this up front; this is defense-in-depth- // for any path that enqueues a move task directly. Cross-store moves must use- // reparse mode (moveKnowledgeReparse), which re-indexes into the target store.+ // Metadata relocation is supported only within the same vector store.+ // Cross-store moves must reparse into the target store.if !sourceKB.SharesStoreWith(targetKB) {return fmt.Errorf("reuse_vectors move across different vector stores is not supported "+"(source KB %s, target KB %s); use reparse mode", sourceKB.ID, targetKB.ID)}- // 1. Get old chunk IDs for vector index copy mapping- oldChunks, err := s.chunkRepo.ListChunksByKnowledgeID(ctx, tenantID, knowledge.ID)- if err != nil {- return fmt.Errorf("failed to list chunks: %w", err)+ if err := access.RequireKBTransfer(ctx, sourceKB, targetKB, access.KBTransferMove); err != nil {+ return err}-- // Build identity mapping (same chunk IDs, just moving between KBs)- chunkIDMapping := make(map[string]string, len(oldChunks))- for _, c := range oldChunks {- chunkIDMapping[c.ID] = c.ID+ oldChunks, err := s.transferChunks(ctx, knowledge, sourceKB.ID, targetKB.ID)+ if err != nil {+ return err}-- // 2. Copy vector indices from source KB to target KB- if len(chunkIDMapping) > 0 && knowledge.EmbeddingModelID != "" {- // Same VectorStore backend is guaranteed by the SharesStoreWith guard at- // the top of this function, so routing CopyIndices through the source- // KB's binding also resolves the target's store.- var sourceStoreID *string- if sourceKB != nil {- sourceStoreID = sourceKB.VectorStoreID- }- retrieveEngine, err := retriever.CreateRetrieveEngineForKB(- ctx, s.retrieveEngine, s.ownership, tenantID, sourceStoreID)+ chunkIDs := make([]string, 0, len(oldChunks))+ for _, chunk := range oldChunks {+ chunkIDs = append(chunkIDs, chunk.ID)+ }+ if knowledge.EmbeddingModelID != "" {+ engine, err := retriever.CreateRetrieveEngineForKB(+ ctx,+ s.retrieveEngine,+ s.ownership,+ tenantID,+ sourceKB.VectorStoreID,+ )if err != nil {- return fmt.Errorf("failed to init retrieve engine: %w", err)+ return err}- embeddingModel, err := s.modelService.GetEmbeddingModel(ctx, knowledge.EmbeddingModelID)+ model, err := s.modelService.GetEmbeddingModel(ctx, knowledge.EmbeddingModelID)if err != nil {- return fmt.Errorf("failed to get embedding model: %w", err)+ return err}-- // Copy indices from source KB to target KB- knowledgeIDMapping := map[string]string{knowledge.ID: knowledge.ID}- if err := retrieveEngine.CopyIndices(ctx, sourceKB.ID, targetKB.ID,- knowledgeIDMapping, chunkIDMapping,- embeddingModel.GetDimensions(), sourceKB.Type,- ); err != nil {- return fmt.Errorf("failed to copy indices: %w", err)+ // Move index metadata in place. Copy + delete by the unchanged document ID+ // would also delete the just-created target indices.+ if err := engine.MoveKnowledgeIndices(ctx,+ sourceKB.ID,+ targetKB.ID,+ knowledge.ID,+ chunkIDs,+ model.GetDimensions(),+ sourceKB.Type); err != nil {+ return err}+ }- // Delete indices from source KB- if err := retrieveEngine.DeleteByKnowledgeIDList(ctx, []string{knowledge.ID},- embeddingModel.GetDimensions(), sourceKB.Type,- ); err != nil {- logger.Warnf(ctx, "moveKnowledgeReuseVectors: failed to delete old indices for knowledge %s: %v", knowledge.ID, err)- // Non-fatal: indices will be orphaned but won't affect correctness+ // Source graph namespaces must not keep exposing a document after it+ // leaves the KB. The exact namespace deletion is repeatable on retry.+ if s.graphEngine != nil {+ if err := s.graphEngine.DelGraph(ctx,+ []types.NameSpace{{+ KnowledgeBase: sourceKB.ID,+ Knowledge: knowledge.ID,+ }}); err != nil {+ return err}}@@ -1307,11 +1360,20 @@ func (s *knowledgeService) moveKnowledgeReuseVectors(if err := s.repo.DeleteKnowledgeTagRelations(ctx, knowledge.ID); err != nil {return fmt.Errorf("failed to clear knowledge tag relations: %w", err)}+ before := *knowledgeknowledge.KnowledgeBaseID = targetKB.IDknowledge.ParseStatus = types.ParseStatusCompleted- knowledge.UpdatedAt = time.Now()- if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {- return fmt.Errorf("failed to update knowledge: %w", err)+ knowledge.ErrorMessage = ""+ state, err := transferState(knowledge)+ if err != nil || state == nil {+ return fmt.Errorf("move state unavailable")+ }+ state.Phase = "done"+ if err := setTransferState(knowledge, *state); err != nil {+ return err+ }+ if err := s.repo.UpdateKnowledgeForTransfer(ctx, &before, knowledge); err != nil {+ return err}return nil@@ -1321,39 +1383,81 @@ func (s *knowledgeService) moveKnowledgeReuseVectors(func (s *knowledgeService) moveKnowledgeReparse(ctx context.Context,knowledge *types.Knowledge,- _, targetKB *types.KnowledgeBase,+ sourceKB, targetKB *types.KnowledgeBase,) error {- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)-- // 1. Clean up existing chunks and vector indices- if err := s.cleanupKnowledgeResources(ctx, knowledge); err != nil {- logger.Warnf(ctx, "moveKnowledgeReparse: cleanup partial error for knowledge %s: %v", knowledge.ID, err)- // Continue - partial cleanup is acceptable+ if err := access.RequireKBTransfer(ctx, sourceKB, targetKB, access.KBTransferMove); err != nil {+ return err+ }+ before := *knowledge+ cleanup := *knowledge+ cleanup.StorageSize = 0+ if err := s.cleanupKnowledgeResources(ctx, &cleanup); err != nil {+ return fmt.Errorf("failed to clean up source: %w", err)}-- // 2. Update knowledge to belong to target KB (tags are KB-scoped; clear relations)if err := s.repo.DeleteKnowledgeTagRelations(ctx, knowledge.ID); err != nil {- return fmt.Errorf("failed to clear knowledge tag relations: %w", err)+ return err}knowledge.KnowledgeBaseID = targetKB.IDknowledge.EmbeddingModelID = targetKB.EmbeddingModelIDknowledge.ParseStatus = types.ParseStatusPending+ knowledge.ErrorMessage = ""knowledge.EnableStatus = "disabled"knowledge.Description = ""knowledge.ProcessedAt = nil- knowledge.UpdatedAt = time.Now()- if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {- return fmt.Errorf("failed to update knowledge: %w", err)+ knowledge.StorageSize = 0+ state, err := transferState(knowledge)+ if err != nil || state == nil {+ return fmt.Errorf("move state unavailable")+ }+ state.Phase = "reparse_pending"+ if err := setTransferState(knowledge, *state); err != nil {+ return err}+ if err := s.repo.UpdateKnowledgeForTransfer(ctx, &before, knowledge); err != nil {+ return err+ }+ if err := s.cleanupMovedSourceWiki(ctx, knowledge, sourceKB, targetKB); err != nil {+ return err+ }+ return s.enqueueMovedKnowledge(ctx, knowledge, sourceKB, targetKB)+}+func (s *knowledgeService) enqueueMovedKnowledge(+ ctx context.Context,+ knowledge *types.Knowledge,+ sourceKB, targetKB *types.KnowledgeBase,+) error {+ if err := access.RequireKBTransfer(ctx, sourceKB, targetKB, access.KBTransferMove); err != nil {+ return err+ }+ if knowledge.ParseStatus == types.ParseStatusFailed {+ before := *knowledge+ knowledge.ParseStatus = types.ParseStatusPending+ knowledge.ErrorMessage = ""+ if err := s.repo.UpdateKnowledgeForTransfer(ctx, &before, knowledge); err != nil {+ return err+ }+ }+ tenantID := knowledge.TenantID+ taskID := "move-reparse:" + access.TransferTaskID(ctx) + ":" + knowledge.ID// 3. Enqueue document processing task with target KB's configurationif knowledge.IsManual() {meta, err := knowledge.ManualMetadata()if err != nil || meta == nil {return fmt.Errorf("failed to get manual metadata for reparse: %w", err)}- s.triggerManualProcessing(ctx, targetKB, knowledge, meta.Content, false)- return nil+ _, err = s.enqueueManualProcessing(+ ctx,+ knowledge,+ meta.Content,+ false,+ asynq.TaskID(taskID),+ asynq.Retention(7*24*time.Hour),+ )+ if err != nil && !errors.Is(err, asynq.ErrTaskIDConflict) && !errors.Is(err, asynq.ErrDuplicateTask) {+ return err+ }+ return s.acknowledgeMovedReparse(ctx, knowledge, sourceKB, targetKB)}if knowledge.FilePath != "" {@@ -1387,16 +1491,23 @@ func (s *knowledgeService) moveKnowledgeReparse(return fmt.Errorf("failed to marshal document process payload: %w", err)}- task := asynq.NewTask(types.TypeDocumentProcess, payloadBytes,- documentProcessTaskOptions(s.config, asynq.MaxRetry(3))...)+ task := asynq.NewTask(+ types.TypeDocumentProcess,+ payloadBytes,+ documentProcessTaskOptions(+ s.config,+ asynq.MaxRetry(3),+ asynq.TaskID(taskID),+ asynq.Retention(7*24*time.Hour),+ )...)info, err := s.task.Enqueue(task)- if err != nil {+ if err != nil && !errors.Is(err, asynq.ErrTaskIDConflict) && !errors.Is(err, asynq.ErrDuplicateTask) {return fmt.Errorf("failed to enqueue document process task: %w", err)}- logger.Infof(ctx, "moveKnowledgeReparse: enqueued reparse task id=%s for knowledge=%s", info.ID, knowledge.ID)+ _ = info}- return nil+ return s.acknowledgeMovedReparse(ctx, knowledge, sourceKB, targetKB)}// getOrCreateTagInTarget finds or creates a tag in the target knowledge base based on the source tag.diff --git a/internal/application/service/knowledge_create.go b/internal/application/service/knowledge_create.goindex 410a2be86..d294f2c14 100644--- a/internal/application/service/knowledge_create.go+++ b/internal/application/service/knowledge_create.go@@ -1017,21 +1017,18 @@ func (s *knowledgeService) UpdateManualKnowledge(ctx context.Context,return nil, werrors.NewValidationError("状态仅支持 draft 或 publish")}- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)- existing, err := s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID)+ existing, kb, err := loadKnowledgeWrite(ctx, s.repo, s.kbService, knowledgeID)if err != nil {- logger.Errorf(ctx, "Failed to load knowledge: %v", err)return nil, err}if !existing.IsManual() {return nil, werrors.NewBadRequestError("仅支持手工知识的在线编辑")}-- kb, err := s.kbService.GetKnowledgeBaseByID(ctx, existing.KnowledgeBaseID)+ ctx, err = withKBWriteTenantInfo(ctx, kb, s.tenantRepo)if err != nil {- logger.Errorf(ctx, "Failed to get knowledge base for manual update: %v", err)return nil, err}+ tenantID := existing.TenantIDvar version intif meta, err := existing.ManualMetadata(); err == nil && meta != nil {@@ -1115,7 +1112,7 @@ func (s *knowledgeService) UpdateManualKnowledge(ctx context.Context,// enqueueManualProcessing enqueues a manual:process Asynq task for async cleanup + re-indexing.func (s *knowledgeService) enqueueManualProcessing(ctx context.Context,- knowledge *types.Knowledge, content string, needCleanup bool,+ knowledge *types.Knowledge, content string, needCleanup bool, options ...asynq.Option,) (string, error) {requestID, _ := types.RequestIDFromContext(ctx)payload := types.ManualProcessPayload{@@ -1134,7 +1131,7 @@ func (s *knowledgeService) enqueueManualProcessing(ctx context.Context,task := asynq.NewTask(types.TypeManualProcess, payloadBytes,asynq.Queue(types.QueueDefault), asynq.MaxRetry(3), asynq.Timeout(30*time.Minute))- info, err := s.task.Enqueue(task)+ info, err := s.task.Enqueue(task, options...)if err != nil {return "", fmt.Errorf("failed to enqueue manual process task: %w", err)}diff --git a/internal/application/service/knowledge_delete.go b/internal/application/service/knowledge_delete.goindex f550e09ad..c24c67d50 100644--- a/internal/application/service/knowledge_delete.go+++ b/internal/application/service/knowledge_delete.go@@ -4,10 +4,11 @@ import ("context""encoding/json""errors"+ "fmt""strings"- "time""github.com/Tencent/WeKnora/internal/application/service/retriever"+ apperrors "github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces"@@ -120,150 +121,11 @@ func deleteExtractedImages(// DeleteKnowledge deletes a knowledge entry and all related resourcesfunc (s *knowledgeService) DeleteKnowledge(ctx context.Context, id string) error {- // Get the knowledge entry- knowledge, err := s.repo.GetKnowledgeByID(ctx, ctx.Value(types.TenantIDContextKey).(uint64), id)+ plan, err := s.planKnowledgeDelete(ctx, []string{id})if err != nil {return err}-- // Mark as deleting first to prevent async task conflicts- // This ensures that any running async tasks will detect the deletion and abort- originalStatus := knowledge.ParseStatus- knowledge.ParseStatus = types.ParseStatusDeleting- knowledge.UpdatedAt = time.Now()- if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge failed to mark as deleting")- // Continue with deletion even if marking fails- } else {- logger.Infof(ctx, "Marked knowledge %s as deleting (previous status: %s)", id, originalStatus)- }-- // Best-effort: purge any queued downstream tasks for this knowledge- // (multimodal / post-process / question / summary / graph extract).- // Worker checkpoints already drop them on the floor, but dequeuing- // here avoids waking workers just to no-op when the parse was still- // in flight at delete time. No-op in Lite mode and on completed rows- // (no queued descendants anyway).- if originalStatus == types.ParseStatusPending ||- originalStatus == types.ParseStatusProcessing {- s.dequeueKnowledgeTasks(ctx, id)- }-- // Resolve file service for this KB before spawning goroutines- kb, _ := s.kbService.GetKnowledgeBaseByID(ctx, knowledge.KnowledgeBaseID)- kbFileSvc := s.resolveFileService(ctx, kb)-- // Collect image URLs before chunks are deleted (ImageInfo references are lost after deletion)- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)- chunkImageInfos, err := s.chunkService.GetRepository().ListImageInfoByKnowledgeIDs(ctx, tenantID, []string{id})- if err != nil {- logger.Errorf(ctx, "Failed to collect image URLs for cleanup: %v", err)- }- var imageInfoStrs []string- for _, ci := range chunkImageInfos {- imageInfoStrs = append(imageInfoStrs, ci.ImageInfo)- }- imageURLs := collectImageURLs(ctx, imageInfoStrs)-- wg := errgroup.Group{}- // Delete knowledge embeddings from vector store.- // Skip entirely when the knowledge has no embedding model (e.g. Wiki-only KB):- // nothing was ever written to the vector store, so there is nothing to delete,- // and GetEmbeddingModel would fail with "model ID cannot be empty".- if strings.TrimSpace(knowledge.EmbeddingModelID) != "" {- wg.Go(func() error {- // kb was already loaded above for resolveFileService — reuse its- // VectorStoreID for engine routing.- var boundStoreID *string- if kb != nil {- boundStoreID = kb.VectorStoreID- }- retrieveEngine, err := retriever.CreateRetrieveEngineForKB(- ctx,- s.retrieveEngine,- s.ownership,- tenantID,- boundStoreID,- )- if err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge delete knowledge embedding failed")- return err- }- embeddingModel, err := s.modelService.GetEmbeddingModel(ctx, knowledge.EmbeddingModelID)- if err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge delete knowledge embedding failed")- return err- }- if err := retrieveEngine.DeleteByKnowledgeIDList(ctx, []string{knowledge.ID}, embeddingModel.GetDimensions(), knowledge.Type); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge delete knowledge embedding failed")- return err- }- return nil- })- } else {- logger.Infof(ctx, "Knowledge %s has no embedding model, skipping vector store cleanup", knowledge.ID)- }-- // Clean wiki pages before deleting chunks so cleanup can still identify- // which chunk_refs belonged to this source document.- if kb != nil && kb.IsWikiEnabled() {- s.cleanupWikiOnKnowledgeDelete(ctx, knowledge)- }-- // Delete all chunks associated with this knowledge- wg.Go(func() error {- if err := s.chunkService.DeleteChunksByKnowledgeID(ctx, knowledge.ID); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge delete chunks failed")- return err- }- return nil- })-- // Delete the knowledge graph- wg.Go(func() error {- namespace := types.NameSpace{KnowledgeBase: knowledge.KnowledgeBaseID, Knowledge: knowledge.ID}- if err := s.graphEngine.DelGraph(ctx, []types.NameSpace{namespace}); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge delete knowledge graph failed")- return err- }- return nil- })-- if err = wg.Wait(); err != nil {- return err- }- if err := s.repo.DeleteKnowledgeTagRelations(ctx, id); err != nil {- logger.Warnf(ctx, "Failed to delete tag relations for knowledge %s: %v", id, err)- }- // Delete the knowledge row FIRST, then drop its physical file. Physical- // cleanup is deliberately deferred until the row is gone: if any of the- // index/chunk/graph cleanups above failed we already returned early with the- // row (and its file) intact, so the queued retry — or a user-triggered- // reparse — can still read the original file. Deleting the file before the- // row could leave a "file missing but row present" zombie that can neither be- // reparsed nor cleanly re-deleted (issue #2192). Orphaning a file after the- // row is gone is the tolerable failure mode instead.- if err := s.repo.DeleteKnowledge(ctx, tenantID, id); err != nil {- return err- }-- // Best-effort physical cleanup. Errors here only leak storage; they must not- // fail the delete now that the row is already gone.- if knowledge.FilePath != "" {- if err := kbFileSvc.DeleteFile(ctx, knowledge.FilePath); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge delete file failed")- }- }- deleteExtractedImages(ctx, kbFileSvc, knowledgeResourceOwners(s.resourceCatalog, knowledge.ID), imageURLs)- tenantInfo := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)- tenantInfo.StorageUsed -= knowledge.StorageSize- if err := s.tenantRepo.AdjustStorageUsed(ctx, tenantInfo.ID, -knowledge.StorageSize); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge update tenant storage used failed")- }- recordKBActivity(ctx, s.audit, tenantID, knowledge.KnowledgeBaseID, types.AuditActionKnowledgeDeleted,- "knowledge", knowledge.ID, types.AuditOutcomeSuccess,- map[string]any{"title": knowledge.Title, "type": knowledge.Type})- return nil+ return s.executeKnowledgeDelete(plan, true)}// cleanupWikiOnKnowledgeDelete handles wiki pages when a source document is deleted.@@ -277,9 +139,9 @@ func (s *knowledgeService) DeleteKnowledge(ctx context.Context, id string) error// - It writes a tombstone + scrubs pending ingest ops so new pages cannot be// born with a stale source_ref (guards (a) queued ingest and (b) ingest// tasks mid-LLM call — both consult the tombstone before writing).-// - It immediately reconciles any pages already present (delete-if-only-ref-// or strip-ref-if-multi).-// - It *unconditionally* enqueues a retract task. Crucially we DO NOT gate+// - It persists a retract task before reconciling existing pages (delete+// if only source, or strip the source if shared), preserving retry evidence.+// Crucially we DO NOT gate// enqueue on "pages currently exist": in the ingest/delete race the// knowledge may have pages that exist only after this function returns// (the ingest task fires later and, absent the tombstone, would have@@ -287,20 +149,42 @@ func (s *knowledgeService) DeleteKnowledge(ctx context.Context, id string) error// run time, so even with an empty PageSlugs it will do the right thing —// and at worst it's a cheap no-op.func (s *knowledgeService) cleanupWikiOnKnowledgeDelete(ctx context.Context, knowledge *types.Knowledge) {+ if err := s.cleanupWikiReferences(ctx, knowledge, s.wikiChunkRefsForKnowledge(ctx, knowledge)); err != nil {+ logger.Warnf(ctx, "wiki cleanup failed: %v", err)+ }+}++func (s *knowledgeService) cleanupWikiReferences(+ ctx context.Context,+ knowledge *types.Knowledge,+ sourceChunkRefs map[string]bool,+) error {if knowledge == nil {- return+ return nil}kbID := knowledge.KnowledgeBaseIDknowledgeID := knowledge.IDif kbID == "" || knowledgeID == "" {- return+ return nil}+ var cleanupErr error+// (1) Tombstone + scrub pending ingest — must happen first so any// wiki_ingest task that wakes up between here and the retract enqueue// below sees "knowledge gone" and bails out.- s.markKnowledgeDeletedForWiki(ctx, kbID, knowledgeID)- s.scrubWikiPendingIngest(ctx, kbID, knowledgeID, "cleanup")+ if s.redisClient != nil {+ key := WikiDeletedTombstoneKey(kbID, knowledgeID)+ if err := s.redisClient.Set(ctx, key, "1", wikiDeletedTTL).Err(); err != nil {+ cleanupErr = errors.Join(cleanupErr, err)+ }+ }+ if s.taskPendingRepo != nil {+ err := s.taskPendingRepo.DeleteByDedupKey(ctx, wikiTaskType, wikiTaskScope, kbID, knowledgeID, WikiOpIngest)+ if err != nil {+ cleanupErr = errors.Join(cleanupErr, err)+ }+ }// Pull title/summary from the knowledge itself — do NOT read them from// existing wiki pages. In the race window wiki pages may not exist yet,@@ -322,9 +206,8 @@ func (s *knowledgeService) cleanupWikiOnKnowledgeDelete(ctx context.Context, knopages, err := s.wikiRepo.ListBySourceRef(ctx, kbID, knowledgeID)if err != nil {logger.Warnf(ctx, "wiki cleanup: failed to list pages by source ref %s: %v", knowledgeID, err)- pages = nil+ return errors.Join(cleanupErr, err)}- sourceChunkRefs := s.wikiChunkRefsForKnowledge(ctx, knowledge)// Prefer the on-disk summary if the summary page already exists (it's// richer than the raw user-provided description). Leave docSummary@@ -336,22 +219,37 @@ func (s *knowledgeService) cleanupWikiOnKnowledgeDelete(ctx context.Context, kno}}+ // Persist the retract page set before removing source refs. Otherwise an+ // enqueue failure would leave the retry unable to rediscover those pages.+ var pageSlugs, folderIDs []string+ for _, page := range pages {+ if page.PageType != types.WikiPageTypeIndex {+ pageSlugs = append(pageSlugs, page.Slug)+ folderIDs = append(folderIDs, page.FolderID)+ }+ }+ lang := types.LanguageFromContextOrDefault(ctx)+ tenantID, _ := types.TenantIDFromContext(ctx)+ if err := enqueueWikiRetract(ctx, s.task, s.taskPendingRepo, WikiRetractPayload{+ TenantID: tenantID, KnowledgeBaseID: kbID, KnowledgeID: knowledgeID,+ DocTitle: docTitle, DocSummary: docSummary, Language: lang,+ PageSlugs: pageSlugs, FolderIDs: uniqueWikiFolderIDs(folderIDs),+ }); err != nil {+ return errors.Join(cleanupErr, err)+ }+var deletedSlugs []string- var retractSlugs []string- var affectedFolderIDs []stringfor _, page := range pages {if page.PageType == types.WikiPageTypeIndex {continue}- if page.FolderID != "" {- affectedFolderIDs = append(affectedFolderIDs, page.FolderID)- }remaining := removeSourceRef(page.SourceRefs, knowledgeID)if len(remaining) == 0 {if err := s.wikiService.DeletePage(ctx, kbID, page.Slug); err != nil {logger.Warnf(ctx, "wiki cleanup: failed to delete page %s: %v", page.Slug, err)+ cleanupErr = errors.Join(cleanupErr, err)} else {deletedSlugs = append(deletedSlugs, page.Slug)}@@ -360,8 +258,7 @@ func (s *knowledgeService) cleanupWikiOnKnowledgeDelete(ctx context.Context, knopage.ChunkRefs = removeChunkRefs(page.ChunkRefs, sourceChunkRefs)if err := s.wikiService.UpdatePageMeta(ctx, page); err != nil {logger.Warnf(ctx, "wiki cleanup: failed to update source refs for page %s: %v", page.Slug, err)- } else {- retractSlugs = append(retractSlugs, page.Slug)+ cleanupErr = errors.Join(cleanupErr, err)}}}@@ -371,34 +268,14 @@ func (s *knowledgeService) cleanupWikiOnKnowledgeDelete(ctx context.Context, knolen(deletedSlugs), knowledgeID, deletedSlugs)}- allAffectedSlugs := append(retractSlugs, deletedSlugs...)-- // (3) Unconditionally enqueue the retract task. See function comment —- // an empty PageSlugs is not a bug, it's the signal "re-query at run- // time". The handler will ListPagesBySourceRef again, pick up any- // pages that materialised after we looked, and also rebuild the index- // so the knowledge's disappearance is reflected in the UI.- lang := types.LanguageFromContextOrDefault(ctx)- tenantID, _ := types.TenantIDFromContext(ctx)- EnqueueWikiRetract(ctx, s.task, s.taskPendingRepo, WikiRetractPayload{- TenantID: tenantID,- KnowledgeBaseID: kbID,- KnowledgeID: knowledgeID,- DocTitle: docTitle,- DocSummary: docSummary,- Language: lang,- PageSlugs: allAffectedSlugs,- FolderIDs: uniqueWikiFolderIDs(affectedFolderIDs),- })- logger.Infof(ctx, "wiki cleanup: enqueued retract task for knowledge %s (%d known slugs: %v)",- knowledgeID, len(allAffectedSlugs), allAffectedSlugs)+ return cleanupErr}func (s *knowledgeService) wikiChunkRefsForKnowledge(ctx context.Context, knowledge *types.Knowledge) map[string]bool {if knowledge == nil || s.chunkRepo == nil {return nil}- chunks, err := s.chunkRepo.ListChunksByKnowledgeID(ctx, knowledge.TenantID, knowledge.ID)+ chunks, err := s.chunkRepo.ListAllChunksByKnowledgeID(ctx, knowledge.TenantID, knowledge.ID)if err != nil {logger.Warnf(ctx, "wiki cleanup: failed to list chunks for knowledge %s: %v", knowledge.ID, err)return nil@@ -413,19 +290,6 @@ func (s *knowledgeService) wikiChunkRefsForKnowledge(ctx context.Context, knowlereturn refs}-// markKnowledgeDeletedForWiki writes a short-TTL tombstone so any wiki_ingest-// task still running or queued for this knowledge can short-circuit before-// resurrecting a page with a stale source_ref. No-op when Redis is absent.-func (s *knowledgeService) markKnowledgeDeletedForWiki(ctx context.Context, kbID, knowledgeID string) {- if s.redisClient == nil || kbID == "" || knowledgeID == "" {- return- }- key := WikiDeletedTombstoneKey(kbID, knowledgeID)- if err := s.redisClient.Set(ctx, key, "1", wikiDeletedTTL).Err(); err != nil {- logger.Warnf(ctx, "wiki cleanup: failed to write tombstone %s: %v", key, err)- }-}-// scrubWikiPendingIngest removes queued WikiOpIngest entries for a knowledge// from task_pending_ops. Used by both the delete path (we're about to// soft-delete the doc, no point ingesting it) and the reparse path (the@@ -441,7 +305,8 @@ func (s *knowledgeService) scrubWikiPendingIngest(ctx context.Context, kbID, knoif s.taskPendingRepo == nil || kbID == "" || knowledgeID == "" {return}- if err := s.taskPendingRepo.DeleteByDedupKey(ctx, wikiTaskType, wikiTaskScope, kbID, knowledgeID, WikiOpIngest); err != nil {+ err := s.taskPendingRepo.DeleteByDedupKey(ctx, wikiTaskType, wikiTaskScope, kbID, knowledgeID, WikiOpIngest)+ if err != nil {logger.Warnf(ctx, "wiki %s: failed to scrub pending ingest ops for knowledge %s: %v", reason, knowledgeID, err)return}@@ -552,15 +417,20 @@ func buildKnowledgeVectorDeleteGroups(// DeleteKnowledgeList deletes a knowledge entry and all related resourcesfunc (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []string) error {- if len(ids) == 0 {- return nil- }- // 1. Get the knowledge entry- tenantInfo := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)- knowledgeList, err := s.repo.GetKnowledgeBatch(ctx, tenantInfo.ID, ids)+ plan, err := s.planKnowledgeDelete(ctx, ids)if err != nil {return err}+ return s.executeKnowledgeDelete(plan, false)+}++func (s *knowledgeService) executeKnowledgeDelete(plan *knowledgeDeletePlan, single bool) error {+ if len(plan.ids) == 0 {+ return nil+ }+ ctx, ids, knowledgeList := plan.ctx, plan.ids, plan.knowledge+ knowledgeBases, kbFileServices := plan.kbs, plan.files+ tenantInfo, _ := types.TenantInfoFromContext(ctx)// Mark all as deleting first to prevent async task conflicts.// Remember which entries still had queued / in-flight downstream tasks@@ -568,12 +438,12 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []stringvar inFlightIDs []stringfor _, knowledge := range knowledgeList {prev := knowledge.ParseStatus+ before := *knowledgeknowledge.ParseStatus = types.ParseStatusDeleting- knowledge.UpdatedAt = time.Now()- if err := s.repo.UpdateKnowledge(ctx, knowledge); err != nil {+ if err := s.repo.UpdateKnowledgeForTransfer(ctx, &before, knowledge); err != nil {logger.GetLogger(ctx).WithField("error", err).WithField("knowledge_id", knowledge.ID).Errorf("DeleteKnowledgeList failed to mark as deleting")- // Continue with deletion even if marking fails+ return err}if prev == types.ParseStatusPending || prev == types.ParseStatusProcessing {inFlightIDs = append(inFlightIDs, knowledge.ID)@@ -582,28 +452,14 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []stringlogger.Infof(ctx, "Marked %d knowledge entries as deleting", len(knowledgeList))// Best-effort dequeue of downstream tasks for in-flight entries.- // See DeleteKnowledge for the rationale; loop is per-knowledge because+ // Workers also check deletion state; this avoids waking them unnecessarily.+ // The loop is per-knowledge because// the inspector only filters by knowledge_id, not by ID set.for _, kid := range inFlightIDs {s.dequeueKnowledgeTasks(ctx, kid)}- // Pre-resolve KB metadata and file services so goroutines don't need DB access.- knowledgeBases := make(map[string]*types.KnowledgeBase)- kbFileServices := make(map[string]interfaces.FileService)- for _, knowledge := range knowledgeList {- if _, ok := kbFileServices[knowledge.KnowledgeBaseID]; !ok {- kb, _ := s.kbService.GetKnowledgeBaseByID(ctx, knowledge.KnowledgeBaseID)- knowledgeBases[knowledge.KnowledgeBaseID] = kb- kbFileServices[knowledge.KnowledgeBaseID] = s.resolveFileService(ctx, kb)- }- }-- // Collect image URLs before chunks are deleted- chunkImageInfos, err := s.chunkService.GetRepository().ListImageInfoByKnowledgeIDs(ctx, tenantInfo.ID, ids)- if err != nil {- logger.Errorf(ctx, "Failed to collect image URLs for batch cleanup: %v", err)- }+ chunkImageInfos := plan.imageInfoknowledgeToKB := make(map[string]string)for _, k := range knowledgeList {knowledgeToKB[k.ID] = k.KnowledgeBaseID@@ -664,7 +520,7 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []string// 3. Clean wiki pages before deleting chunks so cleanup can still identify// which chunk_refs belonged to each source document.for _, knowledge := range knowledgeList {- kb, _ := s.kbService.GetKnowledgeBaseByID(ctx, knowledge.KnowledgeBaseID)+ kb := knowledgeBases[knowledge.KnowledgeBaseID]if kb != nil && kb.IsWikiEnabled() {s.cleanupWikiOnKnowledgeDelete(ctx, knowledge)}@@ -672,7 +528,7 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []string// 4. Delete all chunks associated with this knowledgewg.Go(func() error {- if err := s.chunkService.DeleteByKnowledgeList(ctx, ids); err != nil {+ if err := s.chunkRepo.DeleteByKnowledgeList(ctx, tenantInfo.ID, ids); err != nil {logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge delete chunks failed")return err}@@ -695,7 +551,7 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []stringreturn nil})- if err = wg.Wait(); err != nil {+ if err := wg.Wait(); err != nil {return err}for _, knowledgeID := range ids {@@ -704,7 +560,7 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []string}}// 6. Delete the knowledge rows FIRST, then drop their physical files. See- // DeleteKnowledge for the rationale: deferring file removal until the rows are+ // Deferring file removal until the rows are// gone avoids "file missing but row present" zombies that break reparse /// re-delete when an earlier cleanup step failed (issue #2192). A failure below// only orphans storage.@@ -731,7 +587,7 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []string}deleteExtractedImages(ctx, fSvc, knowledgeResourceOwners(s.resourceCatalog, kbKnowledgeIDs[kbID]...), urls)}- tenantInfo.StorageUsed += storageAdjust+ // TenantInfo can be shared by concurrent cleanup branches; update only storage accounting in the repository.if err := s.tenantRepo.AdjustStorageUsed(ctx, tenantInfo.ID, storageAdjust); err != nil {logger.GetLogger(ctx).WithField("error", err).Errorf("DeleteKnowledge update tenant storage used failed")}@@ -752,6 +608,13 @@ func (s *knowledgeService) DeleteKnowledgeList(ctx context.Context, ids []stringdetails["knowledge_ids"] = knowledgeIDs}kbActivityAppendSampleTitles(details, titles...)+ if single {+ knowledge := knowledges[0]+ recordKBActivity(ctx, s.audit, tenantInfo.ID, kbID, types.AuditActionKnowledgeDeleted,+ "knowledge", knowledge.ID, types.AuditOutcomeSuccess,+ map[string]any{"title": knowledge.Title, "type": knowledge.Type})+ continue+ }recordKBActivity(ctx, s.audit, tenantInfo.ID, kbID, types.AuditActionKnowledgeBatchDeleted,"knowledge", "", types.AuditOutcomeSuccess, details)}@@ -768,23 +631,14 @@ func (s *knowledgeService) cleanupKnowledgeResources(ctx context.Context, knowlereturn nil}+ kb, err := knowledgeWriteKB(ctx, s.kbService, knowledge)+ if err != nil {+ return fmt.Errorf("resolve cleanup knowledge base: %w", err)+ }tenantInfo := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)if knowledge.EmbeddingModelID != "" {- // Load KB to discover its VectorStoreID binding. Falls back to tenant- // effective engines if the KB has no binding or the load fails.- //- // Silent fallback risk: if a bound KB fails to load here due to a- // transient DB error, the cleanup will delete from env engines and- // leave orphan vectors in the bound store. Warn so operators can spot it.- var boundStoreID *string- if kb, loadErr := s.kbService.GetKnowledgeBaseByID(ctx, knowledge.KnowledgeBaseID); loadErr == nil && kb != nil {- boundStoreID = kb.VectorStoreID- } else if loadErr != nil {- logger.GetLogger(ctx).WithField("error", loadErr).WithField("knowledge_base_id", knowledge.KnowledgeBaseID).- Warnf("cleanupKnowledgeResources: failed to load KB for vector store resolution; falling back to tenant effective engines")- }retrieveEngine, err := retriever.CreateRetrieveEngineForKB(- ctx, s.retrieveEngine, s.ownership, tenantInfo.ID, boundStoreID)+ ctx, s.retrieveEngine, s.ownership, tenantInfo.ID, kb.VectorStoreID)if err != nil {logger.GetLogger(ctx).WithField("error", err).Error("Failed to init retrieve engine during cleanup")cleanupErr = errors.Join(cleanupErr, err)@@ -803,7 +657,6 @@ func (s *knowledgeService) cleanupKnowledgeResources(ctx context.Context, knowle}// Collect image URLs before chunks are deleted- kb, _ := s.kbService.GetKnowledgeBaseByID(ctx, knowledge.KnowledgeBaseID)fileSvc := s.resolveFileService(ctx, kb)chunkImageInfos, imgErr := s.chunkService.GetRepository().ListImageInfoByKnowledgeIDs(ctx, tenantInfo.ID, []string{knowledge.ID})if imgErr != nil {@@ -816,7 +669,7 @@ func (s *knowledgeService) cleanupKnowledgeResources(ctx context.Context, knowle}imageURLs := collectImageURLs(ctx, imageInfoStrs)- if err := s.chunkService.DeleteChunksByKnowledgeID(ctx, knowledge.ID); err != nil {+ if err := s.chunkRepo.DeleteChunksByKnowledgeID(ctx, knowledge.TenantID, knowledge.ID); err != nil {logger.GetLogger(ctx).WithField("error", err).Error("Failed to delete manual knowledge chunks")cleanupErr = errors.Join(cleanupErr, err)}@@ -860,20 +713,46 @@ func (s *knowledgeService) ProcessKnowledgeListDelete(ctx context.Context, t *aslogger.Infof(ctx, "Processing knowledge list delete task for %d knowledge items", len(payload.KnowledgeIDs))- // Get tenant info- tenant, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID)+ if payload.TenantID == 0 {+ return fmt.Errorf("invalid delete task tenant: %w", asynq.SkipRetry)+ }+ ids, err := writeResourceIDs(payload.KnowledgeIDs)if err != nil {- logger.Errorf(ctx, "Failed to get tenant %d: %v", payload.TenantID, err)- return err+ return fmt.Errorf("invalid delete task IDs: %w", asynq.SkipRetry)}-- // Set context values- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)- ctx = context.WithValue(ctx, types.TenantInfoContextKey, tenant)-- // Delete knowledge list- if err := s.DeleteKnowledgeList(ctx, payload.KnowledgeIDs); err != nil {- logger.Errorf(ctx, "Failed to delete knowledge list: %v", err)+ if len(ids) == 0 {+ return nil+ }+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)+ kbID := payload.KnowledgeBaseID+ if kbID == "" {+ // Pre-upgrade tasks were admitted by single-KB endpoints but omitted+ // the KB ID. Reconstruct only an unambiguous, same-tenant scope.+ rows, err := s.repo.GetKnowledgeBatch(ctx, payload.TenantID, ids)+ if err != nil {+ return err+ }+ if len(rows) == 0 {+ return nil+ }+ for _, row := range rows {+ if row == nil || row.TenantID != payload.TenantID || row.KnowledgeBaseID == "" ||+ (kbID != "" && row.KnowledgeBaseID != kbID) {+ return fmt.Errorf("ambiguous legacy delete scope: %w", asynq.SkipRetry)+ }+ kbID = row.KnowledgeBaseID+ }+ }+ bindings := make(map[string]string, len(ids))+ for _, id := range ids {+ bindings[id] = kbID+ }+ ctx = withKnowledgeCleanup(ctx, payload.TenantID, bindings)+ if err := s.DeleteKnowledgeList(ctx, ids); err != nil {+ var appErr *apperrors.AppError+ if errors.As(err, &appErr) && (appErr.HTTPCode == 403 || appErr.HTTPCode == 400 || appErr.HTTPCode == 409) {+ return fmt.Errorf("invalid delete task scope: %v: %w", err, asynq.SkipRetry)+ }return err}diff --git a/internal/application/service/knowledge_delete_plan.go b/internal/application/service/knowledge_delete_plan.gonew file mode 100644index 000000000..f08f17aea--- /dev/null+++ b/internal/application/service/knowledge_delete_plan.go@@ -0,0 +1,169 @@+package service++import (+ "context"++ "github.com/Tencent/WeKnora/internal/application/access"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+)++type knowledgeCleanupKey struct{}++// Cleanup continues a previously admitted operation on exact persisted+// references. It never grants general KB write access to a session owner.+type knowledgeCleanupScope struct {+ caller types.Caller+ tenant uint64+ bindings map[string]string // knowledge ID -> KB ID, copied when admitted+}++func withKnowledgeCleanup(ctx context.Context, tenant uint64, bindings map[string]string) context.Context {+ ctx = types.WithExecutionTenant(ctx, tenant)+ copyOfBindings := make(map[string]string, len(bindings))+ for id, kb := range bindings {+ copyOfBindings[id] = kb+ }+ return context.WithValue(ctx, knowledgeCleanupKey{}, knowledgeCleanupScope{+ caller: types.CallerFromContext(ctx), tenant: tenant, bindings: copyOfBindings,+ })+}++// Only call with IDs obtained from an already authorized persisted relationship+// (session messages, a temporary KB, or a clone diff), never a request body.+// expectedKB additionally pins workflows with an independently known KB.+func deleteReferencedKnowledge(+ ctx context.Context,+ svc interfaces.KnowledgeService,+ expectedKB string,+ ids []string,+) error {+ tenant, err := writeExecutionTenant(ctx)+ if err != nil {+ return err+ }+ ids, err = writeResourceIDs(ids)+ if err != nil || len(ids) == 0 {+ return err+ }+ rows, err := svc.GetRepository().GetKnowledgeBatch(ctx, tenant, ids)+ if err != nil {+ return err+ }+ wanted := make(map[string]bool, len(ids))+ for _, id := range ids {+ wanted[id] = true+ }+ bindings := make(map[string]string, len(rows))+ remaining := make([]string, 0, len(rows))+ for _, row := range rows {+ if row == nil || !wanted[row.ID] || row.TenantID != tenant || row.KnowledgeBaseID == "" ||+ (expectedKB != "" && row.KnowledgeBaseID != expectedKB) {+ return apperrors.NewForbiddenError("cleanup resource binding changed")+ }+ bindings[row.ID] = row.KnowledgeBaseID+ remaining = append(remaining, row.ID)+ }+ if len(remaining) == 0 {+ return nil+ }+ return svc.DeleteKnowledgeList(withKnowledgeCleanup(ctx, tenant, bindings), remaining)+}++type knowledgeDeletePlan struct {+ ctx context.Context+ ids []string+ knowledge []*types.Knowledge+ kbs map[string]*types.KnowledgeBase+ files map[string]interfaces.FileService+ imageInfo []interfaces.ChunkImageInfo+}++func (s *knowledgeService) planKnowledgeDelete(ctx context.Context, ids []string) (*knowledgeDeletePlan, error) {+ ids, err := writeResourceIDs(ids)+ if err != nil {+ return nil, err+ }+ plan := &knowledgeDeletePlan{+ ctx: ctx,+ kbs: make(map[string]*types.KnowledgeBase),+ files: make(map[string]interfaces.FileService),+ }+ if len(ids) == 0 {+ return plan, nil+ }+ tenant, err := writeExecutionTenant(ctx)+ if err != nil {+ return nil, err+ }+ cleanup, isCleanup := ctx.Value(knowledgeCleanupKey{}).(knowledgeCleanupScope)+ if isCleanup {+ if cleanup.tenant != tenant || cleanup.caller != types.CallerFromContext(ctx) {+ return nil, apperrors.NewForbiddenError("invalid cleanup scope")+ }+ for _, id := range ids {+ if cleanup.bindings[id] == "" {+ return nil, apperrors.NewForbiddenError("knowledge outside cleanup scope")+ }+ }+ }+ rows, err := s.repo.GetKnowledgeBatch(ctx, tenant, ids)+ if err != nil {+ return nil, err+ }+ byID := make(map[string]*types.Knowledge, len(rows))+ for _, row := range rows {+ if row != nil && row.TenantID == tenant {+ byID[row.ID] = row+ }+ }+ for _, id := range ids {+ row := byID[id]+ if row == nil {+ if isCleanup {+ // An earlier attempt already removed this exact resource.+ continue+ }+ return nil, apperrors.NewNotFoundError("knowledge not found")+ }+ if isCleanup && cleanup.bindings[id] != row.KnowledgeBaseID {+ return nil, apperrors.NewForbiddenError("cleanup resource binding changed")+ }+ if err := access.RejectMovingKnowledge(row); err != nil {+ return nil, err+ }+ if _, ok := plan.kbs[row.KnowledgeBaseID]; !ok {+ kb, err := knowledgeWriteKB(ctx, s.kbService, row)+ if err != nil {+ return nil, err+ }+ if !isCleanup {+ if _, err := requireKBWrite(ctx, kb); err != nil {+ return nil, err+ }+ }+ plan.kbs[kb.ID] = kb+ }+ copyOfRow := *row+ plan.knowledge = append(plan.knowledge, ©OfRow)+ plan.ids = append(plan.ids, id)+ }+ if len(plan.ids) == 0 {+ return plan, nil+ }+ // Resolve owner storage/index context and all KB routing before mutations.+ ctx, err = withKBWriteTenantInfo(ctx, plan.kbs[plan.knowledge[0].KnowledgeBaseID], s.tenantRepo)+ if err != nil {+ return nil, err+ }+ plan.ctx = ctx+ for id, kb := range plan.kbs {+ plan.files[id] = s.resolveFileService(ctx, kb)+ }+ plan.imageInfo, err = s.chunkRepo.ListImageInfoByKnowledgeIDs(ctx, tenant, plan.ids)+ if err != nil {+ return nil, err+ }+ return plan, nil+}diff --git a/internal/application/service/knowledge_faq.go b/internal/application/service/knowledge_faq.goindex b0afb1e8c..b935342a9 100644--- a/internal/application/service/knowledge_faq.go+++ b/internal/application/service/knowledge_faq.go@@ -32,32 +32,9 @@ func (s *knowledgeService) ListFAQEntries(ctx context.Context,return nil, err}- // Check if this is a shared knowledge base access- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)- effectiveTenantID := tenantID-- // If the kb belongs to a different tenant, check for shared access- if kb.TenantID != tenantID {- // Get user ID from context- userIDVal := ctx.Value(types.UserIDContextKey)- if userIDVal == nil {- return nil, werrors.NewForbiddenError("无权访问该知识库")- }- _ = userIDVal.(string) // userID retained only for legacy log fields- callerTenantRole := types.TenantRoleFromContext(ctx)-- // Check if the caller's tenant has at least viewer permission via org sharing.- hasPermission, err := s.kbShareService.HasTenantKBPermission(ctx, kbID, tenantID, callerTenantRole, types.OrgRoleViewer)- if err != nil || !hasPermission {- return nil, werrors.NewForbiddenError("无权访问该知识库")- }-- // Use the source tenant ID for data access- sourceTenantID, err := s.kbShareService.GetKBSourceTenant(ctx, kbID)- if err != nil {- return nil, werrors.NewForbiddenError("无权访问该知识库")- }- effectiveTenantID = sourceTenantID+ effectiveTenantID, err := resolveKBReadTenant(ctx, kb, s.kbShareService)+ if err != nil {+ return nil, err}faqKnowledge, err := s.findFAQKnowledge(ctx, effectiveTenantID, kb.ID)@@ -141,7 +118,7 @@ func (s *knowledgeService) CreateFAQEntry(ctx context.Context,return nil, werrors.NewBadRequestError("请求体不能为空")}- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return nil, err}@@ -342,7 +319,7 @@ func (s *knowledgeService) UpdateFAQEntry(ctx context.Context,if payload == nil {return nil, werrors.NewBadRequestError("请求体不能为空")}- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return nil, err}@@ -510,7 +487,7 @@ func (s *knowledgeService) AddSimilarQuestions(ctx context.Context,return nil, werrors.NewBadRequestError("相似问列表不能为空")}- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return nil, err}@@ -655,7 +632,7 @@ func (s *knowledgeService) AddSimilarQuestions(ctx context.Context,func (s *knowledgeService) UpdateFAQEntryStatus(ctx context.Context,kbID string, entryID string, isEnabled bool,) error {- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return err}@@ -704,7 +681,7 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context,if req == nil || (len(req.ByID) == 0 && len(req.ByTag) == 0) {return nil}- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return err}@@ -713,25 +690,17 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context,enabledUpdates := make(map[string]bool)tagUpdates := make(map[string]string)- // Convert exclude seq_ids to UUIDs- excludeUUIDs := make([]string, 0, len(req.ExcludeIDs))- if len(req.ExcludeIDs) > 0 {- excludeChunks, err := s.chunkRepo.ListChunksBySeqID(ctx, tenantID, req.ExcludeIDs)- if err == nil {- for _, c := range excludeChunks {- excludeUUIDs = append(excludeUUIDs, c.ID)- }- }+ plan, err := s.planFAQFields(ctx, kb, req)+ if err != nil {+ return err}+ excludeUUIDs := plan.excludeIDs// Handle ByTag updates first (by tag seq_id)if len(req.ByTag) > 0 {- for tagSeqID, update := range req.ByTag {- // Convert tag seq_id to UUID- tag, err := s.tagRepo.GetBySeqID(ctx, tenantID, tagSeqID)- if err != nil {- return werrors.NewNotFoundError(fmt.Sprintf("标签 %d 不存在", tagSeqID))- }+ for _, tagSeqID := range sortedFAQIDs(req.ByTag) {+ update := req.ByTag[tagSeqID]+ tag := plan.tags[tagSeqID]var setFlags, clearFlags types.ChunkFlags@@ -748,10 +717,7 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context,var newTagUUID *stringif update.TagID != nil {if *update.TagID > 0 {- newTag, err := s.tagRepo.GetBySeqID(ctx, tenantID, *update.TagID)- if err != nil {- return werrors.NewNotFoundError(fmt.Sprintf("标签 %d 不存在", *update.TagID))- }+ newTag := plan.tags[*update.TagID]newTagUUID = &newTag.ID} else {emptyStr := ""@@ -768,6 +734,19 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context,return err}+ // Preserve group changes when an explicit ByID patch follows it.+ for _, id := range affectedIDs {+ if chunk := plan.chunksByID[id]; chunk != nil {+ if update.IsEnabled != nil {+ chunk.IsEnabled = *update.IsEnabled+ }+ chunk.Flags = (chunk.Flags | setFlags) &^ clearFlags+ if newTagUUID != nil {+ chunk.TagID = *newTagUUID+ }+ }+ }+// Collect affected IDs for retriever syncif len(affectedIDs) > 0 {if update.IsEnabled != nil {@@ -786,33 +765,15 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context,// Handle ByID updates (by entry seq_id)if len(req.ByID) > 0 {- entrySeqIDs := make([]int64, 0, len(req.ByID))- for entrySeqID := range req.ByID {- entrySeqIDs = append(entrySeqIDs, entrySeqID)- }- chunks, err := s.chunkRepo.ListChunksBySeqID(ctx, tenantID, entrySeqIDs)- if err != nil {- return err- }-- // Build chunk seq_id to chunk map- chunkBySeqID := make(map[int64]*types.Chunk)- for _, chunk := range chunks {- chunkBySeqID[chunk.SeqID] = chunk- }+ chunkBySeqID := plan.chunkssetFlags := make(map[string]types.ChunkFlags)clearFlags := make(map[string]types.ChunkFlags)chunksToUpdate := make([]*types.Chunk, 0)- for entrySeqID, update := range req.ByID {- chunk, exists := chunkBySeqID[entrySeqID]- if !exists {- continue- }- if chunk.KnowledgeBaseID != kb.ID || chunk.ChunkType != types.ChunkTypeFAQ {- continue- }+ for _, entrySeqID := range sortedFAQIDs(req.ByID) {+ update := req.ByID[entrySeqID]+ chunk := chunkBySeqID[entrySeqID]needUpdate := false@@ -839,10 +800,7 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context,if update.TagID != nil {var newTagID stringif *update.TagID > 0 {- newTag, err := s.tagRepo.GetBySeqID(ctx, tenantID, *update.TagID)- if err != nil {- return werrors.NewNotFoundError(fmt.Sprintf("标签 %d 不存在", *update.TagID))- }+ newTag := plan.tags[*update.TagID]newTagID = newTag.ID}if chunk.TagID != newTagID {@@ -900,7 +858,7 @@ func (s *knowledgeService) UpdateFAQEntryFieldsBatch(ctx context.Context,// UpdateFAQEntryTag updates the tag assigned to an FAQ entry.func (s *knowledgeService) UpdateFAQEntryTag(ctx context.Context, kbID string, entryID string, tagID *string) error {- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return err}@@ -948,104 +906,15 @@ func (s *knowledgeService) UpdateFAQEntryTag(ctx context.Context, kbID string, e// UpdateFAQEntryTagBatch updates tags for FAQ entries in batch.// Key: entry seq_id, Value: tag seq_id (nil to remove tag)func (s *knowledgeService) UpdateFAQEntryTagBatch(ctx context.Context, kbID string, updates map[int64]*int64) error {- if len(updates) == 0 {- return nil- }- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)- if err != nil {- return err- }- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)-- // Get all chunks in batch by seq_id- entrySeqIDs := make([]int64, 0, len(updates))- for entrySeqID := range updates {- entrySeqIDs = append(entrySeqIDs, entrySeqID)- }- chunks, err := s.chunkRepo.ListChunksBySeqID(ctx, tenantID, entrySeqIDs)- if err != nil {- return err- }-- // Build chunk seq_id to chunk map- chunkBySeqID := make(map[int64]*types.Chunk)- for _, chunk := range chunks {- chunkBySeqID[chunk.SeqID] = chunk- }-- // Build tag seq_id set for validation- tagSeqIDSet := make(map[int64]bool)- for _, tagSeqID := range updates {- if tagSeqID != nil && *tagSeqID > 0 {- tagSeqIDSet[*tagSeqID] = true+ req := &types.FAQEntryFieldsBatchUpdate{ByID: make(map[int64]types.FAQEntryFieldsUpdate, len(updates))}+ for id, tag := range updates {+ value := int64(0) // nil in the tag API means remove the tag.+ if tag != nil {+ value = *tag}+ req.ByID[id] = types.FAQEntryFieldsUpdate{TagID: &value}}-- // Validate all tags in batch by seq_id- tagMap := make(map[int64]*types.KnowledgeTag)- if len(tagSeqIDSet) > 0 {- tagSeqIDs := make([]int64, 0, len(tagSeqIDSet))- for tagSeqID := range tagSeqIDSet {- tagSeqIDs = append(tagSeqIDs, tagSeqID)- }- tags, err := s.tagRepo.GetBySeqIDs(ctx, tenantID, tagSeqIDs)- if err != nil {- return err- }- for _, tag := range tags {- if tag.KnowledgeBaseID != kb.ID {- return werrors.NewBadRequestError(fmt.Sprintf("标签 %d 不属于当前知识库", tag.SeqID))- }- tagMap[tag.SeqID] = tag- }- }-- // Update chunks- chunksToUpdate := make([]*types.Chunk, 0)- for entrySeqID, tagSeqID := range updates {- chunk, exists := chunkBySeqID[entrySeqID]- if !exists {- continue- }- if chunk.KnowledgeBaseID != kb.ID || chunk.ChunkType != types.ChunkTypeFAQ {- continue- }-- var resolvedTagID string- if tagSeqID != nil && *tagSeqID > 0 {- tag, ok := tagMap[*tagSeqID]- if !ok {- return werrors.NewBadRequestError(fmt.Sprintf("标签 %d 不存在", *tagSeqID))- }- resolvedTagID = tag.ID- }-- chunk.TagID = resolvedTagID- chunk.UpdatedAt = time.Now()- chunksToUpdate = append(chunksToUpdate, chunk)- }-- if len(chunksToUpdate) > 0 {- if err := s.chunkRepo.UpdateChunks(ctx, chunksToUpdate); err != nil {- return err- }-- // Sync tag updates to retriever engines- tagUpdates := make(map[string]string)- for _, chunk := range chunksToUpdate {- tagUpdates[chunk.ID] = chunk.TagID- }- retrieveEngine, err := retriever.CreateRetrieveEngineForKB(- ctx, s.retrieveEngine, s.ownership, tenantID, kb.VectorStoreID)- if err != nil {- return err- }- if err := retrieveEngine.BatchUpdateChunkTagID(ctx, tagUpdates); err != nil {- return err- }- }-- return nil+ return s.UpdateFAQEntryFieldsBatch(ctx, kbID, req)}// SearchFAQEntries searches FAQ entries using hybrid search.@@ -1389,41 +1258,47 @@ func (s *knowledgeService) DeleteFAQEntries(ctx context.Context,if len(entrySeqIDs) == 0 {return werrors.NewBadRequestError("请选择需要删除的 FAQ 条目")}- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return err}tenantID := ctx.Value(types.TenantIDContextKey).(uint64)- var faqKnowledge *types.Knowledge- chunksToRemove := make([]*types.Chunk, 0, len(entrySeqIDs))- for _, seqID := range entrySeqIDs {- if seqID <= 0 {- continue- }- chunk, err := s.chunkRepo.GetChunkBySeqID(ctx, tenantID, seqID)- if err != nil {- return werrors.NewNotFoundError("FAQ条目不存在")- }- if chunk.KnowledgeBaseID != kb.ID || chunk.ChunkType != types.ChunkTypeFAQ {- return werrors.NewBadRequestError("包含无效的 FAQ 条目")- }- if err := s.chunkService.DeleteChunk(ctx, chunk.ID); err != nil {- return err- }- if faqKnowledge == nil {- faqKnowledge, err = s.repo.GetKnowledgeByID(ctx, tenantID, chunk.KnowledgeID)+ selected, err := s.loadFAQWriteChunks(ctx, kb, entrySeqIDs)+ if err != nil {+ return err+ }+ chunksToRemove := make([]*types.Chunk, 0, len(selected))+ knowledges := make(map[string]*types.Knowledge)+ groups := make(map[string][]*types.Chunk)+ for _, id := range sortedFAQIDs(selected) {+ chunk := selected[id]+ if knowledges[chunk.KnowledgeID] == nil {+ knowledge, err := s.repo.GetKnowledgeByID(ctx, tenantID, chunk.KnowledgeID)if err != nil {return err}+ if knowledge == nil || knowledge.TenantID != tenantID || knowledge.KnowledgeBaseID != kb.ID ||+ knowledge.Type != types.KnowledgeTypeFAQ {+ return werrors.NewForbiddenError("FAQ 文档不属于当前知识库")+ }+ knowledges[chunk.KnowledgeID] = knowledge}+ groups[chunk.KnowledgeID] = append(groups[chunk.KnowledgeID], chunk)chunksToRemove = append(chunksToRemove, chunk)}- if len(chunksToRemove) > 0 && faqKnowledge != nil {- if err := s.deleteFAQChunkVectors(ctx, kb, faqKnowledge, chunksToRemove); err != nil {+ // All entries and parent documents are authorized before any deletion.+ for _, chunk := range chunksToRemove {+ if err := s.chunkService.DeleteChunk(ctx, chunk.ID); err != nil {return err}}+ for id, chunks := range groups {+ if err := s.deleteFAQChunkVectors(ctx, kb, knowledges[id], chunks); err != nil {+ return err+ }+ }+details := map[string]any{"count": len(chunksToRemove), "source_type": "faq"}titles := make([]string, 0, len(chunksToRemove))for _, chunk := range chunksToRemove {@@ -1630,6 +1505,9 @@ func (s *knowledgeService) validateFAQKnowledgeBase(ctx context.Context, kbID stif err != nil {return nil, err}+ if kb == nil || kb.ID != kbID {+ return nil, werrors.NewNotFoundError("知识库不存在")+ }kb.EnsureDefaults()if kb.Type != types.KnowledgeBaseTypeFAQ {return nil, werrors.NewBadRequestError("仅 FAQ 知识库支持该操作")@@ -1906,7 +1784,9 @@ func (s *knowledgeService) buildFAQTagResolver(if len(seqIDs) > 0 {if tags, err := s.tagRepo.GetBySeqIDs(ctx, tenantID, seqIDs); err == nil {for _, t := range tags {- seqIDToUUID[t.SeqID] = t.ID+ if validateFAQTagScope(t, tenantID, kbID) == nil {+ seqIDToUUID[t.SeqID] = t.ID+ }}} else {logger.Warnf(ctx, "buildFAQTagResolver: batch GetBySeqIDs failed (%d ids), fallback per-entry: %v",@@ -1953,6 +1833,9 @@ func (s *knowledgeService) resolveTagID(ctx context.Context, kbID string, payloaif err != nil {return "", fmt.Errorf("failed to find tag by seq_id %d: %w", payload.TagID, err)}+ if err := validateFAQTagScope(tag, tenantID, kbID); err != nil {+ return "", err+ }return tag.ID, nil}diff --git a/internal/application/service/knowledge_faq_batch.go b/internal/application/service/knowledge_faq_batch.gonew file mode 100644index 000000000..4087020cb--- /dev/null+++ b/internal/application/service/knowledge_faq_batch.go@@ -0,0 +1,149 @@+package service++import (+ "context"+ "fmt"+ "sort"++ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+)++func sortedFAQIDs[V any](values map[int64]V) []int64 {+ ids := make([]int64, 0, len(values))+ for id := range values {+ ids = append(ids, id)+ }+ sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })+ return ids+}++// loadFAQWriteChunks validates the entire selection before the first mutation.+// Copies keep planning from mutating repository-owned snapshots on rejection.+func (s *knowledgeService) loadFAQWriteChunks(+ ctx context.Context,+ kb *types.KnowledgeBase,+ ids []int64,+) (map[int64]*types.Chunk, error) {+ wanted := make(map[int64]bool, len(ids))+ for _, id := range ids {+ if id <= 0 {+ return nil, apperrors.NewBadRequestError("FAQ 条目 ID 必须为正整数")+ }+ wanted[id] = true+ }+ result := make(map[int64]*types.Chunk, len(wanted))+ if len(wanted) == 0 {+ return result, nil+ }+ chunks, err := s.chunkRepo.ListChunksBySeqID(ctx, kb.TenantID, sortedFAQIDs(wanted))+ if err != nil {+ return nil, err+ }+ for _, chunk := range chunks {+ if chunk == nil || !wanted[chunk.SeqID] {+ continue+ }+ if chunk.TenantID != kb.TenantID || chunk.KnowledgeBaseID != kb.ID || chunk.ChunkType != types.ChunkTypeFAQ {+ return nil, apperrors.NewForbiddenError("FAQ 条目不属于当前知识库")+ }+ snapshot := *chunk+ result[chunk.SeqID] = &snapshot+ }+ if len(result) != len(wanted) {+ return nil, apperrors.NewNotFoundError("FAQ 条目不存在")+ }+ return result, nil+}++type faqFieldPlan struct {+ chunks map[int64]*types.Chunk+ chunksByID map[string]*types.Chunk+ tags map[int64]*types.KnowledgeTag+ excludeIDs []string+}++func (s *knowledgeService) planFAQFields(+ ctx context.Context,+ kb *types.KnowledgeBase,+ req *types.FAQEntryFieldsBatchUpdate,+) (*faqFieldPlan, error) {+ ids := append(sortedFAQIDs(req.ByID), req.ExcludeIDs...)+ chunks, err := s.loadFAQWriteChunks(ctx, kb, ids)+ if err != nil {+ return nil, err+ }+ plan := &faqFieldPlan{+ chunks: chunks,+ chunksByID: make(map[string]*types.Chunk),+ tags: make(map[int64]*types.KnowledgeTag),+ }+ for _, chunk := range chunks {+ plan.chunksByID[chunk.ID] = chunk+ }+ for _, id := range req.ExcludeIDs {+ plan.excludeIDs = append(plan.excludeIDs, chunks[id].ID)+ }+ tagIDs := make(map[int64]bool)+ for id := range req.ByTag {+ if id <= 0 {+ return nil, apperrors.NewBadRequestError("标签 ID 必须为正整数")+ }+ tagIDs[id] = true+ }+ for _, updates := range []map[int64]types.FAQEntryFieldsUpdate{req.ByTag, req.ByID} {+ for _, update := range updates {+ if update.TagID != nil && *update.TagID > 0 {+ tagIDs[*update.TagID] = true+ }+ }+ }+ if len(tagIDs) > 0 {+ tags, err := s.tagRepo.GetBySeqIDs(ctx, kb.TenantID, sortedFAQIDs(tagIDs))+ if err != nil {+ return nil, err+ }+ for _, tag := range tags {+ if tag == nil || !tagIDs[tag.SeqID] {+ continue+ }+ if err := validateFAQTagScope(tag, kb.TenantID, kb.ID); err != nil {+ return nil, err+ }+ plan.tags[tag.SeqID] = tag+ }+ for _, id := range sortedFAQIDs(tagIDs) {+ if plan.tags[id] == nil {+ return nil, apperrors.NewNotFoundError(fmt.Sprintf("标签 %d 不存在", id))+ }+ }+ }+ return plan, nil+}++func validateFAQTagScope(tag *types.KnowledgeTag, tenantID uint64, kbID string) error {+ if tag == nil {+ return apperrors.NewNotFoundError("标签不存在")+ }+ if tag.TenantID != tenantID || tag.KnowledgeBaseID != kbID {+ return apperrors.NewForbiddenError("标签不属于当前知识库")+ }+ return nil+}++func (s *knowledgeService) validateFAQImportTags(+ ctx context.Context,+ kb *types.KnowledgeBase,+ entries []types.FAQEntryPayload,+) error {+ // Import still reports per-entry content validation failures. Referenced+ // resources must all be in scope before admission or execution, however.+ req := &types.FAQEntryFieldsBatchUpdate{ByTag: make(map[int64]types.FAQEntryFieldsUpdate)}+ for _, entry := range entries {+ if entry.TagID != 0 {+ req.ByTag[entry.TagID] = types.FAQEntryFieldsUpdate{}+ }+ }+ _, err := s.planFAQFields(ctx, kb, req)+ return err+}diff --git a/internal/application/service/knowledge_faq_import.go b/internal/application/service/knowledge_faq_import.goindex 7bd6770f8..c944b846d 100644--- a/internal/application/service/knowledge_faq_import.go+++ b/internal/application/service/knowledge_faq_import.go@@ -11,6 +11,8 @@ import ("strings""time"+ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/application/service/retriever"werrors "github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/logger"@@ -39,10 +41,13 @@ func (s *knowledgeService) UpsertFAQEntries(ctx context.Context,}// 验证知识库是否存在且有效- kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return "", err}+ if err := s.validateFAQImportTags(ctx, kb, payload.Entries); err != nil {+ return "", err+ }tenantID := ctx.Value(types.TenantIDContextKey).(uint64)@@ -1386,7 +1391,7 @@ func (s *knowledgeService) executeFAQImport(ctx context.Context, taskID string,}}()- kb, err = s.validateFAQKnowledgeBase(ctx, kbID)+ kb, ctx, err = s.writableFAQKnowledgeBase(ctx, kbID)if err != nil {return err}@@ -2245,7 +2250,29 @@ func (s *knowledgeService) ProcessFAQImport(ctx context.Context, t *asynq.Task)ctx = logger.WithRequestID(ctx, uuid.New().String())ctx = logger.WithField(ctx, "faq_import", payload.TaskID)- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)+ kb, err := s.validateFAQKnowledgeBase(ctx, payload.KBID)+ if err != nil {+ if errors.Is(err, repository.ErrKnowledgeBaseNotFound) {+ return fmt.Errorf("%w: FAQ task KB no longer exists", asynq.SkipRetry)+ }+ return err+ }+ ctx, err = access.WithKBTaskWrite(ctx, kb, payload.TenantID)+ if err != nil {+ return fmt.Errorf("%w: FAQ task KB does not belong to its tenant", asynq.SkipRetry)+ }+ knowledge, err := s.repo.GetKnowledgeByID(ctx, payload.TenantID, payload.KnowledgeID)+ if err != nil {+ if errors.Is(err, repository.ErrKnowledgeNotFound) {+ return fmt.Errorf("%w: FAQ task document no longer exists", asynq.SkipRetry)+ }+ return err+ }+ if knowledge == nil || knowledge.TenantID != payload.TenantID || knowledge.KnowledgeBaseID != payload.KBID ||+ knowledge.Type != types.KnowledgeTypeFAQ {+ return fmt.Errorf("%w: FAQ task document does not belong to its KB", asynq.SkipRetry)+ }// 获取任务重试信息,用于判断是否是最后一次重试retryCount, _ := asynq.GetRetryCount(ctx)@@ -2287,6 +2314,9 @@ func (s *knowledgeService) ProcessFAQImport(ctx context.Context, t *asynq.Task)logger.Infof(ctx, "Processing FAQ import task: task_id=%s, kb_id=%s, total_entries=%d, dry_run=%v, retry=%d/%d",payload.TaskID, payload.KBID, len(payload.Entries), payload.DryRun, retryCount, maxRetry)+ if err := s.validateFAQImportTags(ctx, kb, payload.Entries); err != nil {+ return err+ }// 保存原始总数量originalTotalEntries := len(payload.Entries)@@ -2361,31 +2391,6 @@ func (s *knowledgeService) ProcessFAQImport(ctx context.Context, t *asynq.Task)logger.Warnf(ctx, "Failed to update FAQ import progress: %v", err)}- // 幂等性检查:获取knowledge记录(FAQ任务使用knowledge ID作为taskID)- knowledge, err := s.repo.GetKnowledgeByID(ctx, payload.TenantID, payload.KnowledgeID)- if err != nil {- logger.Errorf(ctx, "failed to get FAQ knowledge: %v", err)- return nil- }-- if knowledge == nil {- return nil- }-- kb, err := s.kbService.GetKnowledgeBaseByID(ctx, payload.KBID)- if err != nil {- logger.Errorf(ctx, "Failed to get knowledge base: %v", err)- // 如果是最后一次重试,更新状态为失败- if isLastRetry {- if updateErr := s.updateFAQImportProgressStatus(ctx, payload.TaskID, payload.InstanceID, payload.EnqueuedAt, types.FAQImportStatusFailed, 0, originalTotalEntries, 0, "获取知识库失败", err.Error()); updateErr != nil {- logger.Errorf(ctx, "Failed to update task status to failed: %v", updateErr)- }- s.recordFAQImportKBActivity(ctx, &payload, progress, originalTotalEntries, types.AuditActionFAQImportFailed, types.AuditOutcomeFailed)- }- s.cleanupFAQEntriesFileOnFinalFailure(ctx, payload.EntriesURL, retryCount, maxRetry)- return fmt.Errorf("failed to get knowledge base: %w", err)- }-// 检查任务状态 - 幂等性处理(复用之前获取的 existingProgress)var processedCount intif existingProgress != nil {@@ -2825,8 +2830,11 @@ func (s *knowledgeService) UpdateLastFAQImportResultDisplayStatus(ctx context.Coreturn werrors.NewBadRequestError("invalid display status, must be 'open' or 'close'")}- // 获取当前空间ID- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)+ kb, ctx, err := s.writableFAQKnowledgeBase(ctx, kbID)+ if err != nil {+ return err+ }+ tenantID := kb.TenantID// 查找FAQ类型的knowledgeknowledgeList, err := s.repo.ListKnowledgeByKnowledgeBaseID(ctx, tenantID, kbID)diff --git a/internal/application/service/knowledge_folder_move_test.go b/internal/application/service/knowledge_folder_move_test.goindex e235ad8f9..18bad69f1 100644--- a/internal/application/service/knowledge_folder_move_test.go+++ b/internal/application/service/knowledge_folder_move_test.go@@ -4,6 +4,7 @@ import ("context""testing"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces""github.com/stretchr/testify/assert"@@ -40,12 +41,23 @@ func (r *folderMoveRepoStub) RenameKnowledgeFolderPath(}func folderMoveContext() context.Context {- return context.WithValue(context.Background(), types.TenantIDContextKey, uint64(1))+ ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(1))+ return (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 1,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 1,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )}func TestMoveKnowledgeToFolderNormalizesDestination(t *testing.T) {repo := &folderMoveRepoStub{}- svc := &knowledgeService{repo: repo}+ svc := &knowledgeService{repo: repo, kbService: &writeKBLookup{kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 1}}}affected, err := svc.MoveKnowledgeToFolder(folderMoveContext(), "kb-1", []string{"k1", "k2"}, "/docs//spec/")require.NoError(t, err)@@ -56,7 +68,7 @@ func TestMoveKnowledgeToFolderNormalizesDestination(t *testing.T) {func TestMoveKnowledgeToFolderAcceptsRootAndRejectsEmptyBatch(t *testing.T) {repo := &folderMoveRepoStub{}- svc := &knowledgeService{repo: repo}+ svc := &knowledgeService{repo: repo, kbService: &writeKBLookup{kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 1}}}// The empty destination is meaningful: it files documents back at the top level._, err := svc.MoveKnowledgeToFolder(folderMoveContext(), "kb-1", []string{"k1"}, "")@@ -70,7 +82,7 @@ func TestMoveKnowledgeToFolderAcceptsRootAndRejectsEmptyBatch(t *testing.T) {func TestMoveKnowledgeToFolderRejectsTraversalAndUnsafeInput(t *testing.T) {repo := &folderMoveRepoStub{}- svc := &knowledgeService{repo: repo}+ svc := &knowledgeService{repo: repo, kbService: &writeKBLookup{kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 1}}}_, err := svc.MoveKnowledgeToFolder(folderMoveContext(), "kb-1", []string{"k1"}, "../../etc/docs")require.NoError(t, err)@@ -82,7 +94,7 @@ func TestMoveKnowledgeToFolderRejectsTraversalAndUnsafeInput(t *testing.T) {func TestRenameKnowledgeFolderValidatesPaths(t *testing.T) {repo := &folderMoveRepoStub{}- svc := &knowledgeService{repo: repo}+ svc := &knowledgeService{repo: repo, kbService: &writeKBLookup{kb: &types.KnowledgeBase{ID: "kb-1", TenantID: 1}}}ctx := folderMoveContext()affected, err := svc.RenameKnowledgeFolder(ctx, "kb-1", "docs", "handbook")@@ -112,3 +124,15 @@ func TestRenameKnowledgeFolderValidatesPaths(t *testing.T) {assert.Equal(t, int64(0), affected)assert.Equal(t, before, repo.renameCalls)}++func (r *folderMoveRepoStub) GetKnowledgeBatch(+ _ context.Context,+ tenant uint64,+ ids []string,+) ([]*types.Knowledge, error) {+ rows := make([]*types.Knowledge, 0, len(ids))+ for _, id := range ids {+ rows = append(rows, &types.Knowledge{ID: id, TenantID: tenant, KnowledgeBaseID: "kb-1"})+ }+ return rows, nil+}diff --git a/internal/application/service/knowledge_index_content_test.go b/internal/application/service/knowledge_index_content_test.goindex 80ee18f6f..55e6045df 100644--- a/internal/application/service/knowledge_index_content_test.go+++ b/internal/application/service/knowledge_index_content_test.go@@ -6,6 +6,7 @@ import ("errors""testing"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces""github.com/hibiken/asynq"@@ -74,7 +75,7 @@ type metadataUpdateKBService struct {func (metadataUpdateKBService) GetKnowledgeBaseByID(_ context.Context, id string,) (*types.KnowledgeBase, error) {- return &types.KnowledgeBase{ID: id, SummaryModelID: "summary-model"}, nil+ return &types.KnowledgeBase{ID: id, TenantID: 7, SummaryModelID: "summary-model"}, nil}type metadataUpdateTaskEnqueuer struct {@@ -114,6 +115,17 @@ func TestUpdateKnowledgeMetadataDoesNotReindexChunks(t *testing.T) {repo: repo, chunkRepo: chunkRepo, kbService: metadataUpdateKBService{}, task: taskEnqueuer,}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 7,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )err := service.UpdateKnowledge(ctx, &types.Knowledge{ID: "knowledge-1",@@ -143,6 +155,17 @@ func TestUpdateKnowledgeMetadataDoesNotLeaveTasklessPendingStatus(t *testing.T)task: &metadataUpdateTaskEnqueuer{err: errors.New("queue unavailable")},}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 7,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )require.NoError(t, service.UpdateKnowledge(ctx, &types.Knowledge{ID: "knowledge-1", CustomMetadata: types.JSON(`{"region":"Shanghai"}`),@@ -162,6 +185,17 @@ func TestUpdateKnowledgeUnchangedMetadataDoesNotRefreshSummary(t *testing.T) {repo: repo, chunkRepo: &metadataUpdateChunkRepo{}, kbService: metadataUpdateKBService{}, task: taskEnqueuer,}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 7,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )require.NoError(t, service.UpdateKnowledge(ctx, &types.Knowledge{ID: "knowledge-1",diff --git a/internal/application/service/knowledge_move_wiki_test.go b/internal/application/service/knowledge_move_wiki_test.goindex bf18bf01e..188fe3b7b 100644--- a/internal/application/service/knowledge_move_wiki_test.go+++ b/internal/application/service/knowledge_move_wiki_test.go@@ -2,8 +2,11 @@ package serviceimport ("context"+ "encoding/json"+ "errors""testing"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces""github.com/stretchr/testify/assert"@@ -19,6 +22,7 @@ import (type moveWikiKnowledgeRepo struct {interfaces.KnowledgeRepositoryknowledge *types.Knowledge+ commitErr error}func (r *moveWikiKnowledgeRepo) GetKnowledgeByID(@@ -40,22 +44,33 @@ func (r *moveWikiKnowledgeRepo) DeleteKnowledgeTagRelations(_ context.Context, _type moveWikiPageRepo struct {interfaces.WikiPageRepository- listedKBs []string+ listedKBs []string+ listErr error+ beforeList func()+ pages []*types.WikiPage}func (r *moveWikiPageRepo) ListBySourceRef(_ context.Context, kbID, _ string,) ([]*types.WikiPage, error) {r.listedKBs = append(r.listedKBs, kbID)- return nil, nil+ if r.beforeList != nil {+ r.beforeList()+ }+ return r.pages, r.listErr}type moveWikiPendingRepo struct {interfaces.TaskPendingOpsRepository- ops []*types.TaskPendingOp+ ops []*types.TaskPendingOp+ err error+ failKB string}func (r *moveWikiPendingRepo) Enqueue(_ context.Context, op *types.TaskPendingOp) error {+ if r.err != nil && (r.failKB == "" || r.failKB == op.ScopeID) {+ return r.err+ }r.ops = append(r.ops, op)return nil}@@ -67,6 +82,8 @@ func (r *moveWikiPendingRepo) DeleteByDedupKey(_ context.Context, _, _, _, _, _type moveWikiChunkRepo struct {interfaces.ChunkRepositorymovedToKB string+ moves int+ moveErr error}func (r *moveWikiChunkRepo) ListChunksByKnowledgeID(@@ -78,6 +95,10 @@ func (r *moveWikiChunkRepo) ListChunksByKnowledgeID(func (r *moveWikiChunkRepo) MoveChunksByKnowledgeID(_ context.Context, _ uint64, _ string, targetKBID string,) error {+ r.moves+++ if r.moveErr != nil {+ return r.moveErr+ }r.movedToKB = targetKBIDreturn nil}@@ -85,6 +106,7 @@ func (r *moveWikiChunkRepo) MoveChunksByKnowledgeID(func wikiEnabledKB(id string) *types.KnowledgeBase {return &types.KnowledgeBase{ID: id,+ TenantID: 1,IndexingStrategy: types.IndexingStrategy{WikiEnabled: true},}}@@ -124,25 +146,25 @@ func newMoveWikiService(t *testing.T) (}func moveWikiCtx() context.Context {- return context.WithValue(context.Background(), types.TenantIDContextKey, uint64(1))+ ctx, _ := access.WithKBTransferTask(+ context.Background(),+ wikiEnabledKB("kb-src"),+ wikiEnabledKB("kb-dst"),+ 1,+ access.KBTransferMove,+ "move-task",+ false,+ )+ return ctx}-func TestMoveOneKnowledgeRetractsWikiFromSourceKB(t *testing.T) {- // An unknown mode makes the move itself a no-op, which pins the cleanup as- // unconditional: it runs before the mode dispatch, while the knowledge still- // belongs to the source KB.+func TestMoveOneKnowledgeRejectsUnknownModeBeforeWikiCleanup(t *testing.T) {svc, wikiRepo, pendingRepo, _ := newMoveWikiService(t)-- err := svc.moveOneKnowledge(moveWikiCtx(), "kn-1",- wikiEnabledKB("kb-src"), wikiEnabledKB("kb-dst"), "bogus")-- require.Error(t, err)- assert.Equal(t, []string{"kb-src"}, wikiRepo.listedKBs)-- srcOps := opsFor(pendingRepo.ops, "kb-src")- require.Len(t, srcOps, 1)- assert.Equal(t, WikiOpRetract, srcOps[0].Op)- assert.Equal(t, "kn-1", srcOps[0].DedupKey)+ err := svc.moveOneKnowledge(moveWikiCtx(), "kn-1", wikiEnabledKB("kb-src"), wikiEnabledKB("kb-dst"), "bogus")+ require.ErrorContains(t, err, "unknown move mode")+ require.Empty(t, wikiRepo.listedKBs)+ require.Empty(t, pendingRepo.ops)+ require.Equal(t, types.ParseStatusCompleted, svc.repo.(*moveWikiKnowledgeRepo).knowledge.ParseStatus)}func TestMoveOneKnowledgeReuseVectorsIngestsIntoTargetKB(t *testing.T) {@@ -165,10 +187,187 @@ func TestMoveOneKnowledgeReuseVectorsIngestsIntoTargetKB(t *testing.T) {func TestMoveOneKnowledgeSkipsWikiWorkForNonWikiKBs(t *testing.T) {svc, wikiRepo, pendingRepo, _ := newMoveWikiService(t)- err := svc.moveOneKnowledge(moveWikiCtx(), "kn-1",- &types.KnowledgeBase{ID: "kb-src"}, &types.KnowledgeBase{ID: "kb-dst"}, "reuse_vectors")+ err := svc.moveOneKnowledge(+ moveWikiCtx(),+ "kn-1",+ &types.KnowledgeBase{+ ID: "kb-src",+ TenantID: 1,+ },+ &types.KnowledgeBase{ID: "kb-dst", TenantID: 1},+ "reuse_vectors",+ )require.NoError(t, err)assert.Empty(t, wikiRepo.listedKBs)assert.Empty(t, pendingRepo.ops)}++func (r *moveWikiKnowledgeRepo) UpdateKnowledgeForTransfer(+ ctx context.Context,+ _ *types.Knowledge,+ after *types.Knowledge,+) error {+ if after.KnowledgeBaseID == "kb-dst" && r.commitErr != nil {+ return r.commitErr+ }+ return r.UpdateKnowledge(ctx, after)+}++func (r *moveWikiChunkRepo) ListAllChunksByKnowledgeID(context.Context, uint64, string) ([]*types.Chunk, error) {+ return nil, nil+}++type moveWikiMetaService struct {+ interfaces.WikiPageService+ updated []*types.WikiPage+}++func (s *moveWikiMetaService) UpdatePageMeta(_ context.Context, page *types.WikiPage) error {+ s.updated = append(s.updated, page)+ return nil+}++func TestMoveWikiCleanupRunsOnlyAfterOwnershipCommit(t *testing.T) {+ for _, stage := range []string{"chunks", "CAS"} {+ t.Run(stage, func(t *testing.T) {+ svc, wiki, pending, chunks := newMoveWikiService(t)+ repo := svc.repo.(*moveWikiKnowledgeRepo)+ failure := errors.New("transfer failed")+ if stage == "chunks" {+ chunks.moveErr = failure+ } else {+ repo.commitErr = failure+ }+ err := svc.moveOneKnowledge(+ moveWikiCtx(),+ "kn-1",+ wikiEnabledKB("kb-src"),+ wikiEnabledKB("kb-dst"),+ "reuse_vectors",+ )+ require.ErrorIs(t, err, failure)+ require.Equal(t, "kb-src", repo.knowledge.KnowledgeBaseID)+ require.Empty(t, wiki.listedKBs)+ require.Empty(t, pending.ops)+ })+ }+}++func TestMoveWikiCleanupFailureRetriesWithoutMovingAgain(t *testing.T) {+ for _, stage := range []string{"lookup", "enqueue", "target enqueue"} {+ t.Run(stage, func(t *testing.T) {+ svc, wiki, pending, chunks := newMoveWikiService(t)+ repo := svc.repo.(*moveWikiKnowledgeRepo)+ failure := errors.New("wiki unavailable")+ if stage == "lookup" {+ wiki.listErr = failure+ } else {+ pending.err = failure+ if stage == "target enqueue" {+ pending.failKB = "kb-dst"+ }+ }+ wiki.beforeList = func() { require.Equal(t, "kb-dst", repo.knowledge.KnowledgeBaseID) }+ err := svc.moveOneKnowledge(+ moveWikiCtx(),+ "kn-1",+ wikiEnabledKB("kb-src"),+ wikiEnabledKB("kb-dst"),+ "reuse_vectors",+ )+ require.ErrorIs(t, err, failure)+ require.Equal(t, "kb-dst", repo.knowledge.KnowledgeBaseID)+ require.Equal(t, []string{"kb-src"}, wiki.listedKBs)+ require.Empty(t, opsFor(pending.ops, "kb-dst"))+ wiki.listErr = nil+ pending.err = nil+ require.NoError(+ t,+ svc.moveOneKnowledge(+ moveWikiCtx(),+ "kn-1",+ wikiEnabledKB("kb-src"),+ wikiEnabledKB("kb-dst"),+ "reuse_vectors",+ ),+ )+ require.Equal(t, 1, chunks.moves)+ require.Equal(t, []string{"kb-src", "kb-src"}, wiki.listedKBs)+ require.NotEmpty(t, opsFor(pending.ops, "kb-dst"))+ })+ }+}++func TestMoveReparseWikiUsesDurableSourceRefsAfterChunksDeleted(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ f.kbs.values["kb"].IndexingStrategy.WikiEnabled = true+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(+ t,+ row.SetManualMetadata(types.NewManualKnowledgeMetadata("# content", types.ManualKnowledgeStatusPublish, 1)),+ )+ row.Description = "source summary"+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ page := &types.WikiPage{+ ID: "page",+ KnowledgeBaseID: "kb",+ SourceRefs: types.StringArray{"doc", "other-doc"},+ ChunkRefs: types.StringArray{"chunk", "other-chunk"},+ }+ wiki := &moveWikiPageRepo{pages: []*types.WikiPage{page}}+ meta := &moveWikiMetaService{}+ pending := &moveWikiPendingRepo{}+ wiki.beforeList = func() {+ saved, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, "other", saved.KnowledgeBaseID)+ chunks, err := f.chunkRepo.ListAllChunksByKnowledgeID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Empty(t, chunks)+ }+ f.svc.wikiRepo = wiki+ f.svc.wikiService = meta+ f.svc.taskPendingRepo = pending+ f.svc.task = &transferQueue{}+ require.NoError(t, f.svc.ProcessKnowledgeMove(context.Background(), moveTask(t, []string{"doc"}, "reparse")))+ require.Equal(t, []string{"kb"}, wiki.listedKBs)+ require.Len(t, meta.updated, 1)+ require.Equal(t, types.StringArray{"other-doc"}, meta.updated[0].SourceRefs)+ require.Equal(t, types.StringArray{"other-chunk"}, meta.updated[0].ChunkRefs)+ ops := opsFor(pending.ops, "kb")+ require.Len(t, ops, 1)+ var payload WikiPendingOp+ require.NoError(t, json.Unmarshal(ops[0].Payload, &payload))+ require.Equal(t, "source summary", payload.DocSummary)+}++func TestMoveWikiRetractionIsDurableBeforeRemovingPageSources(t *testing.T) {+ svc, wiki, pending, chunks := newMoveWikiService(t)+ page := &types.WikiPage{ID: "page", Slug: "concept/source", SourceRefs: types.StringArray{"kn-1", "other"}}+ wiki.pages = []*types.WikiPage{page}+ meta := &moveWikiMetaService{}+ svc.wikiService = meta+ pending.err = errors.New("enqueue unavailable")+ err := svc.moveOneKnowledge(+ moveWikiCtx(),+ "kn-1",+ wikiEnabledKB("kb-src"),+ wikiEnabledKB("kb-dst"),+ "reuse_vectors",+ )+ require.ErrorIs(t, err, pending.err)+ require.Empty(t, meta.updated)+ require.Contains(t, page.SourceRefs, "kn-1")+ pending.err = nil+ require.NoError(+ t,+ svc.moveOneKnowledge(moveWikiCtx(), "kn-1", wikiEnabledKB("kb-src"), wikiEnabledKB("kb-dst"), "reuse_vectors"),+ )+ require.Equal(t, 1, chunks.moves)+ require.Len(t, meta.updated, 1)+ var op WikiPendingOp+ require.NoError(t, json.Unmarshal(opsFor(pending.ops, "kb-src")[0].Payload, &op))+ require.Equal(t, []string{"concept/source"}, op.PageSlugs)+}diff --git a/internal/application/service/knowledge_post_process.go b/internal/application/service/knowledge_post_process.goindex f3f28a6b9..35146c50b 100644--- a/internal/application/service/knowledge_post_process.go+++ b/internal/application/service/knowledge_post_process.go@@ -8,6 +8,7 @@ import ("sort""time"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/tracing/langfuse""github.com/Tencent/WeKnora/internal/types"@@ -83,11 +84,39 @@ func (s *KnowledgePostProcessService) Handle(ctx context.Context, task *asynq.Talogger.Infof(ctx, "[KnowledgePostProcess] Orchestrating post processing for knowledge: %s", payload.KnowledgeID)- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)if payload.Language != "" {ctx = context.WithValue(ctx, types.LanguageContextKey, payload.Language)}+ // 1. Fetch Knowledge and KB+ knowledge, err := s.knowledgeRepo.GetKnowledgeByIDOnly(ctx, payload.KnowledgeID)+ if err != nil {+ return fmt.Errorf("get knowledge %s: %w", payload.KnowledgeID, err)+ }+ if knowledge == nil {+ logger.Warnf(ctx, "[KnowledgePostProcess] Knowledge %s not found, aborting.", payload.KnowledgeID)+ return nil+ }++ if err := validateProcessingKnowledge(knowledge,+ payload.TenantID,+ payload.KnowledgeBaseID,+ payload.KnowledgeID); err != nil {+ return err+ }+ kb, err := s.kbService.GetKnowledgeBaseByIDOnly(ctx, payload.KnowledgeBaseID)+ if err != nil || kb == nil {+ return fmt.Errorf("get knowledge base %s: %w", payload.KnowledgeBaseID, err)+ }++ if kb.ID != payload.KnowledgeBaseID || kb.TenantID != payload.TenantID {+ return fmt.Errorf("postprocess task KB owner changed: %w", asynq.SkipRetry)+ }+ ctx, err = access.WithKBTaskWrite(ctx, kb, payload.TenantID)+ if err != nil {+ return fmt.Errorf("invalid postprocess scope: %v: %w", err, asynq.SkipRetry)+ }// Resolve attempt: payload carries it from the upstream stage, but// fall back to the latest known attempt for compatibility with// in-flight tasks queued before this code shipped.@@ -108,16 +137,6 @@ func (s *KnowledgePostProcessService) Handle(ctx context.Context, task *asynq.TapostSpan := s.tracker().BeginStage(ctx, payload.KnowledgeID, attempt, types.StagePostProcess, nil)- // 1. Fetch Knowledge and KB- knowledge, err := s.knowledgeRepo.GetKnowledgeByIDOnly(ctx, payload.KnowledgeID)- if err != nil {- return fmt.Errorf("get knowledge %s: %w", payload.KnowledgeID, err)- }- if knowledge == nil {- logger.Warnf(ctx, "[KnowledgePostProcess] Knowledge %s not found, aborting.", payload.KnowledgeID)- return nil- }-// Skip post-processing entirely when the knowledge has been cancelled// by the user or marked for deletion. We must NOT enqueue summary /// question / graph / wiki child tasks for an aborted knowledge. We@@ -136,11 +155,6 @@ func (s *KnowledgePostProcessService) Handle(ctx context.Context, task *asynq.Tareturn nil}- kb, err := s.kbService.GetKnowledgeBaseByIDOnly(ctx, payload.KnowledgeBaseID)- if err != nil || kb == nil {- return fmt.Errorf("get knowledge base %s: %w", payload.KnowledgeBaseID, err)- }-processOverrides, _ := knowledge.ProcessOverrides()eff := ResolveProcessConfig(kb, processOverrides)@@ -150,6 +164,13 @@ func (s *KnowledgePostProcessService) Handle(ctx context.Context, task *asynq.Tareturn fmt.Errorf("list chunks for knowledge %s: %w", payload.KnowledgeID, err)}+ for _, chunk := range chunks {+ if chunk == nil || chunk.TenantID != payload.TenantID || chunk.KnowledgeID != payload.KnowledgeID ||+ chunk.KnowledgeBaseID != payload.KnowledgeBaseID {+ return fmt.Errorf("postprocess chunk binding changed: %w", asynq.SkipRetry)+ }+ }+// Gather all text-like chunks (including newly added OCR and Caption from multimodal tasks)var textChunks []*types.Chunkfor _, c := range chunks {diff --git a/internal/application/service/knowledge_post_process_wiki_enqueue_test.go b/internal/application/service/knowledge_post_process_wiki_enqueue_test.goindex a3596678f..88c37a9dd 100644--- a/internal/application/service/knowledge_post_process_wiki_enqueue_test.go+++ b/internal/application/service/knowledge_post_process_wiki_enqueue_test.go@@ -117,21 +117,30 @@ func newWikiEnqueueTestService() (*KnowledgePostProcessService, *wikiEnqueueFailureKnowledgeRepo) {repo := &wikiEnqueueFailureKnowledgeRepo{knowledge: &types.Knowledge{- ID: knowledgeID,- ParseStatus: types.ParseStatusProcessing,+ ID: knowledgeID,+ TenantID: 7,+ KnowledgeBaseID: "kb-wiki",+ ParseStatus: types.ParseStatusProcessing,},}pendingRepo.knowledgeRepo = reporeturn &KnowledgePostProcessService{knowledgeRepo: repo,kbService: &wikiEnqueueFailureKBService{kb: &types.KnowledgeBase{- ID: "kb-wiki",+ ID: "kb-wiki",+ TenantID: 7,IndexingStrategy: types.IndexingStrategy{WikiEnabled: true,},}},chunkService: &wikiEnqueueFailureChunkService{chunks: []*types.Chunk{- {ID: "chunk-1", ChunkType: types.ChunkTypeText},+ {+ ID: "chunk-1",+ TenantID: 7,+ KnowledgeID: knowledgeID,+ KnowledgeBaseID: "kb-wiki",+ ChunkType: types.ChunkTypeText,+ },}},taskEnqueuer: queue,pendingRepo: pendingRepo,@@ -219,3 +228,13 @@ func TestKnowledgePostProcessRetriesWikiTriggerWithoutDoubleAccounting(t *testinqueue.taskTypes,)}++func TestPostProcessRejectsMovedKnowledgeBeforeWikiOrSpanWrites(t *testing.T) {+ pending := &wikiEnqueueFailurePendingRepo{}+ queue := &wikiEnqueueFailureTaskQueue{}+ svc, repo := newWikiEnqueueTestService("moved-doc", pending, queue)+ repo.knowledge.KnowledgeBaseID = "other-kb"+ require.ErrorIs(t, svc.Handle(context.Background(), newWikiEnqueuePostProcessTask(t, "moved-doc")), asynq.SkipRetry)+ require.Zero(t, repo.expectedSubtasks)+ require.Equal(t, types.ParseStatusProcessing, repo.knowledge.ParseStatus)+}diff --git a/internal/application/service/knowledge_process.go b/internal/application/service/knowledge_process.goindex ce9365fcd..04e2210fb 100644--- a/internal/application/service/knowledge_process.go+++ b/internal/application/service/knowledge_process.go@@ -10,6 +10,8 @@ import ("strings""time"+ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/application/service/retriever""github.com/Tencent/WeKnora/internal/common"werrors "github.com/Tencent/WeKnora/internal/errors"@@ -32,13 +34,21 @@ func (s *knowledgeService) cloneKnowledge(src *types.Knowledge,targetKB *types.KnowledgeBase,) (err error) {- if src.ParseStatus != "completed" {- logger.GetLogger(ctx).WithField("knowledge_id", src.ID).Errorf("MoveKnowledge parse status is not completed")- return nil+ sourceKB, err := knowledgeWriteKB(ctx, s.kbService, src)+ if err != nil {+ return err+ }+ if err := access.RequireKBTransfer(ctx, sourceKB, targetKB, access.KBTransferClone); err != nil {+ return err+ }+ if src.ParseStatus != types.ParseStatusCompleted {+ return fmt.Errorf("source knowledge %s is not completed", src.ID)+ }+ if _, err := s.transferChunks(ctx, src, sourceKB.ID); err != nil {+ return err}- tenantInfo := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)dst := &types.Knowledge{- ID: uuid.New().String(),+ ID: uuid.NewString(),TenantID: targetKB.TenantID,KnowledgeBaseID: targetKB.ID,Type: src.Type,@@ -55,8 +65,21 @@ func (s *knowledgeService) cloneKnowledge(FileSize: src.FileSize,FileHash: src.FileHash,FilePath: src.FilePath,- StorageSize: src.StorageSize,+ StorageSize: 0,Metadata: src.Metadata,+ CustomMetadata: src.CustomMetadata,+ }++ state := knowledgeTransferState{+ TaskID: access.TransferTaskID(ctx),+ Operation: access.KBTransferClone,+ SourceKB: sourceKB.ID,+ TargetKB: targetKB.ID,+ SourceID: src.ID,+ Phase: "cloning",+ }+ if err := setTransferState(dst, state); err != nil {+ return err}// Deep-copy the source document file into an object owned by the destination@@ -80,37 +103,52 @@ func (s *knowledgeService) cloneKnowledge(}defer func() {- if err != nil {- if len(copiedFilePaths) > 0 {- cleanupCopiedObjects(ctx, s.resolveFileService(ctx, targetKB), copiedFilePaths)- }- dst.ParseStatus = "failed"- dst.ErrorMessage = err.Error()- _ = s.repo.UpdateKnowledge(ctx, dst)- logger.GetLogger(ctx).WithField("error", err).Errorf("MoveKnowledge failed to move knowledge")- } else {- dst.ParseStatus = "completed"- dst.EnableStatus = "enabled"- _ = s.repo.UpdateKnowledge(ctx, dst)- logger.GetLogger(ctx).WithField("knowledge_id", dst.ID).Infof("MoveKnowledge move knowledge successfully")+ if err == nil {+ return}+ stored, loadErr := s.repo.GetKnowledgeByID(ctx, dst.TenantID, dst.ID)+ if errors.Is(loadErr, repository.ErrKnowledgeNotFound) {+ cleanupCopiedObjects(ctx, s.resolveFileService(ctx, targetKB), copiedFilePaths)+ return+ }+ // An uncertain save/read must not delete objects that may be referenced.+ if loadErr != nil || stored == nil || validateTransferKnowledge(stored, targetKB) != nil {+ return+ }+ marker, markerErr := transferState(stored)+ if markerErr != nil || !matchesTransfer(ctx, marker, sourceKB, targetKB, access.KBTransferClone, src.ID, "") ||+ stored.ParseStatus == types.ParseStatusCompleted {+ return+ }+ before, after := *stored, *stored+ after.ParseStatus = types.ParseStatusFailed+ after.ErrorMessage = err.Error()+ _ = s.repo.UpdateKnowledgeForTransfer(ctx, &before, &after)}()-if err = s.repo.CreateKnowledge(ctx, dst); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("MoveKnowledge create knowledge failed")- return+ return err}- tenantInfo.StorageUsed += dst.StorageSize- if err = s.tenantRepo.AdjustStorageUsed(ctx, tenantInfo.ID, dst.StorageSize); err != nil {- logger.GetLogger(ctx).WithField("error", err).Errorf("MoveKnowledge update tenant storage used failed")- return+ // Create timestamps can be rounded by the database before the first CAS.+ persisted, err := s.repo.GetKnowledgeByID(ctx, dst.TenantID, dst.ID)+ if err != nil {+ return err+ }+ if err := validateTransferKnowledge(persisted, targetKB); err != nil {+ return err}+ dst.UpdatedAt = persisted.UpdatedAtif err = s.CloneChunk(ctx, src, dst); err != nil {- logger.GetLogger(ctx).WithField("knowledge_id", dst.ID).- WithField("error", err).Errorf("MoveKnowledge move chunks failed")- return+ return err}- return+ before := *dst+ state.Phase = "done"+ if err = setTransferState(dst, state); err != nil {+ return err+ }+ dst.ParseStatus = types.ParseStatusCompleted+ dst.EnableStatus = "enabled"+ dst.StorageSize = src.StorageSize+ return s.repo.UpdateKnowledgeForTransfer(ctx, &before, dst)}// processDocumentFromPassage handles asynchronous processing of text passages@@ -294,7 +332,7 @@ func (s *knowledgeService) processChunks(ctx context.Context,logger.Infof(ctx, "Cleaning up existing chunks and index data for knowledge: %s", knowledge.ID)// 删除旧的chunks- if err := s.chunkService.DeleteChunksByKnowledgeID(ctx, knowledge.ID); err != nil {+ if err := s.chunkRepo.DeleteChunksByKnowledgeID(ctx, knowledge.TenantID, knowledge.ID); err != nil {logger.Warnf(ctx, "Failed to delete existing chunks (may not exist): %v", err)// 不返回错误,继续处理(可能没有旧数据)}@@ -494,7 +532,7 @@ func (s *knowledgeService) processChunks(ctx context.Context,s.beginStage(ctx, knowledge.ID, types.StageChunking, types.JSONMap{"chunks_planned": len(insertChunks),})- if err := s.chunkService.CreateChunks(ctx, insertChunks); err != nil {+ if err := s.chunkRepo.CreateChunks(ctx, insertChunks); err != nil {knowledge.ParseStatus = types.ParseStatusFailedknowledge.ErrorMessage = err.Error()knowledge.UpdatedAt = time.Now()@@ -574,7 +612,7 @@ func (s *knowledgeService) processChunks(ctx context.Context,if aborted, status := s.isKnowledgeAborted(ctx, knowledge.TenantID, knowledge.ID); aborted {logger.Infof(ctx, "Knowledge aborted (%s) before indexing: %s", status, knowledge.ID)if status == types.ParseStatusDeleting {- if err := s.chunkService.DeleteChunksByKnowledgeID(ctx, knowledge.ID); err != nil {+ if err := s.chunkRepo.DeleteChunksByKnowledgeID(ctx, knowledge.TenantID, knowledge.ID); err != nil {logger.Warnf(ctx, "Failed to cleanup chunks after deletion detected: %v", err)}}@@ -589,7 +627,7 @@ func (s *knowledgeService) processChunks(ctx context.Context,s.repo.UpdateKnowledge(ctx, knowledge)// delete failed chunks- if err := s.chunkService.DeleteChunksByKnowledgeID(ctx, knowledge.ID); err != nil {+ if err := s.chunkRepo.DeleteChunksByKnowledgeID(ctx, knowledge.TenantID, knowledge.ID); err != nil {logger.Errorf(ctx, "Delete chunks failed: %v", err)}@@ -622,7 +660,7 @@ func (s *knowledgeService) processChunks(ctx context.Context,if aborted, status := s.isKnowledgeAborted(ctx, knowledge.TenantID, knowledge.ID); aborted {logger.Infof(ctx, "Knowledge aborted (%s) after indexing: %s", status, knowledge.ID)if status == types.ParseStatusDeleting {- if err := s.chunkService.DeleteChunksByKnowledgeID(ctx, knowledge.ID); err != nil {+ if err := s.chunkRepo.DeleteChunksByKnowledgeID(ctx, knowledge.TenantID, knowledge.ID); err != nil {logger.Warnf(ctx, "Failed to cleanup chunks after deletion detected: %v", err)}if err := retrieveEngine.DeleteByKnowledgeIDList(ctx, []string{knowledge.ID}, embeddingModel.GetDimensions(), kb.Type); err != nil {@@ -1319,7 +1357,7 @@ func (s *knowledgeService) ProcessSummaryGeneration(ctx context.Context, t *asyn}// Save summary chunk- if err := s.chunkService.CreateChunks(ctx, []*types.Chunk{summaryChunk}); err != nil {+ if err := s.chunkRepo.CreateChunks(ctx, []*types.Chunk{summaryChunk}); err != nil {logger.Errorf(ctx, "Failed to create summary chunk: %v", err)summaryErr = errreturn fmt.Errorf("failed to create summary chunk: %w", err)@@ -1726,7 +1764,7 @@ func (s *knowledgeService) processQuestionGenerationForKnowledge(ctx context.Con}// Update chunk in database- if err := s.chunkService.UpdateChunk(ctx, chunk); err != nil {+ if err := s.chunkRepo.UpdateChunk(ctx, chunk); err != nil {chunkUpdateFailed++logger.Warnf(ctx, "Failed to update chunk %s: %v", chunk.ID, err)continue@@ -2059,7 +2097,7 @@ func (s *knowledgeService) processQuestionGenerationForChunks(ctx context.Contexlogger.Warnf(ctx, "Failed to set document metadata for chunk %s: %v", chunk.ID, err)continue}- if err := s.chunkService.UpdateChunk(ctx, chunk); err != nil {+ if err := s.chunkRepo.UpdateChunk(ctx, chunk); err != nil {logger.Warnf(ctx, "Failed to update chunk %s: %v", chunk.ID, err)continue}@@ -2180,13 +2218,12 @@ func (s *knowledgeService) RegenerateChunkQuestions(return nil, fmt.Errorf("questions can only be generated for text chunks")}generationRevision := chunk.ContentRevision- knowledge, err := s.repo.GetKnowledgeByID(ctx, tenantID, chunk.KnowledgeID)+ knowledge, kb, err := loadKnowledgeWrite(ctx, s.repo, s.kbService, chunk.KnowledgeID)if err != nil {return nil, err}- kb, err := s.kbService.GetKnowledgeBaseByID(ctx, chunk.KnowledgeBaseID)- if err != nil {- return nil, err+ if knowledge.KnowledgeBaseID != chunk.KnowledgeBaseID || chunk.TenantID != knowledge.TenantID {+ return nil, werrors.NewForbiddenError("chunk does not belong to its knowledge document")}if kb.SummaryModelID == "" {return nil, fmt.Errorf("summary model is required for question generation")@@ -2200,7 +2237,7 @@ func (s *knowledgeService) RegenerateChunkQuestions(return ""}neighbor, getErr := s.chunkRepo.GetChunkByID(ctx, tenantID, id)- if getErr != nil {+ if getErr != nil || !sameChunkDocument(chunk, neighbor) {return ""}return neighbor.Content@@ -2414,13 +2451,14 @@ func (s *knowledgeService) ReparseKnowledge() (*types.Knowledge, error) {logger.Info(ctx, "Start re-parsing knowledge")- tenantID := ctx.Value(types.TenantIDContextKey).(uint64)- existing, err := s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID)+ existing, kb, err := loadKnowledgeWrite(ctx, s.repo, s.kbService, knowledgeID)if err != nil {logger.Errorf(ctx, "Failed to load knowledge: %v", err)return nil, err}+ tenantID := existing.TenantID+// Allocate a fresh span tree attempt up front. Doing this BEFORE// the cleanup + enqueue means: (a) the UI immediately sees a new// attempt with all five stages back to "pending" instead of the@@ -2434,13 +2472,6 @@ func (s *knowledgeService) ReparseKnowledge(logger.Warnf(ctx, "[Reparse] OpenAttempt failed for %s: %v (will fall back in worker)", existing.ID, err)}- // Get knowledge base configuration- kb, err := s.kbService.GetKnowledgeBaseByID(ctx, existing.KnowledgeBaseID)- if err != nil {- logger.Errorf(ctx, "Failed to get knowledge base for reparse: %v", err)- return nil, err- }-// When the caller supplies new overrides (e.g. via the reparse confirm// dialog), validate them against this knowledge's file type, then persist// to metadata so both this call's enqueue and the worker re-read the same@@ -2914,6 +2945,10 @@ func (s *knowledgeService) UpdateImageInfo(chunkID string,imageInfo string,) error {+ knowledge, _, err := loadKnowledgeWrite(ctx, s.repo, s.kbService, knowledgeID)+ if err != nil {+ return err+ }imageInfo = common.CleanInvalidUTF8(imageInfo)var images []*types.ImageInfoif err := json.Unmarshal([]byte(imageInfo), &images); err != nil {@@ -2932,6 +2967,11 @@ func (s *knowledgeService) UpdateImageInfo(logger.Errorf(ctx, "Failed to get chunk: %v", err)return err}+ if chunk == nil || chunk.ID != chunkID || chunk.KnowledgeID != knowledge.ID ||+ chunk.TenantID != knowledge.TenantID ||+ chunk.KnowledgeBaseID != knowledge.KnowledgeBaseID {+ return werrors.NewForbiddenError("chunk does not belong to its knowledge document")+ }chunk.ImageInfo = imageInfotenantID := ctx.Value(types.TenantIDContextKey).(uint64)chunkChildren, err := s.chunkService.ListChunkByParentID(ctx, tenantID, chunkID)@@ -2942,6 +2982,11 @@ func (s *knowledgeService) UpdateImageInfo(})return err}+ for _, child := range chunkChildren {+ if !sameChunkDocument(chunk, child) {+ return werrors.NewForbiddenError("image child does not belong to its document")+ }+ }logger.Infof(ctx, "Found %d chunks with parent chunk ID: %s", len(chunkChildren), chunkID)// Iterate through each chunk and update its content based on the image information@@ -3029,7 +3074,7 @@ func (s *knowledgeService) UpdateImageInfo(logger.Infof(ctx, "Updated %d chunks out of %d total chunks", len(updateChunk), len(chunkChildren)+1)if len(addChunk) > 0 {- err := s.chunkService.CreateChunks(ctx, addChunk)+ err := s.chunkRepo.CreateChunks(ctx, addChunk)if err != nil {logger.ErrorWithFields(ctx, err, map[string]interface{}{"add_chunk_size": len(addChunk),@@ -3040,7 +3085,7 @@ func (s *knowledgeService) UpdateImageInfo(// Update the chunksfor _, c := range updateChunk {- err := s.chunkService.UpdateChunk(ctx, c)+ err := s.chunkRepo.UpdateChunk(ctx, c)if err != nil {logger.ErrorWithFields(ctx, err, map[string]interface{}{"chunk_id": c.ID,@@ -3061,7 +3106,7 @@ func (s *knowledgeService) UpdateImageInfo(}// Update the knowledge file hash- knowledge, err := s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID)+ knowledge, err = s.repo.GetKnowledgeByID(ctx, tenantID, knowledgeID)if err != nil {logger.Errorf(ctx, "Failed to get knowledge: %v", err)return err@@ -3088,7 +3133,7 @@ func (s *knowledgeService) ProcessManualUpdate(ctx context.Context, t *asynq.Tasctx = logger.WithRequestID(ctx, payload.RequestId)ctx = logger.WithField(ctx, "manual_process", payload.KnowledgeID)- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)tenantInfo, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID)if err != nil {@@ -3107,6 +3152,13 @@ func (s *knowledgeService) ProcessManualUpdate(ctx context.Context, t *asynq.Tasreturn nil}+ if err := validateProcessingKnowledge(knowledge,+ payload.TenantID,+ payload.KnowledgeBaseID,+ payload.KnowledgeID); err != nil {+ return err+ }+// Skip if already completed or being deletedif knowledge.ParseStatus == types.ParseStatusCompleted {logger.Infof(ctx, "ProcessManualUpdate: already completed, skipping: %s", payload.KnowledgeID)@@ -3130,6 +3182,13 @@ func (s *knowledgeService) ProcessManualUpdate(ctx context.Context, t *asynq.Tass.repo.UpdateKnowledge(ctx, knowledge)return nil}+ if kb == nil || kb.ID != payload.KnowledgeBaseID || kb.TenantID != payload.TenantID {+ return fmt.Errorf("processing task KB owner changed: %w", asynq.SkipRetry)+ }+ ctx, err = access.WithKBTaskWrite(ctx, kb, payload.TenantID)+ if err != nil {+ return fmt.Errorf("invalid processing scope: %v: %w", err, asynq.SkipRetry)+ }// Re-check abort status right before marking processing — see the same// note in ProcessDocument for the cancel race this guards.@@ -3185,7 +3244,7 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) ectx = logger.WithRequestID(ctx, payload.RequestId)ctx = logger.WithField(ctx, "document_process", payload.KnowledgeID)- ctx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)if payload.Language != "" {ctx = context.WithValue(ctx, types.LanguageContextKey, payload.Language)}@@ -3216,6 +3275,13 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) ereturn nil}+ if err := validateProcessingKnowledge(knowledge,+ payload.TenantID,+ payload.KnowledgeBaseID,+ payload.KnowledgeID); err != nil {+ return err+ }+// 检查是否正在删除 / 已被用户取消 - 如果是则直接退出if knowledge.ParseStatus == types.ParseStatusDeleting {logger.Infof(ctx, "Knowledge is being deleted, aborting processing: %s", payload.KnowledgeID)@@ -3261,6 +3327,13 @@ func (s *knowledgeService) ProcessDocument(ctx context.Context, t *asynq.Task) es.repo.UpdateKnowledge(ctx, knowledge)return nil}+ if kb == nil || kb.ID != payload.KnowledgeBaseID || kb.TenantID != payload.TenantID {+ return fmt.Errorf("processing task KB owner changed: %w", asynq.SkipRetry)+ }+ ctx, err = access.WithKBTaskWrite(ctx, kb, payload.TenantID)+ if err != nil {+ return fmt.Errorf("invalid processing scope: %v: %w", err, asynq.SkipRetry)+ }processOverrides, _ := knowledge.ProcessOverrides()eff := ResolveProcessConfig(kb, processOverrides)@@ -3926,6 +3999,11 @@ func (s *knowledgeService) ProcessKnowledgeListReparse(ctx context.Context, t *alogger.Infof(ctx, "Processing knowledge list reparse task for %d knowledge items", len(payload.KnowledgeIDs))+ ctx, ids, err := s.reparseTaskScope(ctx, payload)+ if err != nil || len(ids) == 0 {+ return err+ }+tenant, err := s.tenantRepo.GetTenantByID(ctx, payload.TenantID)if err != nil {logger.Errorf(ctx, "Failed to get tenant %d: %v", payload.TenantID, err)@@ -3935,7 +4013,7 @@ func (s *knowledgeService) ProcessKnowledgeListReparse(ctx context.Context, t *actx = context.WithValue(ctx, types.TenantIDContextKey, payload.TenantID)ctx = context.WithValue(ctx, types.TenantInfoContextKey, tenant)- outcome, err := runKnowledgeListReparseSubmissions(payload.KnowledgeIDs, func(id string) error {+ outcome, err := runKnowledgeListReparseSubmissions(ids, func(id string) error {_, err := s.ReparseKnowledge(ctx, id, payload.ProcessConfig)return err})diff --git a/internal/application/service/knowledge_process_parent_child_test.go b/internal/application/service/knowledge_process_parent_child_test.goindex a217a86a4..e4df0190e 100644--- a/internal/application/service/knowledge_process_parent_child_test.go+++ b/internal/application/service/knowledge_process_parent_child_test.go@@ -29,11 +29,11 @@ func (r *parentChildKnowledgeRepo) UpdateKnowledge(}type parentChildChunkService struct {- interfaces.ChunkService+ interfaces.ChunkRepositorycreated []*types.Chunk}-func (s *parentChildChunkService) DeleteChunksByKnowledgeID(context.Context, string) error {+func (s *parentChildChunkService) DeleteChunksByKnowledgeID(context.Context, uint64, string) error {return nil}@@ -160,7 +160,7 @@ func TestProcessChunksIndexesEveryTextChild(t *testing.T) {ctx := context.WithValue(context.Background(), types.TenantInfoContextKey, tenant)svc := &knowledgeService{repo: &parentChildKnowledgeRepo{knowledge: knowledge},- chunkService: chunkService,+ chunkRepo: chunkService,modelService: parentChildModelService{embedder: parentChildEmbedder{}},retrieveEngine: parentChildRetrieveRegistry{engine: retrieveEngine},graphEngine: parentChildGraphRepo{},diff --git a/internal/application/service/knowledge_reparse_scope.go b/internal/application/service/knowledge_reparse_scope.gonew file mode 100644index 000000000..44afcc3ff--- /dev/null+++ b/internal/application/service/knowledge_reparse_scope.go@@ -0,0 +1,60 @@+package service++import (+ "context"+ "fmt"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/hibiken/asynq"+)++// Validate the whole batch before any destructive submission. The exact KB+// grant is consumed again when ReparseKnowledge reloads each document.+func (s *knowledgeService) reparseTaskScope(+ ctx context.Context, payload types.KnowledgeListReparsePayload,+) (context.Context, []string, error) {+ if payload.TenantID == 0 {+ return ctx, nil, fmt.Errorf("invalid reparse task tenant: %w", asynq.SkipRetry)+ }+ ids, err := writeResourceIDs(payload.KnowledgeIDs)+ if err != nil {+ return ctx, nil, fmt.Errorf("invalid reparse task IDs: %w", asynq.SkipRetry)+ }+ if len(ids) == 0 {+ return ctx, ids, nil+ }+ ctx = types.WithExecutionTenant(ctx, payload.TenantID)+ rows, err := s.repo.GetKnowledgeBatch(ctx, payload.TenantID, ids)+ if err != nil {+ return ctx, nil, err+ }+ kbID := payload.KnowledgeBaseID+ seen := make(map[string]bool, len(rows))+ for _, row := range rows {+ if row == nil || row.TenantID != payload.TenantID || row.KnowledgeBaseID == "" ||+ (kbID != "" && row.KnowledgeBaseID != kbID) {+ return ctx, nil, fmt.Errorf("reparse task binding changed: %w", asynq.SkipRetry)+ }+ if err := access.RejectMovingKnowledge(row); err != nil {+ return ctx, nil, fmt.Errorf("reparse task document unavailable: %v: %w", err, asynq.SkipRetry)+ }+ // Legacy payloads can reconstruct only their current unambiguous KB.+ kbID = row.KnowledgeBaseID+ seen[row.ID] = true+ }+ for _, id := range ids {+ if !seen[id] {+ return ctx, nil, fmt.Errorf("reparse task document missing: %w", asynq.SkipRetry)+ }+ }+ kb, err := s.kbService.GetKnowledgeBaseByID(ctx, kbID)+ if err != nil {+ return ctx, nil, err+ }+ if kb == nil || kb.ID != kbID || kb.TenantID != payload.TenantID {+ return ctx, nil, fmt.Errorf("reparse task KB binding changed: %w", asynq.SkipRetry)+ }+ ctx, err = access.WithKBTaskWrite(ctx, kb, payload.TenantID)+ return ctx, ids, err+}diff --git a/internal/application/service/knowledge_shared_access_test.go b/internal/application/service/knowledge_shared_access_test.goindex be0e21214..a405ec0dc 100644--- a/internal/application/service/knowledge_shared_access_test.go+++ b/internal/application/service/knowledge_shared_access_test.go@@ -21,45 +21,64 @@ type fakeKBShareService struct {func (f *fakeKBShareService) ShareKnowledgeBase(context.Context, string, string, string, uint64, types.OrgMemberRole) (*types.KnowledgeBaseShare, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) UpdateSharePermission(context.Context, string, types.OrgMemberRole, string, uint64) error {return errors.New("not implemented")}+func (f *fakeKBShareService) RemoveShare(context.Context, string, string, uint64) error {return errors.New("not implemented")}+func (f *fakeKBShareService) ListSharesByKnowledgeBase(context.Context, string, uint64) ([]*types.KnowledgeBaseShare, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) ListSharesByOrganization(context.Context, string) ([]*types.KnowledgeBaseShare, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) ListSharedKnowledgeBases(context.Context, uint64, types.TenantRole) ([]*types.SharedKnowledgeBaseInfo, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) ListSharedKnowledgeBasesInOrganization(context.Context, string, uint64, types.TenantRole) ([]*types.OrganizationSharedKnowledgeBaseItem, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) ListSharedKnowledgeBaseIDsByOrganizations(context.Context, []string, uint64) (map[string][]string, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) GetShare(context.Context, string) (*types.KnowledgeBaseShare, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) GetShareByKBAndOrg(context.Context, string, string) (*types.KnowledgeBaseShare, error) {return nil, errors.New("not implemented")}-func (f *fakeKBShareService) CheckTenantKBPermission(context.Context, string, uint64, types.TenantRole) (types.OrgMemberRole, bool, error) {- return "", false, errors.New("not implemented")++func (f *fakeKBShareService) CheckTenantKBPermission(+ _ context.Context,+ kbID string,+ _ uint64,+ _ types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ return types.OrgRoleViewer, f.allowedKBs[kbID], nil}+func (f *fakeKBShareService) HasTenantKBPermission(ctx context.Context, kbID string, callerTenantID uint64, callerTenantRole types.TenantRole, requiredRole types.OrgMemberRole) (bool, error) {return f.allowedKBs[kbID], nil}+func (f *fakeKBShareService) GetKBSourceTenant(context.Context, string) (uint64, error) {return 0, errors.New("not implemented")}+func (f *fakeKBShareService) CountSharesByKnowledgeBaseIDs(context.Context, []string) (map[string]int64, error) {return nil, errors.New("not implemented")}+func (f *fakeKBShareService) CountByOrganizations(context.Context, []string) (map[string]int64, error) {return nil, errors.New("not implemented")}@@ -153,3 +172,57 @@ func TestGetKnowledgeBatchWithSharedAccess_ExcludesSharedKnowledgeWithoutPermiss}var _ interfaces.KBShareService = (*fakeKBShareService)(nil)++type countingKBShareService struct {+ fakeKBShareService+ calls int+}++func (s *countingKBShareService) CheckTenantKBPermission(+ ctx context.Context,+ id string,+ tenantID uint64,+ role types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ s.calls+++ return s.fakeKBShareService.CheckTenantKBPermission(ctx, id, tenantID, role)+}++func TestGetKnowledgeBatchWithSharedAccessChecksEachKBOnceAndRechecksNextRequest(t *testing.T) {+ shares := &countingKBShareService{+ fakeKBShareService: fakeKBShareService{allowedKBs: map[string]bool{"kb-shared": true}},+ }+ svc, db := newKnowledgeSharedAccessService(t, shares)+ for _, id := range []string{"first", "second"} {+ seedKnowledge(t, db, &types.Knowledge{ID: id, TenantID: 2, KnowledgeBaseID: "kb-shared", Type: "file"})+ }+ got, err := svc.GetKnowledgeBatchWithSharedAccess(newSharedAccessContext(), 1, []string{"first", "second"})+ require.NoError(t, err)+ require.Len(t, got, 2)+ require.Equal(t, 1, shares.calls)+ shares.allowedKBs["kb-shared"] = false+ got, err = svc.GetKnowledgeBatchWithSharedAccess(newSharedAccessContext(), 1, []string{"first", "second"})+ require.NoError(t, err)+ require.Empty(t, got)+ require.Equal(t, 2, shares.calls)+}++func TestResolveKBReadTenantPreservesServiceBoundary(t *testing.T) {+ kb := &types.KnowledgeBase{ID: "kb", TenantID: 2}+ shares := &fakeKBShareService{allowedKBs: map[string]bool{"kb": true}}+ tenant, err := resolveKBReadTenant(newSharedAccessContext(), kb, shares)+ require.NoError(t, err)+ require.Equal(t, uint64(2), tenant)+ _, err = resolveKBReadTenant(+ context.WithValue(context.Background(), types.TenantIDContextKey, uint64(1)),+ kb,+ shares,+ )+ require.Error(t, err, "direct cross-tenant calls still require a user identity")+ _, err = resolveKBReadTenant(newSharedAccessContext(), kb, nil)+ require.Error(t, err, "a missing share service cannot grant access")+ ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(2))+ tenant, err = resolveKBReadTenant(ctx, kb, nil)+ require.NoError(t, err, "a service execution context already scoped to the KB remains usable")+ require.Equal(t, uint64(2), tenant)+}diff --git a/internal/application/service/knowledge_shared_storage_failure_test.go b/internal/application/service/knowledge_shared_storage_failure_test.gonew file mode 100644index 000000000..cac55cc12--- /dev/null+++ b/internal/application/service/knowledge_shared_storage_failure_test.go@@ -0,0 +1,46 @@+package service++import (+ "context"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/repository"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++type failingSharedKnowledgeRepo struct {+ interfaces.KnowledgeRepository+ err error+}++func (r *failingSharedKnowledgeRepo) GetKnowledgeBatch(context.Context, uint64, []string) ([]*types.Knowledge, error) {+ return []*types.Knowledge{{ID: "own", TenantID: 1, KnowledgeBaseID: "own-kb"}}, nil+}++func (r *failingSharedKnowledgeRepo) GetKnowledgeByIDOnly(context.Context, string) (*types.Knowledge, error) {+ return nil, r.err+}++func TestSharedDocumentReadsPropagateStorageFailure(t *testing.T) {+ for _, failure := range []error{errors.New("database unavailable"), repository.ErrKnowledgeNotFound} {+ repo := &failingSharedKnowledgeRepo{err: failure}+ svc := &knowledgeService{repo: repo}+ search := &knowledgeBaseService{kgRepo: repo}+ rows, err := svc.GetKnowledgeBatchWithSharedAccess(newSharedAccessContext(), 1, []string{"own", "shared"})+ found, searchErr := search.fetchKnowledgeDataWithShared(newSharedAccessContext(), 1, []string{"own", "shared"})+ if errors.Is(failure, repository.ErrKnowledgeNotFound) {+ require.NoError(t, err)+ require.NoError(t, searchErr)+ require.Len(t, rows, 1)+ require.Len(t, found, 1)+ } else {+ require.ErrorIs(t, err, failure)+ require.ErrorIs(t, searchErr, failure)+ require.Nil(t, rows)+ require.Nil(t, found)+ }+ }+}diff --git a/internal/application/service/knowledge_transfer.go b/internal/application/service/knowledge_transfer.gonew file mode 100644index 000000000..415d3b431--- /dev/null+++ b/internal/application/service/knowledge_transfer.go@@ -0,0 +1,525 @@+package service++import (+ "context"+ "encoding/json"+ "fmt"+ "sort"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/service/retriever"+ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/hibiken/asynq"+)++// Transfer state lives with the document, so queue retries do not depend on+// an expiring progress cache. It is server metadata, never custom metadata.+type knowledgeTransferState struct {+ TaskID string `json:"task_id"`+ Operation access.KBTransferOperation `json:"operation"`+ SourceKB string `json:"source_kb"`+ TargetKB string `json:"target_kb"`+ SourceID string `json:"source_id"`+ Mode string `json:"mode,omitempty"`+ WikiChunkIDs []string `json:"wiki_chunk_ids,omitempty"`+ WikiSummary string `json:"wiki_summary,omitempty"`+ Phase string `json:"phase"`+}++func transferState(k *types.Knowledge) (*knowledgeTransferState, error) {+ fields := map[string]json.RawMessage{}+ if len(k.Metadata) != 0 {+ if err := json.Unmarshal(k.Metadata, &fields); err != nil {+ return nil, err+ }+ }+ raw := fields[types.KnowledgeTransferMetadataKey]+ if len(raw) == 0 {+ return nil, nil+ }+ var state knowledgeTransferState+ if err := json.Unmarshal(raw, &state); err != nil {+ return nil, err+ }+ return &state, nil+}++func setTransferState(k *types.Knowledge, state knowledgeTransferState) error {+ fields := map[string]json.RawMessage{}+ if len(k.Metadata) != 0 {+ if err := json.Unmarshal(k.Metadata, &fields); err != nil {+ return err+ }+ }+ if fields == nil {+ fields = map[string]json.RawMessage{}+ }+ raw, err := json.Marshal(state)+ if err != nil {+ return err+ }+ fields[types.KnowledgeTransferMetadataKey] = raw+ k.Metadata, err = json.Marshal(fields)+ return err+}++func matchesTransfer(+ ctx context.Context,+ state *knowledgeTransferState,+ source, target *types.KnowledgeBase,+ operation access.KBTransferOperation,+ sourceID, mode string,+) bool {+ return state != nil && state.TaskID != "" && state.TaskID == access.TransferTaskID(ctx) &&+ state.Operation == operation &&+ state.SourceKB == source.ID &&+ state.TargetKB == target.ID &&+ state.SourceID == sourceID &&+ state.Mode == mode+}++func validateTransferKnowledge(k *types.Knowledge, kb *types.KnowledgeBase) error {+ if k == nil || k.ID == "" || k.TenantID != kb.TenantID || k.KnowledgeBaseID != kb.ID {+ return fmt.Errorf("knowledge binding does not match the transfer scope")+ }+ return nil+}++// Read every chunk type and validate persisted document/KB/tag relationships+// before a clone or move can delete, index, create tags, or copy files.+func (s *knowledgeService) transferChunks(+ ctx context.Context,+ k *types.Knowledge,+ allowedKBs ...string,+) ([]*types.Chunk, error) {+ allowed := map[string]bool{}+ for _, id := range allowedKBs {+ allowed[id] = true+ }+ var all []*types.Chunk+ seen := map[string]bool{}+ tags := map[string]string{}+ chunks, err := s.chunkRepo.ListAllChunksByKnowledgeID(ctx, k.TenantID, k.ID)+ if err != nil {+ return nil, err+ }+ for _, c := range chunks {+ if c == nil || c.ID == "" || seen[c.ID] || c.TenantID != k.TenantID || c.KnowledgeID != k.ID ||+ !allowed[c.KnowledgeBaseID] {+ return nil, fmt.Errorf("chunk binding does not match the transfer scope")+ }+ seen[c.ID] = true+ if c.TagID != "" && tags[c.TagID] != c.KnowledgeBaseID {+ tag, err := s.tagRepo.GetByID(ctx, k.TenantID, c.TagID)+ if err != nil {+ return nil, err+ }+ if tag == nil || tag.ID != c.TagID || tag.TenantID != k.TenantID ||+ tag.KnowledgeBaseID != c.KnowledgeBaseID {+ return nil, fmt.Errorf("chunk tag belongs to another knowledge base")+ }+ tags[c.TagID] = c.KnowledgeBaseID+ }+ all = append(all, c)+ }++ for _, c := range all {+ if c.ParentChunkID != "" && !seen[c.ParentChunkID] {+ return nil, fmt.Errorf("chunk parent belongs to another document")+ }+ }+ return all, nil+}++func (s *knowledgeService) planKnowledgeMove(+ ctx context.Context,+ source, target *types.KnowledgeBase,+ ids []string,+ mode string,+) ([]*types.Knowledge, error) {+ if err := access.RequireKBTransfer(ctx, source, target, access.KBTransferMove); err != nil {+ return nil, err+ }+ tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)+ if err := access.ValidateKBTransferCompatibility(source, target, access.KBTransferMove, mode, tenant); err != nil {+ return nil, err+ }+ ids, err := writeResourceIDs(ids)+ if err != nil {+ return nil, err+ }+ if len(ids) == 0 {+ return nil, fmt.Errorf("knowledge IDs cannot be empty")+ }+ rows, err := s.repo.GetKnowledgeBatch(ctx, source.TenantID, ids)+ if err != nil {+ return nil, err+ }+ byID := map[string]*types.Knowledge{}+ for _, row := range rows {+ if row != nil {+ byID[row.ID] = row+ }+ }+ engineChecked := false+ result := make([]*types.Knowledge, 0, len(ids))+ for _, id := range ids {+ row := byID[id]+ if row == nil || row.TenantID != source.TenantID {+ return nil, fmt.Errorf("knowledge %s not found in transfer tenant", id)+ }+ if err := validateMoveItem(ctx, row, source, target, mode); err != nil {+ return nil, err+ }+ allowed := []string{row.KnowledgeBaseID}+ state, _ := transferState(row)+ if matchesTransfer(ctx, state, source, target, access.KBTransferMove, row.ID, mode) && state.Phase == "moving" {+ allowed = []string{source.ID, target.ID}+ }+ _, err = s.transferChunks(ctx, row, allowed...)+ if err != nil {+ return nil, err+ }+ if mode == "reuse_vectors" && row.EmbeddingModelID != "" {+ if row.EmbeddingModelID != source.EmbeddingModelID {+ return nil, fmt.Errorf("knowledge %s uses a different embedding model", row.ID)+ }+ if !engineChecked {+ engine, err := retriever.CreateRetrieveEngineForKB(+ ctx,+ s.retrieveEngine,+ s.ownership,+ source.TenantID,+ source.VectorStoreID,+ )+ if err != nil {+ return nil, err+ }+ if err := engine.ValidateKnowledgeIndexMove(ctx); err != nil {+ return nil, err+ }+ engineChecked = true+ }+ }+ snapshot := *row+ result = append(result, &snapshot)+ }+ return result, nil+}++func validateMoveItem(ctx context.Context, k *types.Knowledge, source, target *types.KnowledgeBase, mode string) error {+ if k == nil || k.TenantID != source.TenantID {+ return access.ErrForbidden+ }+ state, err := transferState(k)+ if err != nil {+ return err+ }+ if matchesTransfer(ctx, state, source, target, access.KBTransferMove, k.ID, mode) {+ switch state.Phase {+ case "moving":+ if k.KnowledgeBaseID == source.ID &&+ (k.ParseStatus == types.ParseStatusProcessing || k.ParseStatus == types.ParseStatusFailed) {+ return nil+ }+ case "reparse_pending", "done":+ if k.KnowledgeBaseID == target.ID {+ return nil+ }+ }+ return fmt.Errorf("knowledge %s changed during move", k.ID)+ }+ if k.KnowledgeBaseID != source.ID || k.ParseStatus != types.ParseStatusCompleted {+ return fmt.Errorf("knowledge %s must be completed in the source knowledge base", k.ID)+ }+ if state != nil && state.Phase != "done" {+ return fmt.Errorf("knowledge %s has an unfinished transfer", k.ID)+ }+ if mode == "reparse" {+ if k.IsManual() {+ meta, err := k.ManualMetadata()+ if err != nil || meta == nil || meta.Content == "" {+ return fmt.Errorf("knowledge %s has no manual content to reparse", k.ID)+ }+ } else if k.FilePath == "" {+ return fmt.Errorf("knowledge %s has no stored file to reparse", k.ID)+ }+ }+ return nil+}++type knowledgeClonePlan struct {+ add []*types.Knowledge+ remove []string+}++func (s *knowledgeService) planKnowledgeClone(+ ctx context.Context,+ source, target *types.KnowledgeBase,+) (*knowledgeClonePlan, error) {+ if err := access.RequireKBTransfer(ctx, source, target, access.KBTransferClone); err != nil {+ return nil, err+ }+ src, err := s.repo.ListKnowledgeByKnowledgeBaseID(ctx, source.TenantID, source.ID)+ if err != nil {+ return nil, err+ }+ dst, err := s.repo.ListKnowledgeByKnowledgeBaseID(ctx, target.TenantID, target.ID)+ if err != nil {+ return nil, err+ }+ for _, pair := range []struct {+ rows []*types.Knowledge+ kb *types.KnowledgeBase+ }{{src, source}, {dst, target}} {+ for _, k := range pair.rows {+ if err := validateTransferKnowledge(k, pair.kb); err != nil {+ return nil, err+ }+ if _, err := s.transferChunks(ctx, k, pair.kb.ID); err != nil {+ return nil, err+ }+ }+ }+ sort.Slice(src, func(i, j int) bool { return src[i].ID < src[j].ID })+ sort.Slice(dst, func(i, j int) bool { return dst[i].ID < dst[j].ID })+ plan := &knowledgeClonePlan{}+ used := map[string]bool{}+ for _, k := range src {+ if k.ParseStatus != types.ParseStatusCompleted {+ return nil, fmt.Errorf("source knowledge %s is not completed", k.ID)+ }+ matched := false+ // Prefer exact source bindings created by this task; unlike file hashes,+ // these also identify manual/empty-hash documents across retries.+ for _, other := range dst {+ state, err := transferState(other)+ if err != nil {+ return nil, err+ }+ if !used[other.ID] && matchesTransfer(ctx, state, source, target, access.KBTransferClone, k.ID, "") {+ used[other.ID] = true+ if state.Phase == "done" && other.ParseStatus == types.ParseStatusCompleted {+ matched = true+ } else {+ plan.remove = append(plan.remove, other.ID)+ }+ break+ }+ }+ if !matched && k.FileHash != "" {+ for _, other := range dst {+ if !used[other.ID] && other.FileHash == k.FileHash && other.ParseStatus == types.ParseStatusCompleted {+ used[other.ID] = true+ matched = true+ break+ }+ }+ }+ if !matched {+ plan.add = append(plan.add, k)+ }+ }+ for _, k := range dst {+ if used[k.ID] {+ continue+ }+ if k.ParseStatus == types.ParseStatusProcessing || k.ParseStatus == types.ParseStatusPending ||+ k.ParseStatus == types.ParseStatusDeleting {+ return nil, fmt.Errorf("target knowledge %s is busy", k.ID)+ }+ plan.remove = append(plan.remove, k.ID)+ }+ return plan, nil+}++func (s *knowledgeService) executeKnowledgeClone(+ ctx context.Context,+ source, target *types.KnowledgeBase,+ progress func(int, int),+) error {+ plan, err := s.planKnowledgeClone(ctx, source, target)+ if err != nil {+ return err+ }+ total, done := len(plan.add)+len(plan.remove), 0+ if progress != nil {+ progress(done, total)+ }+ if len(plan.remove) > 0 {+ // The complete binding/preflight plan above precedes the first deletion.+ if err := deleteReferencedKnowledge(ctx, s, target.ID, plan.remove); err != nil {+ return err+ }+ done += len(plan.remove)+ if progress != nil {+ progress(done, total)+ }+ }+ // Serial execution keeps storage accounting, tag creation and progress+ // coherent; each completed document is independently resumable.+ for _, k := range plan.add {+ if err := s.cloneKnowledge(ctx, k, target); err != nil {+ return err+ }+ done+++ if progress != nil {+ progress(done, total)+ }+ }+ return nil+}++// acknowledgeMovedReparse completes transfer admission, not document parsing.+// The target processing pipeline owns ParseStatus after its task is enqueued.+func (s *knowledgeService) acknowledgeMovedReparse(+ ctx context.Context,+ knowledge *types.Knowledge,+ source, target *types.KnowledgeBase,+) error {+ // The processing worker can already have updated the row after enqueue.+ // Reload before checkpointing; never overwrite its parse status or metadata.+ current, err := s.repo.GetKnowledgeByID(ctx, knowledge.TenantID, knowledge.ID)+ if err != nil {+ return err+ }+ if err := validateTransferKnowledge(current, target); err != nil {+ return err+ }+ state, err := transferState(current)+ if err != nil {+ return err+ }+ if !matchesTransfer(ctx, state, source, target, access.KBTransferMove, knowledge.ID, "reparse") {+ return access.ErrForbidden+ }+ if state.Phase == "done" {+ return nil+ }+ before := *current+ after := *current+ state.Phase = "done"+ if err := setTransferState(&after, *state); err != nil {+ return err+ }+ return s.repo.UpdateKnowledgeForTransfer(ctx, &before, &after)+}++func (s *knowledgeService) preflightFAQClone(+ ctx context.Context,+ source, target *types.KnowledgeBase,+) (map[string]*types.Chunk, map[string]*types.Chunk, error) {+ if err := access.RequireKBTransfer(ctx, source, target, access.KBTransferClone); err != nil {+ return nil, nil, err+ }+ maps := []map[string]*types.Chunk{{}, {}}+ for i, kb := range []*types.KnowledgeBase{source, target} {+ rows, err := s.repo.ListKnowledgeByKnowledgeBaseID(ctx, kb.TenantID, kb.ID)+ if err != nil {+ return nil, nil, err+ }+ if len(rows) > 1 {+ return nil, nil, fmt.Errorf("FAQ knowledge base has multiple document containers")+ }+ for _, row := range rows {+ if err := validateTransferKnowledge(row, kb); err != nil {+ return nil, nil, err+ }+ if row.Type != types.KnowledgeTypeFAQ {+ return nil, nil, fmt.Errorf("invalid FAQ container")+ }+ chunks, err := s.transferChunks(ctx, row, kb.ID)+ if err != nil {+ return nil, nil, err+ }+ for _, chunk := range chunks {+ if chunk.ChunkType != types.ChunkTypeFAQ {+ return nil, nil, fmt.Errorf("invalid FAQ chunk type")+ }+ maps[i][chunk.ID] = chunk+ }+ }+ }+ return maps[0], maps[1], nil+}++func (s *knowledgeService) markMoveItemFailed(+ ctx context.Context,+ id string,+ source, target *types.KnowledgeBase,+ mode string,+ taskErr error,+) {+ if access.RequireKBTransfer(ctx, source, target, access.KBTransferMove) != nil {+ return+ }+ row, err := s.repo.GetKnowledgeByID(ctx, source.TenantID, id)+ if err != nil || row == nil || row.ID != id || row.TenantID != source.TenantID {+ return+ }+ state, err := transferState(row)+ if err != nil || !matchesTransfer(ctx, state, source, target, access.KBTransferMove, id, mode) {+ return+ }+ sourceFailed := row.KnowledgeBaseID == source.ID && state.Phase == "moving" &&+ row.ParseStatus == types.ParseStatusProcessing+ enqueueFailed := row.KnowledgeBaseID == target.ID && state.Phase == "reparse_pending" &&+ row.ParseStatus == types.ParseStatusPending+ if !sourceFailed && !enqueueFailed {+ return+ }+ before, after := *row, *row+ after.ParseStatus = types.ParseStatusFailed+ after.ErrorMessage = taskErr.Error()+ if err := s.repo.UpdateKnowledgeForTransfer(ctx, &before, &after); err != nil {+ logger.Errorf(ctx, "Failed to record move failure for knowledge %s, task %s: %v (move error: %v)",+ row.ID, state.TaskID, err, taskErr)+ }+}++// A stale parser must not start after a move has claimed a completed document,+// including the interval before its knowledge_base_id changes. Reparse tasks+// emitted by the move are admitted only once the destination checkpoint exists.+func validateProcessingKnowledge(knowledge *types.Knowledge, tenant uint64, kbID, knowledgeID string) error {+ if knowledge == nil || tenant == 0 || kbID == "" || knowledge.ID != knowledgeID || knowledge.TenantID != tenant ||+ knowledge.KnowledgeBaseID != kbID {+ return fmt.Errorf("processing task binding changed: %w", asynq.SkipRetry)+ }+ state, err := transferState(knowledge)+ if err != nil {+ return fmt.Errorf("invalid processing metadata: %v: %w", err, asynq.SkipRetry)+ }+ if state != nil && state.Operation == access.KBTransferMove && state.Phase == "moving" {+ return fmt.Errorf("knowledge is being moved: %w", asynq.SkipRetry)+ }+ return nil+}++// Cleanup consumes the durable source references only after target ownership+// is committed. A done transfer is retried here when wiki reconciliation fails.+func (s *knowledgeService) cleanupMovedSourceWiki(ctx context.Context, knowledge *types.Knowledge,+ source, target *types.KnowledgeBase,+) error {+ if !source.IsWikiEnabled() {+ return nil+ }+ if knowledge.KnowledgeBaseID != target.ID {+ return access.ErrForbidden+ }+ state, err := transferState(knowledge)+ if err != nil {+ return err+ }+ if state == nil || state.SourceKB != source.ID || state.TargetKB != target.ID {+ return access.ErrForbidden+ }+ old := *knowledge+ old.KnowledgeBaseID = source.ID+ old.Description = state.WikiSummary+ refs := make(map[string]bool, len(state.WikiChunkIDs))+ for _, id := range state.WikiChunkIDs {+ refs[id] = true+ }+ return s.cleanupWikiReferences(ctx, &old, refs)+}diff --git a/internal/application/service/knowledge_transfer_test.go b/internal/application/service/knowledge_transfer_test.gonew file mode 100644index 000000000..28487f418--- /dev/null+++ b/internal/application/service/knowledge_transfer_test.go@@ -0,0 +1,457 @@+package service++import (+ "context"+ "encoding/json"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/alicebob/miniredis/v2"+ "github.com/hibiken/asynq"+ "github.com/redis/go-redis/v9"+ "github.com/stretchr/testify/require"+)++func transferFixture(t *testing.T, operation access.KBTransferOperation) *documentWriteFixture {+ t.Helper()+ f := newDocumentWriteFixture(t)+ require.NoError(t, f.db.AutoMigrate(&types.Tenant{}))+ require.NoError(t, f.db.Create(&types.Tenant{ID: 7, Name: "tenant", StorageUsed: 5}).Error)+ require.NoError(+ t,+ f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("parse_status", types.ParseStatusCompleted).Error,+ )+ ctx, err := access.WithKBTransferTask(+ context.Background(),+ f.kbs.values["kb"],+ f.kbs.values["other"],+ 7,+ operation,+ "transfer-task",+ false,+ )+ require.NoError(t, err)+ f.ctx = context.WithValue(ctx, types.TenantInfoContextKey, &types.Tenant{ID: 7, StorageUsed: 5})+ mr := miniredis.RunT(t)+ f.svc.redisClient = redis.NewClient(&redis.Options{Addr: mr.Addr()})+ t.Cleanup(func() { require.NoError(t, f.svc.redisClient.Close()) })+ return f+}++func moveTask(t *testing.T, ids []string, mode string) *asynq.Task {+ t.Helper()+ raw, err := json.Marshal(+ types.KnowledgeMovePayload{+ TenantID: 7,+ TaskID: "transfer-task",+ SourceKBID: "kb",+ TargetKBID: "other",+ KnowledgeIDs: ids,+ Mode: mode,+ },+ )+ require.NoError(t, err)+ return asynq.NewTask(types.TypeKnowledgeMove, raw)+}++func TestMoveBatchPreflightHasNoPartialMutations(t *testing.T) {+ for _, ids := range [][]string{{"doc", "missing"}, {"doc", "other-doc"}, {"doc", ""}} {+ t.Run(ids[1], func(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ err := f.svc.ProcessKnowledgeMove(context.Background(), moveTask(t, ids, "reuse_vectors"))+ require.Error(t, err)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, types.ParseStatusCompleted, row.ParseStatus)+ require.Equal(t, "kb", row.KnowledgeBaseID)+ require.Empty(t, row.Metadata)+ require.Zero(t, f.chunkRepo.writes)+ require.Zero(t, f.graph.calls)+ })+ }+}++func TestMoveRejectsInvalidPairAndModeBeforeWrites(t *testing.T) {+ for _, change := range []string{"tenant", "same KB", "mode", "chunk", "tag"} {+ t.Run(change, func(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ mode := "reuse_vectors"+ switch change {+ case "tenant":+ f.kbs.values["other"].TenantID = 8+ case "same KB":+ f.kbs.values["other"].ID = "kb"+ case "mode":+ mode = "bogus"+ case "chunk":+ require.NoError(+ t,+ f.db.Model(&types.Chunk{}).Where("id = ?", "chunk").Update("knowledge_base_id", "third").Error,+ )+ case "tag":+ require.NoError(t, f.db.Model(&types.Chunk{}).Where("id = ?", "chunk").Update("tag_id", "tag").Error)+ require.NoError(+ t,+ f.db.Model(&types.KnowledgeTag{}).Where("id = ?", "tag").Update("knowledge_base_id", "other").Error,+ )+ }+ require.Error(t, f.svc.ProcessKnowledgeMove(context.Background(), moveTask(t, []string{"doc"}, mode)))+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, types.ParseStatusCompleted, row.ParseStatus)+ require.Empty(t, row.Metadata)+ })+ }+}++type transferFaultRepo struct {+ interfaces.KnowledgeRepository+ failID string+ claims int+}++func (r *transferFaultRepo) DeleteKnowledgeTagRelations(ctx context.Context, id string) error {+ if id == r.failID {+ return errors.New("temporary tag cleanup failure")+ }+ return r.KnowledgeRepository.DeleteKnowledgeTagRelations(ctx, id)+}++func (r *transferFaultRepo) UpdateKnowledgeForTransfer(ctx context.Context, before, after *types.Knowledge) error {+ r.claims+++ return r.KnowledgeRepository.UpdateKnowledgeForTransfer(ctx, before, after)+}++func TestMovePartialFailureResumesAndSkipsCompletedDocuments(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ require.NoError(+ t,+ f.db.Create(+ &types.Knowledge{ID: "second", TenantID: 7, KnowledgeBaseID: "kb", ParseStatus: types.ParseStatusCompleted},+ ).Error,+ )+ require.NoError(+ t,+ f.db.Create(+ &types.Chunk{+ ID: "second-chunk",+ TenantID: 7,+ KnowledgeID: "second",+ KnowledgeBaseID: "kb",+ ChunkType: types.ChunkTypeImageOCR,+ },+ ).Error,+ )+ fault := &transferFaultRepo{KnowledgeRepository: f.repo, failID: "second"}+ f.svc.repo = fault+ task := moveTask(t, []string{"doc", "doc", "second"}, "reuse_vectors")+ require.ErrorContains(t, f.svc.ProcessKnowledgeMove(context.Background(), task), "temporary tag cleanup failure")+ first, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, "other", first.KnowledgeBaseID)+ firstUpdated := first.UpdatedAt+ second, err := f.repo.GetKnowledgeByID(f.ctx, 7, "second")+ require.NoError(t, err)+ require.Equal(t, "kb", second.KnowledgeBaseID)+ state, err := transferState(second)+ require.NoError(t, err)+ require.Equal(t, "moving", state.Phase)+ fault.failID = ""+ require.NoError(t, f.svc.ProcessKnowledgeMove(context.Background(), task))+ first, err = f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, firstUpdated, first.UpdatedAt, "completed item must not be moved again")+ second, err = f.repo.GetKnowledgeByID(f.ctx, 7, "second")+ require.NoError(t, err)+ require.Equal(t, "other", second.KnowledgeBaseID)+ require.Equal(t, types.ParseStatusCompleted, second.ParseStatus)+ progress, err := f.svc.GetKnowledgeMoveProgress(f.ctx, "transfer-task")+ require.NoError(t, err)+ require.Equal(t, 2, progress.Total)+ require.Zero(t, progress.Failed)+ require.Equal(t, types.KBCloneStatusCompleted, progress.Status)+}++type transferQueue struct {+ fail bool+ ids []string+}++func (q *transferQueue) Enqueue(_ *asynq.Task, options ...asynq.Option) (*asynq.TaskInfo, error) {+ for _, option := range options {+ if option.Type() == asynq.TaskIDOpt {+ q.ids = append(q.ids, option.Value().(string))+ }+ }+ if q.fail {+ return nil, errors.New("queue unavailable")+ }+ return &asynq.TaskInfo{ID: "processing-task"}, nil+}++func TestMoveReparseRetryOnlyReenqueuesAndAccountsOnce(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(+ t,+ row.SetManualMetadata(types.NewManualKnowledgeMetadata("# content", types.ManualKnowledgeStatusPublish, 1)),+ )+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ queue := &transferQueue{fail: true}+ f.svc.task = queue+ task := moveTask(t, []string{"doc"}, "reparse")+ require.ErrorContains(t, f.svc.ProcessKnowledgeMove(context.Background(), task), "queue unavailable")+ row, err = f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, "other", row.KnowledgeBaseID)+ require.Zero(t, row.StorageSize)+ cleanupCalls := f.graph.calls+ var tenant types.Tenant+ require.NoError(t, f.db.First(&tenant, 7).Error)+ require.Zero(t, tenant.StorageUsed)+ // A parser may already have written manual metadata before the move's ack.+ meta, err := row.ManualMetadata()+ require.NoError(t, err)+ require.NoError(t, row.SetManualMetadata(meta))+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ queue.fail = false+ require.NoError(t, f.svc.ProcessKnowledgeMove(context.Background(), task))+ require.Equal(t, cleanupCalls, f.graph.calls)+ require.Len(t, queue.ids, 2)+ require.Equal(t, queue.ids[0], queue.ids[1])+ require.NoError(t, f.db.First(&tenant, 7).Error)+ require.Zero(t, tenant.StorageUsed)+ row, err = f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ state, err := transferState(row)+ require.NoError(t, err)+ require.Equal(t, "done", state.Phase)+}++type cloneFaultChunks struct {+ interfaces.ChunkRepository+ fail bool+}++func (r *cloneFaultChunks) CreateChunks(ctx context.Context, chunks []*types.Chunk) error {+ if err := r.ChunkRepository.CreateChunks(ctx, chunks); err != nil {+ return err+ }+ if r.fail {+ return errors.New("lost clone acknowledgement")+ }+ return nil+}++func TestCloneRetryReplacesIncompleteCopyWithoutDuplicatingEmptyHashes(t *testing.T) {+ f := transferFixture(t, access.KBTransferClone)+ fault := &cloneFaultChunks{ChunkRepository: f.chunkRepo, fail: true}+ f.svc.chunkRepo = fault+ require.ErrorContains(+ t,+ f.svc.executeKnowledgeClone(f.ctx, f.kbs.values["kb"], f.kbs.values["other"], nil),+ "lost clone acknowledgement",+ )+ rows, err := f.repo.ListKnowledgeByKnowledgeBaseID(f.ctx, 7, "other")+ require.NoError(t, err)+ require.Len(t, rows, 1)+ require.Equal(t, types.ParseStatusFailed, rows[0].ParseStatus)+ failedChunks, chunkErr := f.chunkRepo.ListAllChunksByKnowledgeID(f.ctx, 7, rows[0].ID)+ require.NoError(t, chunkErr)+ require.Empty(t, failedChunks, "a lost create acknowledgement must also be rolled back")+ fault.fail = false+ require.NoError(t, f.svc.executeKnowledgeClone(f.ctx, f.kbs.values["kb"], f.kbs.values["other"], nil))+ rows, err = f.repo.ListKnowledgeByKnowledgeBaseID(f.ctx, 7, "other")+ require.NoError(t, err)+ require.Len(t, rows, 1)+ require.Equal(t, types.ParseStatusCompleted, rows[0].ParseStatus)+ id := rows[0].ID+ require.NoError(t, f.svc.executeKnowledgeClone(f.ctx, f.kbs.values["kb"], f.kbs.values["other"], nil))+ rows, err = f.repo.ListKnowledgeByKnowledgeBaseID(f.ctx, 7, "other")+ require.NoError(t, err)+ require.Len(t, rows, 1)+ require.Equal(t, id, rows[0].ID)+ var tenant types.Tenant+ require.NoError(t, f.db.First(&tenant, 7).Error)+ require.EqualValues(t, 10, tenant.StorageUsed)+}++func TestClonePreflightDoesNotDeleteTargetForUnreadySource(t *testing.T) {+ f := transferFixture(t, access.KBTransferClone)+ require.NoError(+ t,+ f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("parse_status", types.ParseStatusProcessing).Error,+ )+ require.Error(t, f.svc.executeKnowledgeClone(f.ctx, f.kbs.values["kb"], f.kbs.values["other"], nil))+ _, err := f.repo.GetKnowledgeByID(f.ctx, 7, "other-doc")+ require.NoError(t, err)+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.chunkRepo.writes)+}++func TestTransferCheckpointCannotResurrectOrOverwriteChangedDocument(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ before, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ after := *before+ after.StorageSize = 0+ after.KnowledgeBaseID = "other"+ require.NoError(t, f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("knowledge_base_id", "third").Error)+ require.Error(t, f.repo.UpdateKnowledgeForTransfer(f.ctx, before, &after))+ var tenant types.Tenant+ require.NoError(t, f.db.First(&tenant, 7).Error)+ require.EqualValues(t, 5, tenant.StorageUsed)+ require.NoError(t, f.db.Where("id = ?", "doc").Delete(&types.Knowledge{}).Error)+ require.Error(t, f.repo.UpdateKnowledgeForTransfer(f.ctx, before, &after))+ _, err = f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.Error(t, err)+}++func TestProcessingTasksRejectOldKnowledgeBaseAfterMove(t *testing.T) {+ for _, taskType := range []string{types.TypeDocumentProcess, types.TypeManualProcess} {+ t.Run(taskType, func(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ require.NoError(+ t,+ f.db.Model(&types.Knowledge{}).+ Where("id = ?", "doc").+ Updates(map[string]any{"knowledge_base_id": "other", "parse_status": types.ParseStatusPending}).+ Error,+ )+ payload, err := json.Marshal(+ types.DocumentProcessPayload{TenantID: 7, KnowledgeID: "doc", KnowledgeBaseID: "kb"},+ )+ require.NoError(t, err)+ task := asynq.NewTask(taskType, payload)+ if taskType == types.TypeDocumentProcess {+ err = f.svc.ProcessDocument(context.Background(), task)+ } else {+ err = f.svc.ProcessManualUpdate(context.Background(), task)+ }+ require.ErrorIs(t, err, asynq.SkipRetry)+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.graph.calls)+ })+ }+}++func TestCopyServiceResumesReservedTargetAndRequiresTransferGrant(t *testing.T) {+ repo := newFakeKBRepo()+ repo.rows["src"] = &types.KnowledgeBase{ID: "src", TenantID: 1}+ svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})+ _, _, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "")+ require.ErrorIs(t, err, access.ErrForbidden)+ require.Len(t, repo.rows, 1)+ ctx, err := access.WithKBTransferTask(+ context.Background(),+ repo.rows["src"],+ &types.KnowledgeBase{ID: "reserved", TenantID: 1, CreatorID: "creator"},+ 1,+ access.KBTransferClone,+ "task",+ true,+ )+ require.NoError(t, err)+ for range 2 {+ _, target, err := svc.CopyKnowledgeBase(ctx, "src", "reserved")+ require.NoError(t, err)+ require.Equal(t, "reserved", target.ID)+ require.Equal(t, "creator", target.CreatorID)+ }+ require.Len(t, repo.rows, 2)+ _, _, err = svc.CopyKnowledgeBase(ctx, "src", "other")+ require.ErrorIs(t, err, access.ErrForbidden)+}++func TestProcessingCannotEnterClaimedMoveBeforeKBBindingChanges(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(+ t,+ setTransferState(+ row,+ knowledgeTransferState{+ TaskID: "transfer-task",+ Operation: access.KBTransferMove,+ SourceKB: "kb",+ TargetKB: "other",+ SourceID: "doc",+ Mode: "reuse_vectors",+ Phase: "moving",+ },+ ),+ )+ row.ParseStatus = types.ParseStatusProcessing+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ f.repo.writes = 0+ payload, err := json.Marshal(types.DocumentProcessPayload{TenantID: 7, KnowledgeID: "doc", KnowledgeBaseID: "kb"})+ require.NoError(t, err)+ require.ErrorIs(+ t,+ f.svc.ProcessDocument(context.Background(), asynq.NewTask(types.TypeDocumentProcess, payload)),+ asynq.SkipRetry,+ )+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.graph.calls)+}++func TestAdmissionProgressCannotOverwriteFinishedWorker(t *testing.T) {+ f := transferFixture(t, access.KBTransferMove)+ require.NoError(+ t,+ f.svc.saveKnowledgeMoveProgress(+ f.ctx,+ &types.KnowledgeMoveProgress{TaskID: "task", Status: types.KBCloneStatusCompleted, Progress: 100},+ ),+ )+ require.NoError(+ t,+ f.svc.SaveKnowledgeMoveProgress(+ f.ctx,+ &types.KnowledgeMoveProgress{TaskID: "task", Status: types.KBCloneStatusPending},+ ),+ )+ progress, err := f.svc.GetKnowledgeMoveProgress(f.ctx, "task")+ require.NoError(t, err)+ require.Equal(t, types.KBCloneStatusCompleted, progress.Status)+ require.Equal(t, 100, progress.Progress)+}++func TestClonePreservesFailedChunkIndexStatus(t *testing.T) {+ f := transferFixture(t, access.KBTransferClone)+ require.NoError(t, f.db.Exec(`CREATE TRIGGER truncate_clone_created_time AFTER INSERT ON knowledges+ BEGIN UPDATE knowledges SET updated_at = strftime('%Y-%m-%d %H:%M:%S', NEW.updated_at) || '+00:00'+ WHERE id = NEW.id; END`).Error)+ require.NoError(t, f.db.Model(&types.Chunk{}).Where("id = ?", "chunk").Update("index_status", "failed").Error)+ require.NoError(t, f.svc.executeKnowledgeClone(f.ctx, f.kbs.values["kb"], f.kbs.values["other"], nil))+ rows, err := f.repo.ListKnowledgeByKnowledgeBaseID(f.ctx, 7, "other")+ require.NoError(t, err)+ require.Len(t, rows, 1)+ chunks, err := f.chunkRepo.ListAllChunksByKnowledgeID(f.ctx, 7, rows[0].ID)+ require.NoError(t, err)+ require.Len(t, chunks, 1)+ require.Equal(t, "failed", chunks[0].IndexStatus)+}++func TestTableSummaryCleanupDoesNotFollowMovedDocument(t *testing.T) {+ f := newDocumentWriteFixture(t)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ chunk, err := f.chunkRepo.GetChunkByID(f.ctx, 7, "chunk")+ require.NoError(t, err)+ require.NoError(t, f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("knowledge_base_id", "other").Error)+ worker := &DataTableSummaryService{knowledgeService: f.svc, chunkService: f.chunks}+ worker.cleanupOnFailure(+ f.ctx, &extractionResources{knowledge: row}, []*types.Chunk{chunk}, errors.New("index failed"),+ )+ f.requireNoWrites(t)+ current, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, "other", current.KnowledgeBaseID)+ require.Equal(t, row.ParseStatus, current.ParseStatus)+}diff --git a/internal/application/service/knowledge_update_test.go b/internal/application/service/knowledge_update_test.goindex b5662a354..cfec03840 100644--- a/internal/application/service/knowledge_update_test.go+++ b/internal/application/service/knowledge_update_test.go@@ -4,6 +4,7 @@ import ("context""testing"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/types""github.com/stretchr/testify/require")@@ -21,6 +22,17 @@ func TestUpdateKnowledgeExplicitEmptyDescriptionClearsSummary(t *testing.T) {repo: repo, kbService: metadataUpdateKBService{},}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 7,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )err := service.UpdateKnowledge(ctx, &types.Knowledge{ID: "knowledge-1",@@ -45,6 +57,17 @@ func TestUpdateKnowledgeOmittedDescriptionPreservesExisting(t *testing.T) {repo: repo, kbService: metadataUpdateKBService{},}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 7,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )err := service.UpdateKnowledge(ctx, &types.Knowledge{ID: "knowledge-1",@@ -68,6 +91,17 @@ func TestUpdateKnowledgeManualDescriptionSetsCompletedStatus(t *testing.T) {repo: repo, kbService: metadataUpdateKBService{},}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 7,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )err := service.UpdateKnowledge(ctx, &types.Knowledge{ID: "knowledge-1",@@ -93,6 +127,17 @@ func TestUpdateKnowledgeDescriptionOnlyDoesNotTouchMetadata(t *testing.T) {repo: repo, kbService: metadataUpdateKBService{},}ctx := context.WithValue(context.Background(), types.TenantIDContextKey, uint64(7))+ ctx = (&access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{+ ID: "kb-1",+ TenantID: 7,+ },+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }).Context(+ ctx,+ )err := service.UpdateKnowledge(ctx, &types.Knowledge{ID: "knowledge-1",diff --git a/internal/application/service/knowledge_write.go b/internal/application/service/knowledge_write.gonew file mode 100644index 000000000..5fe8bce76--- /dev/null+++ b/internal/application/service/knowledge_write.go@@ -0,0 +1,141 @@+package service++import (+ "context"+ "strings"++ "github.com/Tencent/WeKnora/internal/application/access"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+)++type knowledgeBaseWriteLookup interface {+ GetKnowledgeBaseByID(context.Context, string) (*types.KnowledgeBase, error)+}++func writeResourceIDs(ids []string) ([]string, error) {+ result := make([]string, 0, len(ids))+ seen := make(map[string]bool, len(ids))+ for _, id := range ids {+ if strings.TrimSpace(id) == "" {+ return nil, apperrors.NewBadRequestError("resource ID cannot be empty")+ }+ if !seen[id] {+ seen[id] = true+ result = append(result, id)+ }+ }+ return result, nil+}++func writeExecutionTenant(ctx context.Context) (uint64, error) {+ tenant, ok := types.TenantIDFromContext(ctx)+ if !ok || tenant == 0 {+ return 0, apperrors.NewUnauthorizedError("workspace context unavailable")+ }+ return tenant, nil+}++// Resolve persisted bindings before consuming grants. An input object's KB or+// tenant must never select the scope used to authorize an existing resource.+func knowledgeWriteKB(+ ctx context.Context,+ lookup knowledgeBaseWriteLookup,+ knowledge *types.Knowledge,+) (*types.KnowledgeBase, error) {+ if knowledge == nil || knowledge.ID == "" || knowledge.KnowledgeBaseID == "" || knowledge.TenantID == 0 {+ return nil, apperrors.NewNotFoundError("knowledge not found")+ }+ kb, err := lookup.GetKnowledgeBaseByID(ctx, knowledge.KnowledgeBaseID)+ if err != nil {+ return nil, err+ }+ if kb == nil || kb.ID != knowledge.KnowledgeBaseID || kb.TenantID != knowledge.TenantID {+ return nil, apperrors.NewForbiddenError("knowledge does not belong to its knowledge base")+ }+ return kb, nil+}++func loadKnowledgeWrite(+ ctx context.Context,+ repo interfaces.KnowledgeRepository,+ lookup knowledgeBaseWriteLookup,+ id string,+) (*types.Knowledge, *types.KnowledgeBase, error) {+ tenant, err := writeExecutionTenant(ctx)+ if err != nil {+ return nil, nil, err+ }+ knowledge, err := repo.GetKnowledgeByID(ctx, tenant, id)+ if err != nil {+ return nil, nil, err+ }+ if knowledge == nil || knowledge.ID != id || knowledge.TenantID != tenant {+ return nil, nil, apperrors.NewNotFoundError("knowledge not found")+ }+ if err := access.RejectMovingKnowledge(knowledge); err != nil {+ return nil, nil, err+ }+ kb, err := knowledgeWriteKB(ctx, lookup, knowledge)+ if err != nil {+ return nil, nil, err+ }+ if _, err := requireKBWrite(ctx, kb); err != nil {+ return nil, nil, err+ }+ copyOfKnowledge := *knowledge+ return ©OfKnowledge, kb, nil+}++// loadKnowledgeWriteBatch validates every requested ID, including missing+// entries, before any caller can apply changes. Each KB needs its own grant.+func loadKnowledgeWriteBatch(+ ctx context.Context,+ repo interfaces.KnowledgeRepository,+ lookup knowledgeBaseWriteLookup,+ ids []string,+) ([]*types.Knowledge, error) {+ ids, err := writeResourceIDs(ids)+ if err != nil || len(ids) == 0 {+ return nil, err+ }+ tenant, err := writeExecutionTenant(ctx)+ if err != nil {+ return nil, err+ }+ rows, err := repo.GetKnowledgeBatch(ctx, tenant, ids)+ if err != nil {+ return nil, err+ }+ byID := make(map[string]*types.Knowledge, len(rows))+ for _, row := range rows {+ if row != nil && row.TenantID == tenant {+ byID[row.ID] = row+ }+ }+ checked := make(map[string]bool)+ result := make([]*types.Knowledge, 0, len(ids))+ for _, id := range ids {+ row := byID[id]+ if row == nil {+ return nil, apperrors.NewNotFoundError("knowledge not found")+ }+ if err := access.RejectMovingKnowledge(row); err != nil {+ return nil, err+ }+ if !checked[row.KnowledgeBaseID] {+ kb, err := knowledgeWriteKB(ctx, lookup, row)+ if err != nil {+ return nil, err+ }+ if _, err := requireKBWrite(ctx, kb); err != nil {+ return nil, err+ }+ checked[row.KnowledgeBaseID] = true+ }+ copyOfRow := *row+ result = append(result, ©OfRow)+ }+ return result, nil+}diff --git a/internal/application/service/knowledge_write_access_test.go b/internal/application/service/knowledge_write_access_test.gonew file mode 100644index 000000000..15a562394--- /dev/null+++ b/internal/application/service/knowledge_write_access_test.go@@ -0,0 +1,442 @@+package service++import (+ "context"+ "encoding/json"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/hibiken/asynq"+ "github.com/stretchr/testify/require"+ "gorm.io/driver/sqlite"+ "gorm.io/gorm"+)++type writeKBLookup struct {+ interfaces.KnowledgeBaseService+ kb *types.KnowledgeBase+}++func (s *writeKBLookup) GetKnowledgeBaseByID(context.Context, string) (*types.KnowledgeBase, error) {+ return s.kb, nil+}++type writeChunkSpy struct {+ interfaces.ChunkRepository+ writes int+}++func (s *writeChunkSpy) UpdateChunkFieldsByTagID(+ ctx context.Context,+ tenant uint64,+ kb, tag string,+ enabled *bool,+ set, clearFlags types.ChunkFlags,+ next *string,+ exclude []string,+) ([]string, error) {+ s.writes+++ return s.ChunkRepository.UpdateChunkFieldsByTagID(ctx, tenant, kb, tag, enabled, set, clearFlags, next, exclude)+}++func (s *writeChunkSpy) UpdateChunks(ctx context.Context, chunks []*types.Chunk) error {+ s.writes+++ return s.ChunkRepository.UpdateChunks(ctx, chunks)+}++func (s *writeChunkSpy) UpdateChunkFlagsBatch(+ ctx context.Context,+ tenant uint64,+ kb string,+ set, clearFlags map[string]types.ChunkFlags,+) error {+ s.writes+++ return s.ChunkRepository.UpdateChunkFlagsBatch(ctx, tenant, kb, set, clearFlags)+}++type writeChunkDeleter struct {+ interfaces.ChunkService+ deleted []string+}++func (s *writeChunkDeleter) DeleteChunk(_ context.Context, id string) error {+ s.deleted = append(s.deleted, id)+ return nil+}++type writeIndexSpy struct {+ interfaces.RetrieveEngineService+ enabled map[string]bool+ tags map[string]string+}++func (*writeIndexSpy) EngineType() types.RetrieverEngineType {+ return types.PostgresRetrieverEngineType+}++func (*writeIndexSpy) Support() []types.RetrieverType {+ return []types.RetrieverType{types.VectorRetrieverType}+}++func (s *writeIndexSpy) BatchUpdateChunkEnabledStatus(_ context.Context, values map[string]bool) error {+ s.enabled = values+ return nil+}++func (s *writeIndexSpy) BatchUpdateChunkTagID(_ context.Context, values map[string]string) error {+ s.tags = values+ return nil+}++type faqWriteFixture struct {+ svc *knowledgeService+ tags *knowledgeTagService+ db *gorm.DB+ ctx context.Context+ chunks *writeChunkSpy+ deletes *writeChunkDeleter+ index *writeIndexSpy+ kb *types.KnowledgeBase+}++func newFAQWriteFixture(t *testing.T) *faqWriteFixture {+ t.Helper()+ db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})+ require.NoError(t, err)+ require.NoError(t, db.AutoMigrate(&types.Knowledge{}, &types.Chunk{}, &types.KnowledgeTag{}))+ store := "write-store"+ kb := &types.KnowledgeBase{ID: "kb", TenantID: 7, Type: types.KnowledgeBaseTypeFAQ, VectorStoreID: &store}+ lookup := &writeKBLookup{kb: kb}+ chunks := &writeChunkSpy{ChunkRepository: repository.NewChunkRepository(db)}+ deletes := &writeChunkDeleter{}+ index := &writeIndexSpy{}+ svc := &knowledgeService{+ kbService: lookup, chunkRepo: chunks, chunkService: deletes,+ tagRepo: repository.NewKnowledgeTagRepository(db), repo: repository.NewKnowledgeRepository(db),+ retrieveEngine: &fakeFanoutRegistry{byStore: map[string]interfaces.RetrieveEngineService{store: index}},+ ownership: &fakeOwnership{owned: map[string]uint64{store: 7}},+ }+ base := types.WithCaller(+ context.Background(),+ types.Caller{TenantID: 1, UserID: "caller", Role: types.TenantRoleAdmin},+ )+ grant := &access.KBAccess{+ KnowledgeBase: kb,+ Caller: types.CallerFromContext(base),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleEditor,+ }+ ctx := context.WithValue(grant.Context(base), types.TenantInfoContextKey, &types.Tenant{ID: 7})+ for _, tag := range []*types.KnowledgeTag{+ {ID: "tag", SeqID: 11, TenantID: 7, KnowledgeBaseID: "kb", Name: "tag"},+ {ID: "next", SeqID: 12, TenantID: 7, KnowledgeBaseID: "kb", Name: "next"},+ {ID: "foreign", SeqID: 22, TenantID: 7, KnowledgeBaseID: "other", Name: "foreign"},+ } {+ require.NoError(t, db.Create(tag).Error)+ }+ for _, chunk := range []*types.Chunk{+ {+ ID: "one",+ SeqID: 1,+ TenantID: 7,+ KnowledgeBaseID: "kb",+ KnowledgeID: "faq",+ ChunkType: types.ChunkTypeFAQ,+ TagID: "tag",+ IsEnabled: true,+ },++ {+ ID: "two",+ SeqID: 2,+ TenantID: 7,+ KnowledgeBaseID: "other",+ KnowledgeID: "foreign-faq",+ ChunkType: types.ChunkTypeFAQ,+ TagID: "foreign",+ IsEnabled: true,+ },+ } {+ require.NoError(t, db.Create(chunk).Error)+ }+ require.NoError(+ t,+ db.Create(&types.Knowledge{ID: "faq", TenantID: 7, KnowledgeBaseID: "kb", Type: types.KnowledgeTypeFAQ}).Error,+ )+ tags := &knowledgeTagService{kbService: lookup, repo: svc.tagRepo}+ tags.chunkRepo = chunks+ svc.tagService = tags+ return &faqWriteFixture{+ svc: svc,+ tags: tags,+ db: db,+ ctx: ctx,+ chunks: chunks,+ deletes: deletes,+ index: index,+ kb: kb,+ }+}++func TestFAQAndTagWritesRejectUnscopedServiceCalls(t *testing.T) {+ f := newFAQWriteFixture(t)+ ctx := types.WithExecutionTenant(types.WithCaller(context.Background(), types.Caller{TenantID: 1}), 7)+ operations := map[string]func(context.Context) error{+ "create FAQ": func(ctx context.Context) error {+ _, err := f.svc.CreateFAQEntry(ctx, "kb", &types.FAQEntryPayload{})+ return err+ },+ "update FAQ": func(ctx context.Context) error {+ _, err := f.svc.UpdateFAQEntry(ctx, "kb", 1, &types.FAQEntryPayload{})+ return err+ },+ "similar questions": func(ctx context.Context) error {+ _, err := f.svc.AddSimilarQuestions(ctx, "kb", 1, []string{"question"})+ return err+ },+ "status": func(ctx context.Context) error { return f.svc.UpdateFAQEntryStatus(ctx, "kb", "one", false) },+ "fields": func(ctx context.Context) error {+ return f.svc.UpdateFAQEntryFieldsBatch(+ ctx,+ "kb",+ &types.FAQEntryFieldsBatchUpdate{ByID: map[int64]types.FAQEntryFieldsUpdate{1: {}}},+ )+ },+ "single tag": func(ctx context.Context) error { return f.svc.UpdateFAQEntryTag(ctx, "kb", "one", nil) },+ "batch tags": func(ctx context.Context) error {+ return f.svc.UpdateFAQEntryTagBatch(ctx, "kb", map[int64]*int64{1: nil})+ },+ "delete": func(ctx context.Context) error { return f.svc.DeleteFAQEntries(ctx, "kb", []int64{1}) },+ "import": func(ctx context.Context) error {+ _, err := f.svc.UpsertFAQEntries(+ ctx,+ "kb",+ &types.FAQBatchUpsertPayload{Entries: []types.FAQEntryPayload{{}}},+ )+ return err+ },+ "import display": func(ctx context.Context) error {+ return f.svc.UpdateLastFAQImportResultDisplayStatus(ctx, "kb", "close")+ },+ "create tag": func(ctx context.Context) error {+ _,+ err := f.tags.CreateTag(ctx,+ "kb",+ "new",+ "",+ 0)+ return err+ },++ "find/create tag": func(ctx context.Context) error {+ _,+ err := f.tags.FindOrCreateTagByName(ctx,+ "kb",+ "tag")+ return err+ },++ "update tag": func(ctx context.Context) error {+ _,+ err := f.tags.UpdateTag(ctx,+ "tag",+ nil,+ nil,+ nil)+ return err+ },++ "delete tag": func(ctx context.Context) error { return f.tags.DeleteTag(ctx, "tag", true, false, nil) },+ }+ for name, operation := range operations {+ t.Run(name, func(t *testing.T) { require.Error(t, operation(ctx)) })+ }+ require.Zero(t, f.chunks.writes)+ require.Empty(t, f.deletes.deleted)+ // The same service accepts a correctly scoped shared Editor operation.+ tag, err := f.tags.CreateTag(f.ctx, "kb", "created", "", 0)+ require.NoError(t, err)+ require.Equal(t, uint64(7), tag.TenantID)+}++func TestFAQBatchPreflightRejectsBeforeAnyWrite(t *testing.T) {+ no := false+ foreign := int64(22)+ for name, req := range map[string]*types.FAQEntryFieldsBatchUpdate{+ "foreign entry after group": {+ ByTag: map[int64]types.FAQEntryFieldsUpdate{11: {IsEnabled: &no}},+ ByID: map[int64]types.FAQEntryFieldsUpdate{2: {IsEnabled: &no}},+ },++ "missing entry after group": {+ ByTag: map[int64]types.FAQEntryFieldsUpdate{11: {IsEnabled: &no}},+ ByID: map[int64]types.FAQEntryFieldsUpdate{999: {}},+ },++ "foreign source tag": {ByTag: map[int64]types.FAQEntryFieldsUpdate{+ 11: {IsEnabled: &no},+ 22: {IsEnabled: &no},+ }},++ "foreign destination tag": {ByID: map[int64]types.FAQEntryFieldsUpdate{1: {TagID: &foreign}}},+ "foreign exclusion": {+ ByTag: map[int64]types.FAQEntryFieldsUpdate{11: {IsEnabled: &no}},+ ExcludeIDs: []int64{2},+ },++ "missing exclusion": {+ ByTag: map[int64]types.FAQEntryFieldsUpdate{11: {IsEnabled: &no}},+ ExcludeIDs: []int64{999},+ },+ } {+ t.Run(name, func(t *testing.T) {+ f := newFAQWriteFixture(t)+ require.Error(t, f.svc.UpdateFAQEntryFieldsBatch(f.ctx, "kb", req))+ require.Zero(t, f.chunks.writes)+ chunk, err := f.chunks.GetChunkByID(f.ctx, 7, "one")+ require.NoError(t, err)+ require.True(t, chunk.IsEnabled)+ require.Equal(t, "tag", chunk.TagID)+ })+ }+}++func TestFAQDeleteValidatesEntireSelectionAndParents(t *testing.T) {+ for _, ids := range [][]int64{{1, 2}, {1, 999}, {1, 0}} {+ t.Run(string(mustWriteJSON(t, ids)), func(t *testing.T) {+ f := newFAQWriteFixture(t)+ require.Error(t, f.svc.DeleteFAQEntries(f.ctx, "kb", ids))+ require.Empty(t, f.deletes.deleted)+ })+ }+ t.Run("foreign parent", func(t *testing.T) {+ f := newFAQWriteFixture(t)+ require.NoError(+ t,+ f.db.Model(&types.Knowledge{}).Where("id = ?", "faq").Update("knowledge_base_id", "other").Error,+ )+ require.Error(t, f.svc.DeleteFAQEntries(f.ctx, "kb", []int64{1}))+ require.Empty(t, f.deletes.deleted)+ })+}++func TestFAQFieldGroupsAndExplicitUpdatesPreservePrecedence(t *testing.T) {+ f := newFAQWriteFixture(t)+ yes, no := true, false+ next := int64(12)+ req := &types.FAQEntryFieldsBatchUpdate{+ ByTag: map[int64]types.FAQEntryFieldsUpdate{11: {TagID: &next, IsRecommended: &yes}},+ ByID: map[int64]types.FAQEntryFieldsUpdate{1: {IsEnabled: &no, IsRecommended: &no}},+ }+ require.NoError(t, f.svc.UpdateFAQEntryFieldsBatch(f.ctx, "kb", req))+ chunk, err := f.chunks.GetChunkByID(f.ctx, 7, "one")+ require.NoError(t, err)+ require.False(t, chunk.IsEnabled)+ require.Equal(t, "next", chunk.TagID, "an explicit enabled patch must preserve the group's tag change")+ require.False(t, chunk.Flags.HasFlag(types.ChunkFlagRecommended))+ require.Equal(t, map[string]string{"one": "next"}, f.index.tags)+ require.Equal(t, map[string]bool{"one": false}, f.index.enabled)+}++func TestFAQTagOnlyBatchUsesValidatedPlanAndSynchronizesIndex(t *testing.T) {+ f := newFAQWriteFixture(t)+ foreign := int64(22)+ require.Error(t, f.svc.UpdateFAQEntryTagBatch(f.ctx, "kb", map[int64]*int64{1: &foreign}))+ require.Zero(t, f.chunks.writes)+ require.NoError(t, f.svc.UpdateFAQEntryTagBatch(f.ctx, "kb", map[int64]*int64{1: nil}))+ require.Equal(t, map[string]string{"one": ""}, f.index.tags)+}++func TestFAQImportRejectsForeignTagsBeforeEnqueue(t *testing.T) {+ f := newFAQWriteFixture(t)+ _, err := f.svc.UpsertFAQEntries(+ f.ctx,+ "kb",+ &types.FAQBatchUpsertPayload{Entries: []types.FAQEntryPayload{{TagID: 22}}},+ )+ require.Error(t, err) // Redis, file storage and the queue are intentionally unwired.+ require.Zero(t, f.chunks.writes)+ _, err = f.svc.resolveTagID(f.ctx, "kb", &types.FAQEntryPayload{TagID: 22})+ require.Error(t, err)+ resolver := f.svc.buildFAQTagResolver(f.ctx, "kb", []types.FAQEntryPayload{{TagID: 22}})+ _, err = resolver(&types.FAQEntryPayload{TagID: 22})+ require.Error(t, err)+}++func TestFAQImportWorkerRejectsMismatchedScopeBeforeSideEffects(t *testing.T) {+ for _, tenant := range []uint64{7, 8} {+ t.Run(string(mustWriteJSON(t, tenant)), func(t *testing.T) {+ f := newFAQWriteFixture(t)+ require.NoError(+ t,+ f.db.Create(+ &types.Knowledge{+ ID: "foreign-faq",+ TenantID: 7,+ KnowledgeBaseID: "other",+ Type: types.KnowledgeTypeFAQ,+ },+ ).Error,+ )+ payload := types.FAQImportPayload{TenantID: tenant, KBID: "kb", KnowledgeID: "foreign-faq", TaskID: "task"}+ err := f.svc.ProcessFAQImport(+ context.Background(),+ asynq.NewTask(types.TypeFAQImport, mustWriteJSON(t, payload)),+ )+ require.ErrorIs(t, err, asynq.SkipRetry)+ require.Zero(t, f.chunks.writes)+ })+ }+}++func TestTagDeleteRejectsInvalidExclusionsBeforeDeletion(t *testing.T) {+ for _, id := range []string{"two", "missing"} {+ t.Run(id, func(t *testing.T) {+ f := newFAQWriteFixture(t)+ require.Error(t, f.tags.DeleteTag(f.ctx, "tag", true, false, []string{id}))+ tag, err := f.svc.tagRepo.GetByID(f.ctx, 7, "tag")+ require.NoError(t, err)+ require.NotNil(t, tag)+ chunk, err := f.chunks.GetChunkByID(f.ctx, 7, "one")+ require.NoError(t, err)+ require.NotNil(t, chunk)+ })+ }+}++func mustWriteJSON(t *testing.T, value interface{}) []byte {+ t.Helper()+ data, err := json.Marshal(value)+ require.NoError(t, err)+ return data+}++func TestSharedFAQWriteLoadsOwnerTenantInfoWithoutReplacingCaller(t *testing.T) {+ f := newFAQWriteFixture(t)+ f.svc.tenantRepo = &processSyncTenantRepo{tenant: &types.Tenant{ID: 7}}+ ctx := context.WithValue(f.ctx, types.TenantInfoContextKey, &types.Tenant{ID: 1})+ _, scoped, err := f.svc.writableFAQKnowledgeBase(ctx, "kb")+ require.NoError(t, err)+ owner, _ := types.TenantInfoFromContext(scoped)+ require.Equal(t, uint64(7), owner.ID)+ require.Equal(t, uint64(1), types.CallerFromContext(scoped).TenantID)+ original, _ := types.TenantInfoFromContext(ctx)+ require.Equal(t, uint64(1), original.ID)+}++func TestDataSourceTagCreationReceivesOnlyItsTaskKBGrant(t *testing.T) {+ h := newSyncDeletionHarness(t, false, "ds-tag-scope", "log-tag-scope", nil, nil)+ tags := h.svc.tagService.(*processSyncTagService)+ _, err := h.run(t)+ require.NoError(t, err)+ require.NotNil(t, tags.ctx)+ require.Zero(t, types.CallerFromContext(tags.ctx).TenantID)+ require.NoError(+ t,+ access.RequireKBWrite(tags.ctx, &types.KnowledgeBase{ID: h.ds.KnowledgeBaseID, TenantID: h.ds.TenantID}),+ )+ require.Error(t, access.RequireKBWrite(tags.ctx, &types.KnowledgeBase{ID: "other", TenantID: h.ds.TenantID}))+}diff --git a/internal/application/service/knowledgebase.go b/internal/application/service/knowledgebase.goindex 42a52dfd2..76189da6b 100644--- a/internal/application/service/knowledgebase.go+++ b/internal/application/service/knowledgebase.go@@ -9,6 +9,8 @@ import ("strings""time"+ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/application/service/retriever""github.com/Tencent/WeKnora/internal/datasource"apperrors "github.com/Tencent/WeKnora/internal/errors"@@ -1099,72 +1101,57 @@ func (s *knowledgeBaseService) SetEmbeddingModel(ctx context.Context, id string,// CopyKnowledgeBase copies a knowledge base to a new knowledge base (shallow copy).// Source and target must belong to the tenant in context; cross-tenant access is rejected.//-// Defensive checks:-//-// - When dstKB != "" (clone into an existing target), the source's-// EmbeddingModelID and VectorStoreID must match the target's. Mismatched-// embedding models would silently mix incompatible vector spaces;-// mismatched vector stores would require copying physical vector data-// between stores, which is not yet supported.-// - When dstKB == "" (create a new target), VectorStoreID is copied from-// the source so the new KB shares the same physical vector index. GORM-// `<-:create` allows INSERT, so the new row is well-formed.-//-// The handler's CopyKnowledgeBase endpoint runs the same checks synchronously-// before enqueueing the async clone task, so the 400 errors here are-// defense-in-depth for the worker entry point.+// The transfer grant fixes both resource IDs and whether a new destination+// may be created. Existing targets must be compatible with the source. A+// worker retry reloads the reserved target instead of creating another KB.func (s *knowledgeBaseService) CopyKnowledgeBase(ctx context.Context,srcKB string, dstKB string,) (*types.KnowledgeBase, *types.KnowledgeBase, error) {+ destinationID, create, creatorID, err := access.CloneDestination(ctx, srcKB)+ if err != nil {+ return nil, nil, err+ }+ if dstKB != "" && dstKB != destinationID {+ return nil, nil, access.ErrForbidden+ }tenantID := types.MustTenantIDFromContext(ctx)- // Load source KB with tenant scope to prevent cross-tenant cloningsourceKB, err := s.repo.GetKnowledgeBaseByIDAndTenant(ctx, srcKB, tenantID)if err != nil {- logger.Errorf(ctx, "Get source knowledge base failed: %v", err)return nil, nil, err}+ if sourceKB == nil || sourceKB.ID != srcKB || sourceKB.TenantID != tenantID {+ return nil, nil, access.ErrForbidden+ }+ sourceCopy := *sourceKB+ sourceKB = &sourceCopysourceKB.EnsureDefaults()- var targetKB *types.KnowledgeBase- if dstKB != "" {- // Load target KB with tenant scope so we only clone into the caller's tenant- targetKB, err = s.repo.GetKnowledgeBaseByIDAndTenant(ctx, dstKB, tenantID)- if err != nil {+ targetKB, err := s.repo.GetKnowledgeBaseByIDAndTenant(ctx, destinationID, tenantID)+ if err != nil && (!create || !errors.Is(err, repository.ErrKnowledgeBaseNotFound)) {+ return nil, nil, err+ }+ if targetKB != nil {+ targetCopy := *targetKB+ targetKB = &targetCopy+ targetKB.EnsureDefaults()+ if err := access.RequireKBTransfer(ctx, sourceKB, targetKB, access.KBTransferClone); err != nil {return nil, nil, err}-- // Defense 1: embedding model must match. Mixing incompatible- // vector spaces would produce semantically broken search results.- if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID {- return nil, nil, apperrors.NewBadRequestError(- "source and target knowledge bases use different embedding models; " +- "clone into a target with the same embedding model")+ tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)+ if err := access.ValidateKBTransferCompatibility(sourceKB,+ targetKB,+ access.KBTransferClone,+ "",+ tenant); err != nil {+ return nil, nil, apperrors.NewBadRequestError(err.Error())}-- // Defense 2: vector store binding must match. Cross-store cloning- // would require copying physical vector data between stores.- // (both nil → equal; both same UUID → equal; otherwise → rejected)- if !sourceKB.SharesStoreWith(targetKB) {- return nil, nil, apperrors.NewBadRequestError(- "source and target knowledge bases are bound to different vector stores; " +- "cross-store cloning is not yet supported")+ } else {+ reserved := &types.KnowledgeBase{ID: destinationID, TenantID: tenantID}+ if !create {+ return nil, nil, access.ErrNotFound}-- // Defense 3: the concrete storage instance must match. Comparing only- // provider names would incorrectly allow COS-A -> COS-B clones.- if tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant); tenant != nil {- defaultID, defaultProvider := "", ""- if tenant.DefaultStorageBackendID != nil {- defaultID = *tenant.DefaultStorageBackendID- }- if tenant.StorageEngineConfig != nil {- defaultProvider = tenant.StorageEngineConfig.DefaultProvider- }- if !sourceKB.SharesStorageBackendWith(targetKB, defaultID, defaultProvider) {- return nil, nil, apperrors.NewBadRequestError(- "source and target knowledge bases use different storage instances; cross-storage-backend cloning is not supported")- }+ if err := access.RequireKBTransfer(ctx, sourceKB, reserved, access.KBTransferClone); err != nil {+ return nil, nil, err}- } else {var faqConfig *types.FAQConfigif sourceKB.FAQConfig != nil {cfg := *sourceKB.FAQConfig@@ -1173,7 +1160,8 @@ func (s *knowledgeBaseService) CopyKnowledgeBase(ctx context.Context,// Preserve VectorStoreID so the cloned KB lands on the same// physical index. GORM `<-:create` permits the value at INSERT.targetKB = &types.KnowledgeBase{- ID: uuid.New().String(),+ ID: destinationID,+ CreatorID: creatorID,Name: sourceKB.Name,Type: sourceKB.Type,Description: sourceKB.Description,diff --git a/internal/application/service/knowledgebase_access.go b/internal/application/service/knowledgebase_access.gonew file mode 100644index 000000000..b7d4a8a7a--- /dev/null+++ b/internal/application/service/knowledgebase_access.go@@ -0,0 +1,74 @@+package service++import (+ "context"++ "github.com/Tencent/WeKnora/internal/application/access"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+)++// Service reads accept exact upstream grants. Otherwise cross-tenant reads+// require a user and organization permission resolved for the original caller.+func kbReadPermissions(ctx context.Context, shares access.KBShareLookup) *access.KBPermissions {+ if types.CallerFromContext(ctx).UserID == "" {+ shares = nil+ }+ return access.NewKBPermissions(ctx, shares)+}++func resolveKBReadTenant(ctx context.Context, kb *types.KnowledgeBase, shares access.KBShareLookup) (uint64, error) {+ if kb != nil {+ allowed, err := kbReadPermissions(ctx, shares).Check(kb.ID, kb.TenantID, types.OrgRoleViewer)+ if err == nil && allowed {+ return kb.TenantID, nil+ }+ }+ return 0, apperrors.NewForbiddenError("无权访问该知识库")+}++func requireKBWrite(ctx context.Context, kb *types.KnowledgeBase) (context.Context, error) {+ if err := access.RequireKBWrite(ctx, kb); err != nil {+ return ctx, apperrors.NewForbiddenError("无权修改该知识库")+ }+ return types.WithExecutionTenant(ctx, kb.TenantID), nil+}++func (s *knowledgeService) writableFAQKnowledgeBase(+ ctx context.Context,+ kbID string,+) (*types.KnowledgeBase, context.Context, error) {+ kb, err := s.validateFAQKnowledgeBase(ctx, kbID)+ if err != nil {+ return nil, ctx, err+ }+ ctx, err = requireKBWrite(ctx, kb)+ if err == nil {+ ctx, err = withKBWriteTenantInfo(ctx, kb, s.tenantRepo)+ }+ return kb, ctx, err+}++// A shared KB mutation must also resolve models/index backends against its+// owner. The authenticated caller remains unchanged when TenantInfo changes.+func withKBWriteTenantInfo(+ ctx context.Context,+ kb *types.KnowledgeBase,+ tenants interfaces.TenantRepository,+) (context.Context, error) {+ if tenant, ok := types.TenantInfoFromContext(ctx); ok && tenant != nil && tenant.ID == kb.TenantID {+ return ctx, nil+ }+ if tenants == nil {+ return ctx, apperrors.NewServiceUnavailableError("无法获取知识库所属空间")+ }+ tenant, err := tenants.GetTenantByID(ctx, kb.TenantID)+ if err != nil {+ return ctx, err+ }+ if tenant == nil || tenant.ID != kb.TenantID {+ return ctx, apperrors.NewNotFoundError("知识库所属空间不存在")+ }+ return context.WithValue(ctx, types.TenantInfoContextKey, tenant), nil+}diff --git a/internal/application/service/knowledgebase_pr3_test.go b/internal/application/service/knowledgebase_pr3_test.goindex d24616f7b..d5bd3a61c 100644--- a/internal/application/service/knowledgebase_pr3_test.go+++ b/internal/application/service/knowledgebase_pr3_test.go@@ -6,6 +6,8 @@ import ("testing""time"+ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/application/service/retriever"apperrors "github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/storageallowlist"@@ -87,22 +89,27 @@ func (r *fakeKBRepo) CreateKnowledgeBase(_ context.Context, kb *types.KnowledgeBr.rows[kb.ID] = kbreturn nil}+func (r *fakeKBRepo) GetKnowledgeBaseByID(_ context.Context, id string) (*types.KnowledgeBase, error) {return r.rows[id], nil}+func (r *fakeKBRepo) GetKnowledgeBaseByIDAndTenant(_ context.Context, id string, tenantID uint64) (*types.KnowledgeBase, error) {kb := r.rows[id]if kb == nil || kb.TenantID != tenantID {- return nil, stderrors.New("not found")+ return nil, repository.ErrKnowledgeBaseNotFound}return kb, nil}+func (r *fakeKBRepo) GetKnowledgeBaseByIDs(_ context.Context, _ []string) ([]*types.KnowledgeBase, error) {return nil, nil}+func (r *fakeKBRepo) ListKnowledgeBases(_ context.Context) ([]*types.KnowledgeBase, error) {return nil, nil}+func (r *fakeKBRepo) ListKnowledgeBasesByTenantID(_ context.Context, tenantID uint64) ([]*types.KnowledgeBase, error) {rows := make([]*types.KnowledgeBase, 0, len(r.rows))for _, kb := range r.rows {@@ -112,6 +119,7 @@ func (r *fakeKBRepo) ListKnowledgeBasesByTenantID(_ context.Context, tenantID ui}return rows, nil}+func (r *fakeKBRepo) UpdateKnowledgeBase(_ context.Context, _ *types.KnowledgeBase) error {return nil}@@ -119,9 +127,11 @@ func (r *fakeKBRepo) DeleteKnowledgeBase(_ context.Context, _ string) error { refunc (r *fakeKBRepo) TogglePinKnowledgeBase(_ context.Context, _ string, _ uint64) (*types.KnowledgeBase, error) {return nil, nil}+func (r *fakeKBRepo) CountByVectorStoreID(_ context.Context, _ *gorm.DB, _ uint64, _ string) (int64, error) {return 0, nil}+func (r *fakeKBRepo) CountByModelID(_ context.Context, _ uint64, _ string) (int64, error) {return 0, nil}@@ -322,7 +332,7 @@ func TestCopyKnowledgeBase_Defenses(t *testing.T) {repo.rows["src"] = mkKB("src", 1, "embed-1", &storeA)svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})- src, tgt, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "")+ src, tgt, err := svc.CopyKnowledgeBase(copyTaskTestContext(t, repo, ""), "src", "")require.NoError(t, err)require.NotNil(t, src.VectorStoreID)require.NotNil(t, tgt.VectorStoreID)@@ -340,7 +350,7 @@ func TestCopyKnowledgeBase_Defenses(t *testing.T) {repo.rows["src"] = mkKB("src", 1, "embed-1", nil)svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})- _, tgt, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "")+ _, tgt, err := svc.CopyKnowledgeBase(copyTaskTestContext(t, repo, ""), "src", "")require.NoError(t, err)assert.Nil(t, tgt.VectorStoreID)})@@ -351,7 +361,7 @@ func TestCopyKnowledgeBase_Defenses(t *testing.T) {repo.rows["dst"] = mkKB("dst", 1, "embed-1", nil)svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})- _, _, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "dst")+ _, _, err := svc.CopyKnowledgeBase(copyTaskTestContext(t, repo, "dst"), "src", "dst")require.NoError(t, err)})@@ -361,7 +371,7 @@ func TestCopyKnowledgeBase_Defenses(t *testing.T) {repo.rows["dst"] = mkKB("dst", 1, "embed-1", &storeA)svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})- _, _, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "dst")+ _, _, err := svc.CopyKnowledgeBase(copyTaskTestContext(t, repo, "dst"), "src", "dst")require.NoError(t, err)})@@ -371,7 +381,7 @@ func TestCopyKnowledgeBase_Defenses(t *testing.T) {repo.rows["dst"] = mkKB("dst", 1, "embed-2", &storeA)svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})- _, _, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "dst")+ _, _, err := svc.CopyKnowledgeBase(copyTaskTestContext(t, repo, "dst"), "src", "dst")require.Error(t, err)assert.Contains(t, err.Error(), "different embedding models")})@@ -382,7 +392,7 @@ func TestCopyKnowledgeBase_Defenses(t *testing.T) {repo.rows["dst"] = mkKB("dst", 1, "embed-1", &storeB)svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})- _, _, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "dst")+ _, _, err := svc.CopyKnowledgeBase(copyTaskTestContext(t, repo, "dst"), "src", "dst")require.Error(t, err)assert.Contains(t, err.Error(), "different vector stores")assert.NotContains(t, err.Error(), "Phase 4", "internal roadmap labels must not leak to end-user error messages")@@ -394,7 +404,7 @@ func TestCopyKnowledgeBase_Defenses(t *testing.T) {repo.rows["dst"] = mkKB("dst", 1, "embed-1", &storeA)svc := newPR3KBService(repo, &fakeRegistry{}, &fakeOwnership{})- _, _, err := svc.CopyKnowledgeBase(ctxWithTenant(1), "src", "dst")+ _, _, err := svc.CopyKnowledgeBase(copyTaskTestContext(t, repo, "dst"), "src", "dst")require.Error(t, err)assert.Contains(t, err.Error(), "different vector stores")})@@ -525,3 +535,22 @@ func TestDuplicateKnowledgeBase_UsesLocalizedEnglishSuffix(t *testing.T) {assert.Equal(t, "Source KB Copy", target.Name)}++func copyTaskTestContext(t *testing.T, repo *fakeKBRepo, dst string) context.Context {+ t.Helper()+ target := repo.rows[dst]+ if target == nil {+ target = &types.KnowledgeBase{ID: "reserved-copy", TenantID: 1}+ }+ ctx, err := access.WithKBTransferTask(+ context.Background(),+ repo.rows["src"],+ target,+ 1,+ access.KBTransferClone,+ "clone-task",+ dst == "",+ )+ require.NoError(t, err)+ return ctx+}diff --git a/internal/application/service/knowledgebase_search.go b/internal/application/service/knowledgebase_search.goindex 2be71595a..cca50c9a1 100644--- a/internal/application/service/knowledgebase_search.go+++ b/internal/application/service/knowledgebase_search.go@@ -97,7 +97,7 @@ func (s *knowledgeBaseService) ResolveEmbeddingModelKeys(ctx context.Context, kb// Resolve each unique (modelID, tenantID) to a model identity keyresolvedKeys := make(map[modelRef]string, len(uniqueRefs))for ref := range uniqueRefs {- tenantCtx := context.WithValue(ctx, types.TenantIDContextKey, ref.TenantID)+ tenantCtx := types.WithExecutionTenant(ctx, ref.TenantID)model, err := s.modelService.GetModelByID(tenantCtx, ref.ModelID)if err != nil || model == nil {logger.Warnf(ctx, "ResolveEmbeddingModelKeys: cannot resolve model %s for tenant %d: %v", ref.ModelID, ref.TenantID, err)@@ -143,7 +143,6 @@ func (s *knowledgeBaseService) HybridSearch(ctx context.Context,searchKBIDs, secutils.SanitizeForLog(params.QueryText))tenantInfo, _ := types.TenantInfoFromContext(ctx)- requestTenantID := types.MustTenantIDFromContext(ctx)// Batch-load every KB in scope. Required for store grouping,// embedding-model consistency validation, and FAQ type detection.@@ -162,13 +161,13 @@ func (s *knowledgeBaseService) HybridSearch(ctx context.Context,return nil, apperrors.NewNotFoundError("knowledge base not found")}- // Authorize every KB the caller asked for. Same-tenant KBs are- // always accessible; foreign-tenant KBs (Organization-shared) must- // pass an explicit per-KB permission check. Without this guard, a+ // Authorize every KB for the original caller, using exact upstream+ // grants or organization permissions. Execution in a shared tenant+ // does not grant access to its other KBs. Without this guard, a// caller could pass arbitrary KB UUIDs in params.KnowledgeBaseIDs// and reach foreign tenants' bound vector stores via the per-group// engine resolution downstream.- if err := s.authorizeKBAccess(ctx, kbs, requestTenantID); err != nil {+ if err := s.authorizeKBAccess(ctx, kbs); err != nil {return nil, err}diff --git a/internal/application/service/knowledgebase_search_fanout_test.go b/internal/application/service/knowledgebase_search_fanout_test.goindex 12043a9df..79bbd3ee7 100644--- a/internal/application/service/knowledgebase_search_fanout_test.go+++ b/internal/application/service/knowledgebase_search_fanout_test.go@@ -415,27 +415,35 @@ func (f *fakeRetrieveEngineService) Retrieve(ctx context.Context, p types.Retriefunc (f *fakeRetrieveEngineService) Index(context.Context, embedding.Embedder, *types.IndexInfo, []types.RetrieverType) error {panic("unused")}+func (f *fakeRetrieveEngineService) BatchIndex(context.Context, embedding.Embedder, []*types.IndexInfo, []types.RetrieverType) error {panic("unused")}+func (f *fakeRetrieveEngineService) EstimateStorageSize(context.Context, embedding.Embedder, []*types.IndexInfo, []types.RetrieverType) int64 {panic("unused")}+func (f *fakeRetrieveEngineService) CopyIndices(context.Context, string, map[string]string, map[string]string, string, int, string) error {panic("unused")}+func (f *fakeRetrieveEngineService) DeleteByChunkIDList(context.Context, []string, int, string) error {panic("unused")}+func (f *fakeRetrieveEngineService) DeleteBySourceIDList(context.Context, []string, int, string) error {panic("unused")}+func (f *fakeRetrieveEngineService) DeleteByKnowledgeIDList(context.Context, []string, int, string) error {panic("unused")}+func (f *fakeRetrieveEngineService) BatchUpdateChunkEnabledStatus(context.Context, map[string]bool) error {panic("unused")}+func (f *fakeRetrieveEngineService) BatchUpdateChunkTagID(context.Context, map[string]string) error {panic("unused")}@@ -455,9 +463,11 @@ func (r *fakeFanoutRegistry) Register(interfaces.RetrieveEngineService) error {func (r *fakeFanoutRegistry) GetRetrieveEngineService(types.RetrieverEngineType) (interfaces.RetrieveEngineService, error) {return nil, stderrors.New("not used in fan-out tests")}+func (r *fakeFanoutRegistry) GetAllRetrieveEngineServices() []interfaces.RetrieveEngineService {return nil}+func (r *fakeFanoutRegistry) GetByStoreID(id string) (interfaces.RetrieveEngineService, error) {if svc, ok := r.byStore[id]; ok {return svc, nil@@ -775,7 +785,7 @@ func TestRetrieveFromStores_PerGroupTimeout(t *testing.T) {// ---------------------------------------------------------------------------// fakeKBShareForAuth implements just enough of KBShareService for the-// authorizeKBAccess test matrix. Only HasTenantKBPermission is exercised;+// authorizeKBAccess test matrix. Only CheckTenantKBPermission is exercised;// the embedded interface keeps the type assignable.type fakeKBShareForAuth struct {// allowed maps kbID → tenantID → allowed. Mirrors the Plan 3 (#1303)@@ -785,17 +795,10 @@ type fakeKBShareForAuth struct {interfaces.KBShareService}-func (f *fakeKBShareForAuth) HasTenantKBPermission(- _ context.Context, kbID string, callerTenantID uint64,- _ types.TenantRole, _ types.OrgMemberRole,-) (bool, error) {- if f.err != nil {- return false, f.err- }- if perTenant, ok := f.allowed[kbID]; ok {- return perTenant[callerTenantID], nil- }- return false, nil+func (f *fakeKBShareForAuth) CheckTenantKBPermission(+ _ context.Context, kbID string, callerTenantID uint64, _ types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ return types.OrgRoleViewer, f.allowed[kbID][callerTenantID], f.err}func ctxWithTenantForAuth(tenantID uint64) context.Context {@@ -809,7 +812,7 @@ func TestAuthorizeKBAccess_SameTenantAllPass(t *testing.T) {{ID: "kb-1", TenantID: 7},{ID: "kb-2", TenantID: 7},}- err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs, 7)+ err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs)require.NoError(t, err)}@@ -825,7 +828,7 @@ func TestAuthorizeKBAccess_ForeignTenantWithShare_OK(t *testing.T) {{ID: "kb-own", TenantID: 7},{ID: "kb-foreign", TenantID: 99},}- err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs, 7)+ err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs)require.NoError(t, err)}@@ -840,7 +843,7 @@ func TestAuthorizeKBAccess_ForeignTenantNoShare_NotFound(t *testing.T) {kbs := []*types.KnowledgeBase{{ID: "kb-foreign", TenantID: 99},}- err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs, 7)+ err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs)require.Error(t, err)app, ok := apperrors.IsAppError(err)require.True(t, ok, "expected typed AppError, got %T", err)@@ -853,7 +856,7 @@ func TestAuthorizeKBAccess_PermissionLookupError_500(t *testing.T) {share := &fakeKBShareForAuth{err: stderrors.New("share infra down")}s := &knowledgeBaseService{kbShareService: share}kbs := []*types.KnowledgeBase{{ID: "kb-foreign", TenantID: 99}}- err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs, 7)+ err := s.authorizeKBAccess(ctxWithTenantForAuth(7), kbs)require.Error(t, err)app, ok := apperrors.IsAppError(err)require.True(t, ok)@@ -863,7 +866,7 @@ func TestAuthorizeKBAccess_PermissionLookupError_500(t *testing.T) {func TestAuthorizeKBAccess_EmptyKBs_OK(t *testing.T) {t.Parallel()s := &knowledgeBaseService{kbShareService: &fakeKBShareForAuth{}}- err := s.authorizeKBAccess(ctxWithTenantForAuth(7), nil, 7)+ err := s.authorizeKBAccess(ctxWithTenantForAuth(7), nil)require.NoError(t, err)}diff --git a/internal/application/service/knowledgebase_search_shared.go b/internal/application/service/knowledgebase_search_shared.goindex c7a0aec5d..a47bbb125 100644--- a/internal/application/service/knowledgebase_search_shared.go+++ b/internal/application/service/knowledgebase_search_shared.go@@ -2,7 +2,9 @@ package serviceimport ("context"+ "errors"+ "github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/types")@@ -30,52 +32,42 @@ func (s *knowledgeBaseService) fetchKnowledgeData(ctx context.Context,}// fetchKnowledgeDataWithShared gets knowledge data in batch, including knowledge-// from shared KBs the user has access to.+// from KBs authorized for the original caller. Initial tenant-scoped rows+// require the same permission check as cross-tenant expansion.func (s *knowledgeBaseService) fetchKnowledgeDataWithShared(ctx context.Context,tenantID uint64,knowledgeIDs []string,) (map[string]*types.Knowledge, error) {- knowledgeMap, err := s.fetchKnowledgeData(ctx, tenantID, knowledgeIDs)+ rows, err := s.fetchKnowledgeData(ctx, tenantID, knowledgeIDs)if err != nil {return nil, err}-- missingIDs := s.findMissingIDs(knowledgeIDs, func(id string) bool {- return knowledgeMap[id] != nil- })- if len(missingIDs) == 0 {- return knowledgeMap, nil+ permissions := kbReadPermissions(ctx, s.kbShareService)+ knowledgeMap := make(map[string]*types.Knowledge, len(rows))+ appendAllowed := func(k *types.Knowledge) {+ if k == nil {+ return+ }+ allowed, err := permissions.Check(k.KnowledgeBaseID, k.TenantID, types.OrgRoleViewer)+ if err == nil && allowed {+ knowledgeMap[k.ID] = k+ }}- logger.Infof(ctx, "[fetchKnowledgeDataWithShared] %d knowledge IDs not found in current tenant, attempting shared KB lookup", len(missingIDs))-- userID, ok := s.extractUserID(ctx)- if !ok {- logger.Warnf(ctx, "[fetchKnowledgeDataWithShared] userID not found or empty in context, skipping shared KB lookup")- return knowledgeMap, nil+ for _, k := range rows {+ appendAllowed(k)}-- logger.Infof(ctx, "[fetchKnowledgeDataWithShared] Looking up %d missing knowledge IDs with userID=%s", len(missingIDs), userID)- callerTenantRole := types.TenantRoleFromContext(ctx)- for _, id := range missingIDs {- k, err := s.kgRepo.GetKnowledgeByIDOnly(ctx, id)- if err != nil || k == nil || k.KnowledgeBaseID == "" {- logger.Debugf(ctx, "[fetchKnowledgeDataWithShared] Knowledge %s not found or has no KB", id)+ for _, id := range knowledgeIDs {+ if rows[id] != nil {continue}- hasPermission, err := s.kbShareService.HasTenantKBPermission(ctx, k.KnowledgeBaseID, tenantID, callerTenantRole, types.OrgRoleViewer)- if err != nil {- logger.Debugf(ctx, "[fetchKnowledgeDataWithShared] Permission check error for KB %s: %v", k.KnowledgeBaseID, err)- continue+ k, err := s.kgRepo.GetKnowledgeByIDOnly(ctx, id)+ if err != nil && !errors.Is(err, repository.ErrKnowledgeNotFound) {+ return nil, err}- if !hasPermission {- logger.Debugf(ctx, "[fetchKnowledgeDataWithShared] No permission for KB %s", k.KnowledgeBaseID)- continue+ if err == nil {+ appendAllowed(k)}- logger.Debugf(ctx, "[fetchKnowledgeDataWithShared] Found shared knowledge %s in KB %s", id, k.KnowledgeBaseID)- knowledgeMap[k.ID] = k}-- logger.Infof(ctx, "[fetchKnowledgeDataWithShared] After shared lookup, total knowledge found: %d", len(knowledgeMap))return knowledgeMap, nil}@@ -84,58 +76,41 @@ func (s *knowledgeBaseService) listChunksByIDWithShared(ctx context.Context,tenantID uint64,chunkIDs []string,) ([]*types.Chunk, error) {- chunks, err := s.chunkRepo.ListChunksByID(ctx, tenantID, chunkIDs)+ rows, err := s.chunkRepo.ListChunksByID(ctx, tenantID, chunkIDs)if err != nil {return nil, err}-- foundSet := make(map[string]bool, len(chunks))- for _, c := range chunks {+ permissions := kbReadPermissions(ctx, s.kbShareService)+ chunks := make([]*types.Chunk, 0, len(rows))+ foundSet := make(map[string]bool)+ appendAllowed := func(c *types.Chunk) {+ if c == nil || foundSet[c.ID] {+ return+ }+ allowed, err := permissions.Check(c.KnowledgeBaseID, c.TenantID, types.OrgRoleViewer)+ if err == nil && allowed {+ chunks = append(chunks, c)+ foundSet[c.ID] = true+ }+ }+ for _, c := range rows {+ appendAllowed(c)if c != nil {foundSet[c.ID] = true}}-- missing := s.findMissingIDs(chunkIDs, func(id string) bool {- return foundSet[id]- })+ missing := s.findMissingIDs(chunkIDs, func(id string) bool { return foundSet[id] })if len(missing) == 0 {return chunks, nil}- logger.Infof(ctx, "[listChunksByIDWithShared] %d chunks not found in current tenant, attempting shared KB lookup", len(missing))-- userID, ok := s.extractUserID(ctx)- if !ok {- logger.Warnf(ctx, "[listChunksByIDWithShared] userID not found or empty in context, skipping shared KB lookup")- return chunks, nil- }-- logger.Infof(ctx, "[listChunksByIDWithShared] Looking up %d missing chunks with userID=%s", len(missing), userID)- callerTenantRole := types.TenantRoleFromContext(ctx)crossChunks, err := s.chunkRepo.ListChunksByIDOnly(ctx, missing)if err != nil {logger.Warnf(ctx, "[listChunksByIDWithShared] Failed to fetch chunks by ID only: %v", err)- return chunks, nil+ return nil, err}- logger.Infof(ctx, "[listChunksByIDWithShared] Found %d chunks without tenant filter", len(crossChunks))-for _, c := range crossChunks {- if c == nil || c.KnowledgeBaseID == "" {- continue- }- hasPermission, err := s.kbShareService.HasTenantKBPermission(ctx, c.KnowledgeBaseID, tenantID, callerTenantRole, types.OrgRoleViewer)- if err != nil {- logger.Debugf(ctx, "[listChunksByIDWithShared] Permission check error for KB %s: %v", c.KnowledgeBaseID, err)- continue- }- if !hasPermission {- logger.Debugf(ctx, "[listChunksByIDWithShared] No permission for KB %s", c.KnowledgeBaseID)- continue- }- chunks = append(chunks, c)+ appendAllowed(c)}-- logger.Infof(ctx, "[listChunksByIDWithShared] After shared lookup, total chunks: %d", len(chunks))return chunks, nil}@@ -149,16 +124,3 @@ func (s *knowledgeBaseService) findMissingIDs(ids []string, exists func(string)}return missing}--// extractUserID extracts the user ID from context, returning ("", false) if not found.-func (s *knowledgeBaseService) extractUserID(ctx context.Context) (string, bool) {- userIDVal := ctx.Value(types.UserIDContextKey)- if userIDVal == nil {- return "", false- }- userID, ok := userIDVal.(string)- if !ok || userID == "" {- return "", false- }- return userID, true-}diff --git a/internal/application/service/knowledgebase_search_storegroup.go b/internal/application/service/knowledgebase_search_storegroup.goindex 8e194c94a..7f8c724ba 100644--- a/internal/application/service/knowledgebase_search_storegroup.go+++ b/internal/application/service/knowledgebase_search_storegroup.go@@ -6,6 +6,7 @@ import ("fmt""time"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/application/service/retriever"apperrors "github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/logger"@@ -184,9 +185,9 @@ func classifyFactoryError(}// authorizeKBAccess rejects multi-KB searches whose scope includes a KB-// that the caller is not entitled to read. Same-tenant KBs always pass.-// Foreign-tenant KBs (Organization-shared) must pass an explicit-// tenant-scoped permission check via kbShareService.HasTenantKBPermission,+// that the original caller is not entitled to read. Exact upstream grants+// support shared KB/agent execution; other foreign KBs need an organization+// permission check for the caller via access.KBPermissions,// applying the 3-D cap (share role + caller's tenant-org role + tenant// Viewer cap) introduced in Plan 3 of #1303.//@@ -198,20 +199,24 @@ func classifyFactoryError(func (s *knowledgeBaseService) authorizeKBAccess(ctx context.Context,kbs []*types.KnowledgeBase,- requestTenantID uint64,) error {if len(kbs) == 0 {return nil}- callerTenantRole := types.TenantRoleFromContext(ctx)+ kbIDs := make([]string, 0, len(kbs))+ for _, kb := range kbs {+ kbIDs = append(kbIDs, kb.ID)+ }+ if err := types.AuthorizeTenantAPIKeyKnowledgeBases(ctx, kbIDs...); err != nil {+ return err+ }++ requestTenantID := types.CallerFromContext(ctx).TenantID+ permissions := access.NewKBPermissions(ctx, s.kbShareService)for _, kb := range kbs {- if kb.TenantID == requestTenantID {- continue- }- hasPermission, permErr := s.kbShareService.HasTenantKBPermission(- ctx, kb.ID, requestTenantID, callerTenantRole, types.OrgRoleViewer)+ hasPermission, permErr := permissions.Check(kb.ID, kb.TenantID, types.OrgRoleViewer)if permErr != nil {logger.ErrorWithFields(ctx, permErr, map[string]interface{}{"caller_tenant_id": requestTenantID,diff --git a/internal/application/service/message.go b/internal/application/service/message.goindex 260747254..b0b719263 100644--- a/internal/application/service/message.go+++ b/internal/application/service/message.go@@ -446,7 +446,7 @@ func (s *messageService) DeleteMessageKnowledge(ctx context.Context, knowledgeIDreturn}logger.Infof(ctx, "Deleting chat history knowledge entry: %s", knowledgeID)- if err := s.knowService.DeleteKnowledge(ctx, knowledgeID); err != nil {+ if err := deleteReferencedKnowledge(ctx, s.knowService, "", []string{knowledgeID}); err != nil {logger.Warnf(ctx, "Failed to delete chat history knowledge %s: %v", knowledgeID, err)}}@@ -466,7 +466,7 @@ func (s *messageService) DeleteSessionKnowledge(ctx context.Context, sessionID s}logger.Infof(ctx, "Deleting %d chat history knowledge entries for session %s", len(knowledgeIDs), sessionID)- if err := s.knowService.DeleteKnowledgeList(ctx, knowledgeIDs); err != nil {+ if err := deleteReferencedKnowledge(ctx, s.knowService, "", knowledgeIDs); err != nil {logger.Warnf(ctx, "Failed to batch delete chat history knowledge for session %s: %v", sessionID, err)}}diff --git a/internal/application/service/resource.go b/internal/application/service/resource.goindex f6b257722..c46443bce 100644--- a/internal/application/service/resource.go+++ b/internal/application/service/resource.go@@ -155,6 +155,47 @@ func (s *resourceCatalog) Bind(ctx context.Context, reference, ownerType, ownerI})}+func (s *resourceCatalog) IsReferencedByKnowledgeBase(+ ctx context.Context,+ tenantID uint64,+ kbID, reference string,+) (bool, error) {+ physical, resource, err := s.ResolvePath(ctx, reference)+ if err != nil {+ return false, err+ }+ if resource == nil {+ resource, err = s.repo.GetByTenantLocation(ctx, tenantID, resourceLocationHash(physical))+ if err != nil {+ return false, err+ }+ }+ if resource == nil || resource.TenantID != tenantID {+ return false, nil+ }+ return s.repo.IsReferencedByKnowledgeBase(ctx, tenantID, kbID, resource.ID)+}++// GetMessageFileBindings resolves registered aliases before reading authoritative origins.+func (s *resourceCatalog) GetMessageFileBindings(+ ctx context.Context, tenantID uint64, reference, messageID string,+) (*types.MessageFileBindings, error) {+ physical, resource, err := s.ResolvePath(ctx, reference)+ if err != nil {+ return nil, err+ }+ if resource == nil {+ resource, err = s.repo.GetByTenantLocation(ctx, tenantID, resourceLocationHash(physical))+ if err != nil {+ return nil, err+ }+ }+ if resource == nil || resource.TenantID != tenantID {+ return &types.MessageFileBindings{}, nil+ }+ return s.repo.GetMessageFileBindings(ctx, tenantID, resource.ID, messageID)+}+// Release implements interfaces.ResourceCatalog.//// Unbinding and counting are deliberately not a single transaction. A racingdiff --git a/internal/application/service/resource_file_authorization_test.go b/internal/application/service/resource_file_authorization_test.gonew file mode 100644index 000000000..6475d5182--- /dev/null+++ b/internal/application/service/resource_file_authorization_test.go@@ -0,0 +1,169 @@+package service++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++type catalogFileShares struct{}++func (catalogFileShares) CheckTenantKBPermission(+ _ context.Context,+ kb string,+ _ uint64,+ _ types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ return types.OrgRoleViewer, kb == "shared", nil+}++func (catalogFileShares) GetKnowledgeBasesByIDsOnly(context.Context, []string) ([]*types.KnowledgeBase, error) {+ return []*types.KnowledgeBase{{ID: "shared", TenantID: 7}}, nil+}++type catalogFileAgent struct{ agent *types.CustomAgent }++func (a *catalogFileAgent) GetSharedAgentForTenant(+ context.Context,+ uint64,+ types.TenantRole,+ string,+ ...uint64,+) (*types.CustomAgent, error) {+ return a.agent, nil+}++func TestCatalogFileAuthorizationRejectsPrivateHandlesInSharedText(t *testing.T) {+ catalog, db := newResourceCatalogForTest(t)+ require.NoError(t, db.AutoMigrate(&types.KnowledgeBase{}, &types.Knowledge{}, &types.Chunk{}, &types.WikiPage{}))+ ctx := newSharedAccessContext()+ const physical = "local://7/exports/private.png"+ ref, err := catalog.Register(ctx, 7, physical, interfaces.ResourceRegistration{})+ require.NoError(t, err)+ for _, kb := range []string{"private", "shared"} {+ require.NoError(t, db.Create(&types.KnowledgeBase{ID: kb, TenantID: 7}).Error)+ require.NoError(+ t,+ db.Create(&types.Knowledge{ID: kb + "-doc", TenantID: 7, KnowledgeBaseID: kb, Type: "file"}).Error,+ )+ }+ require.NoError(+ t,+ catalog.Bind(ctx, ref, types.ResourceOwnerKnowledge, "private-doc", types.ResourceRelationSourceFile),+ )+ text := " "+ require.NoError(+ t,+ db.Create(+ &types.Chunk{ID: "chunk", TenantID: 7, KnowledgeBaseID: "shared", KnowledgeID: "shared-doc", Content: text},+ ).Error,+ )+ require.NoError(+ t,+ db.Create(&types.WikiPage{ID: "wiki", TenantID: 7, KnowledgeBaseID: "shared", Content: text}).Error,+ )+ grant := &access.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{ID: "shared", TenantID: 7},+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: 7,+ Permission: types.OrgRoleViewer,+ }+ lookup := catalog.(interfaces.KBResourceLookup)+ message := &types.Message{+ ID: "message",+ AgentTenantID: 1,+ Content: text,+ KnowledgeReferences: []*types.SearchResult{{KnowledgeBaseID: "shared", Content: text}},+ }+ shares := access.MessageKBShareAuthorizer{ShareGuard: catalogFileShares{}, KBs: catalogFileShares{}}+ check := func(allowed bool) {+ t.Helper()+ for _, path := range []string{ref, physical} {+ _, err := access.ResolveKBFile(ctx, grant, "shared", path, catalog, lookup)+ if allowed {+ require.NoError(t, err)+ } else {+ require.ErrorIs(t, err, access.ErrForbidden)+ }+ _, err = access.AuthorizeMessageFile(ctx, message, path, nil, catalog, shares)+ if allowed && path == ref {+ require.NoError(t, err)+ } else {+ require.ErrorIs(t, err, access.ErrForbidden)+ }+ }+ }+ check(false)+ require.NoError(+ t,+ catalog.Bind(ctx, ref, types.ResourceOwnerKnowledge, "shared-doc", types.ResourceRelationSourceFile),+ )+ check(true)+ require.NoError(t, db.Where("id = ?", "shared").Delete(&types.KnowledgeBase{}).Error)+ check(false)+}++func TestCatalogSharedAgentFileRequiresCurrentSelectionOrExactArtifactBinding(t *testing.T) {+ catalog, db := newResourceCatalogForTest(t)+ require.NoError(t, db.AutoMigrate(&types.KnowledgeBase{}, &types.Knowledge{}))+ ctx := newSharedAccessContext()+ const physical = "local://7/exports/source.pdf"+ ref, err := catalog.Register(ctx, 7, physical, interfaces.ResourceRegistration{})+ require.NoError(t, err)+ require.NoError(t, db.Create(&types.KnowledgeBase{ID: "private", TenantID: 7}).Error)+ doc := &types.Knowledge{ID: "doc", TenantID: 7, KnowledgeBaseID: "private", Type: "file"}+ require.NoError(t, db.Create(doc).Error)+ require.NoError(t, catalog.Bind(ctx, ref, types.ResourceOwnerKnowledge, "doc", types.ResourceRelationSourceFile))+ agents := &catalogFileAgent{agent: &types.CustomAgent{ID: "agent", TenantID: 7}}+ message := &types.Message{+ ID: "message",+ AgentID: "agent",+ AgentTenantID: 7,+ Content: ref + " " + physical,+ Artifacts: types.MessageArtifacts{{URL: ref}},+ }+ check := func(allowed bool) {+ t.Helper()+ for _, path := range []string{ref, physical} {+ _, err := access.AuthorizeMessageFile(+ ctx,+ message,+ path,+ agents,+ catalog,+ access.MessageKBShareAuthorizer{},+ )+ if allowed {+ require.NoError(t, err)+ } else {+ require.ErrorIs(t, err, access.ErrForbidden)+ }+ }+ }+ for _, mode := range []string{"none", "", "unknown", "selected", "all"} {+ agents.agent.Config = types.CustomAgentConfig{KBSelectionMode: mode, KnowledgeBases: []string{"private"}}+ check(mode == "selected" || mode == "all")+ }+ agents.agent.Config = types.CustomAgentConfig{KBSelectionMode: "selected", KnowledgeBases: []string{"other"}}+ check(false)+ agents.agent.Config.KnowledgeBases = []string{"private"}+ scoped := types.WithTenantAPIKeyScope(ctx, types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"other"}})+ _, err = access.AuthorizeMessageFile(scoped, message, ref, agents, catalog, access.MessageKBShareAuthorizer{})+ require.ErrorIs(t, err, access.ErrForbidden)+ require.NoError(t, db.Delete(doc).Error)+ check(false)+ agents.agent.Config.KBSelectionMode = "none"+ require.NoError(+ t,+ catalog.Bind(ctx, ref, types.ResourceOwnerMessage, "another-message", types.ResourceRelationArtifact),+ )+ check(false)+ require.NoError(t, catalog.Bind(ctx, ref, types.ResourceOwnerMessage, "message", types.ResourceRelationArtifact))+ check(true)+ agents.agent = nil+ check(false)+}diff --git a/internal/application/service/resource_references_test.go b/internal/application/service/resource_references_test.gonew file mode 100644index 000000000..fefffa4cf--- /dev/null+++ b/internal/application/service/resource_references_test.go@@ -0,0 +1,71 @@+package service++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++func TestKBFileBindingRequiresLiveKnowledgeInExactKB(t *testing.T) {+ catalog, db := newResourceCatalogForTest(t)+ require.NoError(t, db.AutoMigrate(&types.KnowledgeBase{}, &types.Knowledge{}, &types.Chunk{}, &types.WikiPage{}))+ ctx := context.Background()+ ref, err := catalog.Register(ctx, 7, "local://7/exports/image.png", interfaces.ResourceRegistration{})+ require.NoError(t, err)+ require.NoError(t, db.Create(&types.KnowledgeBase{ID: "kb", TenantID: 7}).Error)+ knowledge := &types.Knowledge{ID: "doc", TenantID: 7, KnowledgeBaseID: "kb", Type: "file"}+ require.NoError(t, db.Create(knowledge).Error)+ require.NoError(+ t,+ catalog.Bind(ctx, ref, types.ResourceOwnerKnowledge, "doc", types.ResourceRelationExtractedImage),+ )+ lookup := catalog.(interfaces.KBResourceLookup)+ for _, reference := range []string{ref, "local://7/exports/image.png"} {+ ok, err := lookup.IsReferencedByKnowledgeBase(ctx, 7, "kb", reference)+ require.NoError(t, err)+ require.True(t, ok)+ ok, err = lookup.IsReferencedByKnowledgeBase(ctx, 7, "other-kb", reference)+ require.NoError(t, err)+ require.False(t, ok)+ }+ require.NoError(t, db.Delete(knowledge).Error)+ ok, err := lookup.IsReferencedByKnowledgeBase(ctx, 7, "kb", ref)+ require.NoError(t, err)+ require.False(t, ok, "a stale binding cannot authorize a deleted document")+}++func TestKBFileLegacyTextReferencesDoNotAuthorizeFiles(t *testing.T) {+ catalog, db := newResourceCatalogForTest(t)+ require.NoError(t, db.AutoMigrate(&types.KnowledgeBase{}, &types.Knowledge{}, &types.Chunk{}, &types.WikiPage{}))+ lookup := catalog.(interfaces.KBResourceLookup)+ const reference = "local://7/exports/image.png"+ chunk := &types.Chunk{+ ID: "chunk",+ TenantID: 7,+ KnowledgeBaseID: "kb",+ Content: "",+ }+ require.NoError(t, db.Create(chunk).Error)+ ok, err := lookup.IsReferencedByKnowledgeBase(context.Background(), 7, "kb", reference)+ require.NoError(t, err)+ require.False(t, ok)+ require.NoError(t, db.Model(chunk).Update("image_info", `[{"url":"`+reference+`"}]`).Error)+ ok, err = lookup.IsReferencedByKnowledgeBase(context.Background(), 7, "kb", reference)+ require.NoError(t, err)+ require.False(t, ok, "text is not an ownership binding")+ require.NoError(t, db.Delete(chunk).Error)+ ok, err = lookup.IsReferencedByKnowledgeBase(context.Background(), 7, "kb", reference)+ require.NoError(t, err)+ require.False(t, ok)+ page := &types.WikiPage{ID: "page", TenantID: 7, KnowledgeBaseID: "kb", Content: ""}+ require.NoError(t, db.Create(page).Error)+ ok, err = lookup.IsReferencedByKnowledgeBase(context.Background(), 7, "kb", reference)+ require.NoError(t, err)+ require.False(t, ok, "text is not an ownership binding")+ ok, err = lookup.IsReferencedByKnowledgeBase(context.Background(), 8, "kb", reference)+ require.NoError(t, err)+ require.False(t, ok)+}diff --git a/internal/application/service/resource_review_regression_test.go b/internal/application/service/resource_review_regression_test.gonew file mode 100644index 000000000..8bf5c2ab1--- /dev/null+++ b/internal/application/service/resource_review_regression_test.go@@ -0,0 +1,284 @@+package service++import (+ "context"+ "encoding/json"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/hibiken/asynq"+ "github.com/stretchr/testify/require"+)++func TestReparseRejectsMovingDocumentBeforeSideEffects(t *testing.T) {+ f := newDocumentWriteFixture(t)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(t, setTransferState(row, knowledgeTransferState{Operation: access.KBTransferMove, Phase: "moving"}))+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ f.repo.writes = 0+ _, err = f.svc.ReparseKnowledge(f.ctx, "doc", nil)+ var appErr *apperrors.AppError+ require.ErrorAs(t, err, &appErr)+ require.Equal(t, 409, appErr.HTTPCode)+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.chunkRepo.writes)+ require.Zero(t, f.graph.calls)+}++func TestReparseRequiresExplicitWriteGrant(t *testing.T) {+ f := newDocumentWriteFixture(t)+ ctx := types.WithExecutionTenant(context.Background(), 7)+ _, err := f.svc.ReparseKnowledge(ctx, "doc", nil)+ require.Error(t, err)+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.chunkRepo.writes)+}++func TestReparseTaskPinsOriginalKBBeforeAnySubmission(t *testing.T) {+ for _, scenario := range []string{"moved", "missing", "mixed legacy", "blank ID", "moving"} {+ t.Run(scenario, func(t *testing.T) {+ f := newDocumentWriteFixture(t)+ payload := types.KnowledgeListReparsePayload{+ TenantID: 7, KnowledgeBaseID: "kb", KnowledgeIDs: []string{"doc"},+ }+ switch scenario {+ case "moved":+ require.NoError(+ t,+ f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("knowledge_base_id", "other").Error,+ )+ case "missing":+ payload.KnowledgeIDs = append(payload.KnowledgeIDs, "missing")+ case "mixed legacy":+ payload.KnowledgeBaseID = ""+ payload.KnowledgeIDs = append(payload.KnowledgeIDs, "other-doc")+ case "blank ID":+ payload.KnowledgeIDs = append(payload.KnowledgeIDs, " ")+ case "moving":+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(+ t,+ setTransferState(row, knowledgeTransferState{Operation: access.KBTransferMove, Phase: "moving"}),+ )+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ }+ f.repo.writes = 0+ raw, err := json.Marshal(payload)+ require.NoError(t, err)+ err = f.svc.ProcessKnowledgeListReparse(+ context.Background(), asynq.NewTask(types.TypeKnowledgeListReparse, raw),+ )+ require.ErrorIs(t, err, asynq.SkipRetry)+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.chunkRepo.writes)+ })+ }+}++func TestReparseTaskGrantCannotFollowMoveAfterPreflight(t *testing.T) {+ f := newDocumentWriteFixture(t)+ ctx, ids, err := f.svc.reparseTaskScope(context.Background(), types.KnowledgeListReparsePayload{+ TenantID: 7, KnowledgeBaseID: "kb", KnowledgeIDs: []string{"doc", "doc"},+ })+ require.NoError(t, err)+ require.Equal(t, []string{"doc"}, ids)+ require.NoError(t, access.RequireKBWrite(ctx, f.kbs.values["kb"]))+ require.Error(t, access.RequireKBWrite(ctx, f.kbs.values["other"]))+ require.NoError(t, f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("knowledge_base_id", "other").Error)+ _, err = f.svc.ReparseKnowledge(ctx, "doc", nil)+ require.Error(t, err)+ require.Zero(t, f.repo.writes)+ require.Zero(t, f.chunkRepo.writes)+}++type sharedChunkFailureRepo struct {+ interfaces.ChunkRepository+ failure error+}++func (r sharedChunkFailureRepo) ListChunksByID(context.Context, uint64, []string) ([]*types.Chunk, error) {+ return []*types.Chunk{{ID: "own", TenantID: 1, KnowledgeBaseID: "own"}}, nil+}++func (r sharedChunkFailureRepo) ListChunksByIDOnly(context.Context, []string) ([]*types.Chunk, error) {+ return nil, r.failure+}++func TestSharedChunkReadPropagatesStorageFailure(t *testing.T) {+ failure := errors.New("shared chunk storage unavailable")+ svc := &knowledgeBaseService{chunkRepo: sharedChunkFailureRepo{failure: failure}}+ rows, err := svc.listChunksByIDWithShared(newSharedAccessContext(), 1, []string{"own", "shared"})+ require.ErrorIs(t, err, failure)+ require.Nil(t, rows)+}++func TestFAQCloneDoesNotInheritTransferState(t *testing.T) {+ f := transferFixture(t, access.KBTransferClone)+ kb := &types.KnowledgeBase{ID: "new-faq", TenantID: 7}+ src := &types.Knowledge{+ Metadata: types.JSON(`{"custom":{"value":3},"_knowledge_transfer":{"operation":"move","phase":"moving"}}`),+ }+ before := string(src.Metadata)+ dst, err := f.svc.getOrCreateFAQKnowledge(f.ctx, kb, src)+ require.NoError(t, err)+ require.JSONEq(t, `{"custom":{"value":3}}`, string(dst.Metadata))+ require.Equal(t, before, string(src.Metadata))+ require.NoError(t, access.RejectMovingKnowledge(dst))+}++type partialCloneEngine struct {+ parentChildRetrieveEngine+ vectors map[string]int+ cleanupFailure bool+}++func (e *partialCloneEngine) Support() []types.RetrieverType {+ return []types.RetrieverType{types.VectorRetrieverType, types.KeywordsRetrieverType}+}++func (e *partialCloneEngine) CopyIndices(+ _ context.Context, _ string, documents, _ map[string]string, _ string, _ int, _ string,+) error {+ for _, id := range documents {+ e.vectors[id] = 1+ }+ return errors.New("partial vector copy")+}++func (e *partialCloneEngine) DeleteByKnowledgeIDList(_ context.Context, ids []string, _ int, _ string) error {+ if e.cleanupFailure {+ return errors.New("vector cleanup unavailable")+ }+ for _, id := range ids {+ delete(e.vectors, id)+ }+ return nil+}++func TestClonePartialIndexFailureCleansOnlyItsDestination(t *testing.T) {+ for _, cleanupFailure := range []bool{false, true} {+ t.Run(map[bool]string{false: "cleaned", true: "cleanup fails visibly"}[cleanupFailure], func(t *testing.T) {+ t.Setenv("RETRIEVE_DRIVER", "postgres")+ f := transferFixture(t, access.KBTransferClone)+ engine := &partialCloneEngine{vectors: map[string]int{"doc": 1}, cleanupFailure: cleanupFailure}+ f.svc.retrieveEngine = parentChildRetrieveRegistry{engine: engine}+ f.svc.modelService = parentChildModelService{embedder: parentChildEmbedder{}}+ f.kbs.values["other"].EmbeddingModelID = "model"+ src, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ err = f.svc.cloneKnowledge(f.ctx, src, f.kbs.values["other"])+ require.ErrorContains(t, err, "partial vector copy")+ rows, err := f.repo.ListKnowledgeByKnowledgeBaseID(f.ctx, 7, "other")+ require.NoError(t, err)+ var dst *types.Knowledge+ for _, row := range rows {+ if row.ID != "other-doc" {+ dst = row+ }+ }+ require.NotNil(t, dst)+ require.Equal(t, types.ParseStatusFailed, dst.ParseStatus)+ chunks, err := f.chunkRepo.ListAllChunksByKnowledgeID(f.ctx, 7, dst.ID)+ require.NoError(t, err)+ if cleanupFailure {+ require.Len(t, chunks, 1, "retain image references when index cleanup is uncertain")+ require.Equal(t, 1, engine.vectors[dst.ID])+ require.Contains(t, dst.ErrorMessage, "vector cleanup unavailable")+ } else {+ require.Empty(t, chunks)+ require.Zero(t, engine.vectors[dst.ID])+ }+ require.Equal(t, 1, engine.vectors["doc"])+ var tenant types.Tenant+ require.NoError(t, f.db.First(&tenant, 7).Error)+ require.EqualValues(t, 5, tenant.StorageUsed, "failed clones must not change storage accounting")+ })+ }+}++func TestReparseWorkerSubmitsPinnedAndLegacySingleKBTasks(t *testing.T) {+ for _, kbID := range []string{"kb", ""} {+ t.Run("scope="+kbID, func(t *testing.T) {+ f := newDocumentWriteFixture(t)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.NoError(+ t,+ row.SetManualMetadata(+ types.NewManualKnowledgeMetadata("# content", types.ManualKnowledgeStatusPublish, 1),+ ),+ )+ require.NoError(t, f.repo.UpdateKnowledge(f.ctx, row))+ f.svc.task = &transferQueue{}+ raw, err := json.Marshal(types.KnowledgeListReparsePayload{+ TenantID: 7, KnowledgeBaseID: kbID, KnowledgeIDs: []string{"doc"},+ })+ require.NoError(t, err)+ require.NoError(+ t,+ f.svc.ProcessKnowledgeListReparse(+ context.Background(), asynq.NewTask(types.TypeKnowledgeListReparse, raw),+ ),+ )+ row, err = f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, types.ParseStatusPending, row.ParseStatus)+ })+ }+}++func TestMovedReparseTransferPhaseDoesNotBlockItsParser(t *testing.T) {+ row := &types.Knowledge{ID: "doc", TenantID: 7, KnowledgeBaseID: "target", ParseStatus: types.ParseStatusPending}+ for _, phase := range []string{"reparse_pending", "done"} {+ require.NoError(+ t,+ setTransferState(row, knowledgeTransferState{+ Operation: access.KBTransferMove, Mode: "reparse", Phase: phase,+ }),+ )+ require.NoError(t, validateProcessingKnowledge(row, 7, "target", "doc"))+ require.ErrorIs(t, validateProcessingKnowledge(row, 7, "source", "doc"), asynq.SkipRetry)+ require.Equal(t, types.ParseStatusPending, row.ParseStatus, "transfer state is independent of parse completion")+ }+}++type orphanMoveEngine struct {+ partialCloneEngine+ calls int+ chunks []string+}++func (e *orphanMoveEngine) MoveKnowledgeIndices(+ _ context.Context, _, _, _ string, chunks []string, _ int, _ string,+) error {+ e.calls+++ e.chunks = append([]string(nil), chunks...)+ return nil+}++func TestMoveStillVisitsVectorBackendWithoutDatabaseChunks(t *testing.T) {+ t.Setenv("RETRIEVE_DRIVER", "postgres")+ f := transferFixture(t, access.KBTransferMove)+ engine := &orphanMoveEngine{}+ f.svc.retrieveEngine = parentChildRetrieveRegistry{engine: engine}+ f.svc.modelService = parentChildModelService{embedder: parentChildEmbedder{}}+ f.kbs.values["kb"].EmbeddingModelID = "model"+ f.kbs.values["other"].EmbeddingModelID = "model"+ require.NoError(+ t,+ f.db.Model(&types.Knowledge{}).Where("id = ?", "doc").Update("embedding_model_id", "model").Error,+ )+ require.NoError(t, f.db.Where("knowledge_id = ?", "doc").Delete(&types.Chunk{}).Error)+ require.NoError(t, f.svc.ProcessKnowledgeMove(context.Background(), moveTask(t, []string{"doc"}, "reuse_vectors")))+ require.Equal(t, 1, engine.calls)+ require.Empty(t, engine.chunks)+ row, err := f.repo.GetKnowledgeByID(f.ctx, 7, "doc")+ require.NoError(t, err)+ require.Equal(t, "other", row.KnowledgeBaseID)+}diff --git a/internal/application/service/retriever/composite.go b/internal/application/service/retriever/composite.goindex 977dd049b..cef6171a9 100644--- a/internal/application/service/retriever/composite.go+++ b/internal/application/service/retriever/composite.go@@ -312,3 +312,42 @@ func (c *CompositeRetrieveEngine) EstimateStorageSize(ctx context.Context,}return sum.Load()}++// ValidateKnowledgeIndexMove checks all stores before the first mutation.+func (c *CompositeRetrieveEngine) ValidateKnowledgeIndexMove(ctx context.Context) error {+ for _, info := range c.engineInfos {+ if _, ok := info.retrieveEngine.(interfaces.KnowledgeIndexMover); !ok {+ return fmt.Errorf("retriever %s does not support moving indices", info.retrieveEngine.EngineType())+ }+ if validator, ok := info.retrieveEngine.(interface{ ValidateKnowledgeIndexMove(context.Context) error }); ok {+ if err := validator.ValidateKnowledgeIndexMove(ctx); err != nil {+ return err+ }+ }+ }+ return nil+}++// MoveKnowledgeIndices updates each validated store with retry-safe operations.+func (c *CompositeRetrieveEngine) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ chunkIDs []string,+ dimension int,+ knowledgeType string,+) error {+ if err := c.ValidateKnowledgeIndexMove(ctx); err != nil {+ return err+ }+ return c.concurrentExecWithError(ctx, func(ctx context.Context, info *engineInfo) error {+ return info.retrieveEngine.(interfaces.KnowledgeIndexMover).MoveKnowledgeIndices(+ ctx,+ sourceKB,+ targetKB,+ knowledgeID,+ chunkIDs,+ dimension,+ knowledgeType,+ )+ })+}diff --git a/internal/application/service/retriever/keywords_vector_hybrid_indexer.go b/internal/application/service/retriever/keywords_vector_hybrid_indexer.goindex 3e62ceb86..efb6d5824 100644--- a/internal/application/service/retriever/keywords_vector_hybrid_indexer.go+++ b/internal/application/service/retriever/keywords_vector_hybrid_indexer.go@@ -2,6 +2,7 @@ package retrieverimport ("context"+ "fmt""regexp""slices""strings"@@ -346,3 +347,37 @@ func (v *KeywordsVectorHybridRetrieveEngineService) BatchUpdateChunkTagID() error {return v.indexRepository.BatchUpdateChunkTagID(ctx, chunkTagMap)}++// ValidateKnowledgeIndexMove checks backend support before any mutation.+func (v *KeywordsVectorHybridRetrieveEngineService) ValidateKnowledgeIndexMove(ctx context.Context) error {+ if _, ok := v.indexRepository.(interfaces.KnowledgeIndexMover); !ok {+ return fmt.Errorf("retriever %s does not support moving indices", v.EngineType())+ }+ if validator, ok := v.indexRepository.(interface{ ValidateKnowledgeIndexMove(context.Context) error }); ok {+ return validator.ValidateKnowledgeIndexMove(ctx)+ }++ return nil+}++// MoveKnowledgeIndices delegates metadata relocation to the supported backend.+func (v *KeywordsVectorHybridRetrieveEngineService) MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ chunkIDs []string,+ dimension int,+ knowledgeType string,+) error {+ if err := v.ValidateKnowledgeIndexMove(ctx); err != nil {+ return err+ }+ return v.indexRepository.(interfaces.KnowledgeIndexMover).MoveKnowledgeIndices(+ ctx,+ sourceKB,+ targetKB,+ knowledgeID,+ chunkIDs,+ dimension,+ knowledgeType,+ )+}diff --git a/internal/application/service/retriever/move_test.go b/internal/application/service/retriever/move_test.gonew file mode 100644index 000000000..5050bf251--- /dev/null+++ b/internal/application/service/retriever/move_test.go@@ -0,0 +1,38 @@+package retriever++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/stretchr/testify/require"+)++type moveTestEngine struct {+ fakeEngine+ calls int+}++func (e *moveTestEngine) MoveKnowledgeIndices(context.Context, string, string, string, []string, int, string) error {+ e.calls+++ return nil+}++func TestCompositeMoveChecksAllEnginesBeforeMutation(t *testing.T) {+ supported := &moveTestEngine{fakeEngine: fakeEngine{engineType: types.PostgresRetrieverEngineType}}+ unsupported := &fakeEngine{engineType: types.ElasticsearchRetrieverEngineType}+ c := &CompositeRetrieveEngine{+ engineInfos: []*engineInfo{{retrieveEngine: supported}, {retrieveEngine: unsupported}},+ }+ require.Error(+ t,+ c.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", []string{"chunk"}, 2, "document"),+ )+ require.Zero(t, supported.calls)+ c.engineInfos = c.engineInfos[:1]+ require.NoError(+ t,+ c.MoveKnowledgeIndices(context.Background(), "source", "target", "doc", []string{"chunk"}, 2, "document"),+ )+ require.Equal(t, 1, supported.calls)+}diff --git a/internal/application/service/session.go b/internal/application/service/session.goindex d7d07fce3..a1e026c27 100644--- a/internal/application/service/session.go+++ b/internal/application/service/session.go@@ -6,18 +6,17 @@ import ("fmt""strings"+ "github.com/Tencent/WeKnora/internal/application/repository"+ chatpipeline "github.com/Tencent/WeKnora/internal/application/service/chat_pipeline""github.com/Tencent/WeKnora/internal/config"apperrors "github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/event""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/models/chat"+ "github.com/Tencent/WeKnora/internal/sandbox""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces""github.com/google/uuid"-- "github.com/Tencent/WeKnora/internal/application/repository"- chatpipeline "github.com/Tencent/WeKnora/internal/application/service/chat_pipeline"- "github.com/Tencent/WeKnora/internal/sandbox")func sessionUserIDFromContext(ctx context.Context) string {@@ -495,7 +494,7 @@ func (s *sessionService) DeleteSession(ctx context.Context, id string) error {return}if len(knowledgeIDs) > 0 {- if err := s.knowledgeService.DeleteKnowledgeList(bgCtx, knowledgeIDs); err != nil {+ if err := deleteReferencedKnowledge(bgCtx, s.knowledgeService, "", knowledgeIDs); err != nil {logger.Warnf(bgCtx, "Failed to delete chat history knowledge for session %s: %v", id, err)}}@@ -572,7 +571,7 @@ func (s *sessionService) BatchDeleteSessions(ctx context.Context, ids []string)return}if len(knowledgeIDs) > 0 {- if err := s.knowledgeService.DeleteKnowledgeList(bgCtx, knowledgeIDs); err != nil {+ if err := deleteReferencedKnowledge(bgCtx, s.knowledgeService, "", knowledgeIDs); err != nil {logger.Warnf(bgCtx, "Failed to delete chat history knowledge for session %s: %v", sessionID, err)}}@@ -629,7 +628,7 @@ func (s *sessionService) DeleteAllSessions(ctx context.Context) error {return}if len(knowledgeIDs) > 0 {- if err := s.knowledgeService.DeleteKnowledgeList(bgCtx, knowledgeIDs); err != nil {+ if err := deleteReferencedKnowledge(bgCtx, s.knowledgeService, "", knowledgeIDs); err != nil {logger.Warnf(bgCtx, "Failed to delete chat history knowledge for session %s: %v", sessionID, err)}}diff --git a/internal/application/service/session_knowledge_qa.go b/internal/application/service/session_knowledge_qa.goindex bf0233b23..7742531d9 100644--- a/internal/application/service/session_knowledge_qa.go+++ b/internal/application/service/session_knowledge_qa.go@@ -445,6 +445,7 @@ func (s *sessionService) buildSearchTargets(knowledgeIDs []string,tagScopes []types.TagScope,) (types.SearchTargets, error) {+ caller := types.CallerFromContext(ctx)var targets types.SearchTargetstagIDsByKB := mergeTagScopesByKB(tagScopes)@@ -455,7 +456,7 @@ func (s *sessionService) buildSearchTargets(fullKBSet := make(map[string]bool)// First pass: batch-fetch KBs, then resolve tenant per ID (tenant scope already set by caller)- callerTenantRole := types.TenantRoleFromContext(ctx)+ permissions := kbReadPermissions(ctx, s.kbShareService)kbIDsToFetch := append([]string(nil), knowledgeBaseIDs...)for kbID := range tagIDsByKB {kbIDsToFetch = append(kbIDsToFetch, kbID)@@ -474,25 +475,17 @@ func (s *sessionService) buildSearchTargets(}}}- userID, _ := types.UserIDFromContext(ctx)resolveKBTenant := func(kbID string) uint64 {if kbTenantMap[kbID] != 0 {return kbTenantMap[kbID]}kb := kbByID[kbID]- if kb == nil {- kbTenantMap[kbID] = tenantID- } else if kb.TenantID == tenantID {- kbTenantMap[kbID] = tenantID- } else if s.kbShareService != nil && userID != "" {- hasAccess, _ := s.kbShareService.HasTenantKBPermission(ctx, kbID, tenantID, callerTenantRole, types.OrgRoleViewer)- if hasAccess {+ kbTenantMap[kbID] = caller.TenantID+ if kb != nil {+ kbTenantMap[kbID] = 0+ if allowed, err := permissions.Check(kbID, kb.TenantID, types.OrgRoleViewer); err == nil && allowed {kbTenantMap[kbID] = kb.TenantID- } else {- kbTenantMap[kbID] = tenantID}- } else {- kbTenantMap[kbID] = tenantID}return kbTenantMap[kbID]}@@ -501,6 +494,9 @@ func (s *sessionService) buildSearchTargets(for _, kbID := range knowledgeBaseIDs {fullKBSet[kbID] = truekbTenant := resolveKBTenant(kbID)+ if kbTenant == 0 {+ continue+ }if len(tagIDsByKB[kbID]) > 0 {continue}@@ -563,6 +559,9 @@ func (s *sessionService) buildSearchTargets(continue}kbTenant := resolveKBTenant(kbID)+ if kbTenant == 0 {+ continue+ }kb := kbByID[kbID]explicitKnowledgeIDs := uniqueNonEmptyStrings(kbToKnowledgeIDs[kbID])diff --git a/internal/application/service/tag.go b/internal/application/service/tag.goindex e0f4f6b82..50d8010e5 100644--- a/internal/application/service/tag.go+++ b/internal/application/service/tag.go@@ -29,6 +29,7 @@ type knowledgeTagService struct {modelService interfaces.ModelServicetask interfaces.TaskEnqueuerkbShareService interfaces.KBShareService+ tenantRepo interfaces.TenantRepositoryaudit interfaces.AuditLogService}@@ -43,6 +44,7 @@ func NewKnowledgeTagService(modelService interfaces.ModelService,task interfaces.TaskEnqueuer,kbShareService interfaces.KBShareService,+ tenantRepo interfaces.TenantRepository,audit interfaces.AuditLogService,) (interfaces.KnowledgeTagService, error) {return &knowledgeTagService{@@ -55,6 +57,7 @@ func NewKnowledgeTagService(modelService: modelService,task: task,kbShareService: kbShareService,+ tenantRepo: tenantRepo,audit: audit,}, nil}@@ -79,27 +82,11 @@ func (s *knowledgeTagService) ListTags(return nil, err}- // Check access permission- tenantID := types.MustTenantIDFromContext(ctx)- if kb.TenantID != tenantID {- // Get user ID from context- userIDVal := ctx.Value(types.UserIDContextKey)- if userIDVal == nil {- return nil, werrors.NewForbiddenError("无权访问该知识库")- }- _ = userIDVal.(string)- callerTenantRole := types.TenantRoleFromContext(ctx)-- // Check whether the caller's tenant has at least viewer permission via org sharing.- hasPermission, err := s.kbShareService.HasTenantKBPermission(ctx, kbID, tenantID, callerTenantRole, types.OrgRoleViewer)- if err != nil || !hasPermission {- return nil, werrors.NewForbiddenError("无权访问该知识库")- }+ effectiveTenantID, err := resolveKBReadTenant(ctx, kb, s.kbShareService)+ if err != nil {+ return nil, err}- // Use kb's tenant ID for data access- effectiveTenantID := kb.TenantID-tags, total, err := s.repo.ListByKB(ctx, effectiveTenantID, kbID, page, keyword)if err != nil {return nil, err@@ -158,6 +145,10 @@ func (s *knowledgeTagService) CreateTag(if err != nil {return nil, err}+ ctx, err = requireKBWrite(ctx, kb)+ if err != nil {+ return nil, err+ }// Check if tag with same name already existsexistingTag, err := s.repo.GetByName(ctx, kb.TenantID, kbID, name)@@ -202,11 +193,18 @@ func (s *knowledgeTagService) UpdateTag(if id == "" {return nil, werrors.NewBadRequestError("标签ID不能为空")}- tenantID := types.MustTenantIDFromContext(ctx)+ tenantID, ok := types.TenantIDFromContext(ctx)+ if !ok || tenantID == 0 {+ return nil, werrors.NewForbiddenError("无权修改标签")+ }tag, err := s.repo.GetByID(ctx, tenantID, id)if err != nil {return nil, err}+ _, ctx, err = s.requireTagWrite(ctx, tag)+ if err != nil {+ return nil, err+ }if name != nil {newName := strings.TrimSpace(*name)@@ -237,14 +235,22 @@ func (s *knowledgeTagService) DeleteTag(ctx context.Context, id string, force boif id == "" {return werrors.NewBadRequestError("标签ID不能为空")}- tenantID := types.MustTenantIDFromContext(ctx)+ tenantID, ok := types.TenantIDFromContext(ctx)+ if !ok || tenantID == 0 {+ return werrors.NewForbiddenError("无权修改标签")+ }tag, err := s.repo.GetByID(ctx, tenantID, id)if err != nil {return err}-- // Get KB info for embedding model- kb, err := s.kbService.GetKnowledgeBaseByID(ctx, tag.KnowledgeBaseID)+ kb, ctx, err := s.requireTagWrite(ctx, tag)+ if err != nil {+ return err+ }+ if err := s.validateTagDeleteExclusions(ctx, kb, excludeIDs); err != nil {+ return err+ }+ ctx, err = withKBWriteTenantInfo(ctx, kb, s.tenantRepo)if err != nil {return err}@@ -291,9 +297,10 @@ func (s *knowledgeTagService) DeleteTag(ctx context.Context, id string, force bo}// Enqueue async task to delete knowledge filespayload := types.KnowledgeListDeletePayload{- TenantID: tenantID,- KnowledgeIDs: knowledgeIDs,- Initiator: types.TaskInitiatorFromContext(ctx),+ KnowledgeBaseID: kb.ID,+ TenantID: tenantID,+ KnowledgeIDs: knowledgeIDs,+ Initiator: types.TaskInitiatorFromContext(ctx),}langfuse.InjectTracing(ctx, &payload)payloadBytes, err := json.Marshal(payload)@@ -476,6 +483,10 @@ func (s *knowledgeTagService) FindOrCreateTagByName(ctx context.Context, kbID stif err != nil {return nil, err}+ ctx, err = requireKBWrite(ctx, kb)+ if err != nil {+ return nil, err+ }tenantID := kb.TenantIDdiff --git a/internal/application/service/tag_access.go b/internal/application/service/tag_access.gonew file mode 100644index 000000000..edf7e4c75--- /dev/null+++ b/internal/application/service/tag_access.go@@ -0,0 +1,60 @@+package service++import (+ "context"++ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+)++func (s *knowledgeTagService) requireTagWrite(+ ctx context.Context,+ tag *types.KnowledgeTag,+) (*types.KnowledgeBase, context.Context, error) {+ if tag == nil {+ return nil, ctx, apperrors.NewNotFoundError("标签不存在")+ }+ kb, err := s.kbService.GetKnowledgeBaseByID(ctx, tag.KnowledgeBaseID)+ if err != nil {+ return nil, ctx, err+ }+ if kb == nil || kb.ID != tag.KnowledgeBaseID || kb.TenantID != tag.TenantID {+ return nil, ctx, apperrors.NewForbiddenError("标签不属于当前知识库")+ }+ ctx, err = requireKBWrite(ctx, kb)+ return kb, ctx, err+}++func (s *knowledgeTagService) validateTagDeleteExclusions(+ ctx context.Context,+ kb *types.KnowledgeBase,+ ids []string,+) error {+ if len(ids) == 0 {+ return nil+ }+ if kb.Type != types.KnowledgeBaseTypeFAQ {+ return apperrors.NewBadRequestError("仅 FAQ 条目删除支持排除条目")+ }+ wanted := make(map[string]bool, len(ids))+ for _, id := range ids {+ wanted[id] = true+ }+ chunks, err := s.chunkRepo.ListChunksByID(ctx, kb.TenantID, ids)+ if err != nil {+ return err+ }+ for _, chunk := range chunks {+ if chunk == nil || !wanted[chunk.ID] {+ continue+ }+ if chunk.TenantID != kb.TenantID || chunk.KnowledgeBaseID != kb.ID || chunk.ChunkType != types.ChunkTypeFAQ {+ return apperrors.NewForbiddenError("排除条目不属于当前知识库")+ }+ delete(wanted, chunk.ID)+ }+ if len(wanted) != 0 {+ return apperrors.NewNotFoundError("排除条目不存在")+ }+ return nil+}diff --git a/internal/application/service/web_search_state.go b/internal/application/service/web_search_state.goindex 811458cb0..00221cfc5 100644--- a/internal/application/service/web_search_state.go+++ b/internal/application/service/web_search_state.go@@ -121,7 +121,7 @@ func (s *webSearchStateService) DeleteWebSearchTempKBState(ctx context.Context,// Delete all knowledge itemsfor _, kid := range state.KnowledgeIDs {- if delErr := s.knowledgeService.DeleteKnowledge(ctx, kid); delErr != nil {+ if delErr := deleteReferencedKnowledge(ctx, s.knowledgeService, state.KBID, []string{kid}); delErr != nil {logger.Warnf(ctx, "Failed to delete temp knowledge %s: %v", kid, delErr)}}diff --git a/internal/application/service/wiki_ingest.go b/internal/application/service/wiki_ingest.goindex eb03de4a3..685221fd7 100644--- a/internal/application/service/wiki_ingest.go+++ b/internal/application/service/wiki_ingest.go@@ -600,12 +600,18 @@ func enqueueWikiIngestTrigger(// because there is no "user upload arriving in waves" pattern to// debounce against — a deletion fires once and we want the cleanup// to land promptly.-func EnqueueWikiRetract(+func EnqueueWikiRetract(ctx context.Context, task interfaces.TaskEnqueuer,+ pendingRepo interfaces.TaskPendingOpsRepository, payload WikiRetractPayload,+) {+ _ = enqueueWikiRetract(ctx, task, pendingRepo, payload)+}++func enqueueWikiRetract(ctx context.Context,task interfaces.TaskEnqueuer,pendingRepo interfaces.TaskPendingOpsRepository,payload WikiRetractPayload,-) {+) error {op := WikiPendingOp{Op: WikiOpRetract,KnowledgeID: payload.KnowledgeID,@@ -618,7 +624,7 @@ func EnqueueWikiRetract(payloadBytes, err := json.Marshal(op)if err != nil {logger.Warnf(ctx, "wiki retract: failed to marshal pending op: %v", err)- return+ return err}accepted, err := enqueueWikiPendingOp(ctx, pendingRepo, &types.TaskPendingOp{TenantID: payload.TenantID,@@ -631,11 +637,11 @@ func EnqueueWikiRetract(})if err != nil {logger.Warnf(ctx, "wiki retract: failed to enqueue pending op: %v", err)- return+ return err}if !accepted {logger.Infof(ctx, "wiki retract: skip enqueue for deleted KB %s", payload.KnowledgeBaseID)- return+ return nil}trigger := WikiIngestPayload{@@ -653,7 +659,9 @@ func EnqueueWikiRetract()if _, err := task.Enqueue(t); err != nil {logger.Warnf(ctx, "wiki retract: failed to enqueue trigger task: %v", err)+ return err}+ return nil}// Handle implements interfaces.TaskHandler for asynq task processing. Thediff --git a/internal/filetransport/response.go b/internal/filetransport/response.gonew file mode 100644index 000000000..4327fdead--- /dev/null+++ b/internal/filetransport/response.go@@ -0,0 +1,70 @@+// Package filetransport streams already-authorized files. It performs no+// resource lookup or permission inference; callers own those boundaries.+package filetransport++import (+ "io"+ "mime"+ "net/http"+ "path/filepath"+ "strconv"+ "time"++ secutils "github.com/Tencent/WeKnora/internal/utils"+)++// Options defines response metadata for an already-authorized reader.+type Options struct {+ Filename string+ Download bool+ ContentType string+ Disposition string+ CacheControl string+ Size int64+}++// Serve closes reader on every path. Seekable backends support standard Range+// and HEAD via ServeContent; streaming-only backends return the full response+// without buffering the object just to implement seeking (RFC 9110 section 14.2).+func Serve(w http.ResponseWriter, r *http.Request, reader io.ReadCloser, options Options) error {+ defer func() { _ = reader.Close() }()+ contentType, inline := secutils.SafeContentTypeByFilename(options.Filename)+ if options.Download {+ inline = false+ }+ if options.ContentType != "" {+ contentType = options.ContentType+ }+ w.Header().Set("Content-Type", contentType)+ w.Header().Set("X-Content-Type-Options", "nosniff")+ disposition := "attachment"+ if inline {+ disposition = "inline"+ }+ if options.Disposition != "" {+ w.Header().Set("Content-Disposition", options.Disposition)+ } else if options.Filename != "" {+ w.Header().Set("Content-Disposition",+ mime.FormatMediaType(disposition,+ map[string]string{"filename": filepath.Base(options.Filename)}))+ } else {+ w.Header().Set("Content-Disposition", disposition)+ }+ if options.CacheControl != "" {+ w.Header().Set("Cache-Control", options.CacheControl)+ }+ if seeker, ok := reader.(io.ReadSeeker); ok {+ http.ServeContent(w, r, options.Filename, time.Time{}, seeker)+ return nil+ }+ w.Header().Set("Accept-Ranges", "none")+ if options.Size > 0 {+ w.Header().Set("Content-Length", strconv.FormatInt(options.Size, 10))+ }+ w.WriteHeader(http.StatusOK)+ if r.Method == http.MethodHead {+ return nil+ }+ _, err := io.Copy(w, reader)+ return err+}diff --git a/internal/filetransport/response_test.go b/internal/filetransport/response_test.gonew file mode 100644index 000000000..776425599--- /dev/null+++ b/internal/filetransport/response_test.go@@ -0,0 +1,77 @@+package filetransport++import (+ "bytes"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/stretchr/testify/require"+)++type seekFile struct {+ *bytes.Reader+ closed bool+}++func (f *seekFile) Close() error { f.closed = true; return nil }++func TestServeSeekableFile(t *testing.T) {+ for _, tt := range []struct {+ name, method, rangeHeader, body string+ status int+ }{+ {"whole", "GET", "", "0123456789", 200},+ {"range", "GET", "bytes=2-5", "2345", 206},+ {"suffix", "GET", "bytes=-3", "789", 206},+ {"head", "HEAD", "", "", 200},+ {"unsatisfiable", "GET", "bytes=20-30", "", 416},+ } {+ t.Run(tt.name, func(t *testing.T) {+ reader := &seekFile{Reader: bytes.NewReader([]byte("0123456789"))}+ req := httptest.NewRequest(tt.method, "/file", nil)+ req.Header.Set("Range", tt.rangeHeader)+ w := httptest.NewRecorder()+ require.NoError(t, Serve(w, req, reader, Options{Filename: "image.png", CacheControl: "private, no-store"}))+ require.Equal(t, tt.status, w.Code)+ if tt.status != 416 {+ require.Equal(t, tt.body, w.Body.String())+ }+ require.True(t, reader.closed)+ require.Equal(t, "nosniff", w.Header().Get("X-Content-Type-Options"))+ if tt.status == 206 {+ require.Contains(t, w.Header().Get("Content-Range"), "/10")+ }+ })+ }+}++type streamFile struct{ read, closed bool }++func (f *streamFile) Read([]byte) (int, error) { f.read = true; return 0, io.EOF }+func (f *streamFile) Close() error { f.closed = true; return nil }++func TestServeStreamingHEADClosesWithoutReading(t *testing.T) {+ reader := &streamFile{}+ w := httptest.NewRecorder()+ require.NoError(+ t,+ Serve(w, httptest.NewRequest("HEAD", "/file", nil), reader, Options{Filename: "a.pdf", Size: 123}),+ )+ require.False(t, reader.read)+ require.True(t, reader.closed)+ require.Equal(t, "123", w.Header().Get("Content-Length"))+}++func TestServeActiveContentAndStreamingRange(t *testing.T) {+ w := httptest.NewRecorder()+ req := httptest.NewRequest(http.MethodGet, "/file", nil)+ req.Header.Set("Range", "bytes=0-1")+ require.NoError(t, Serve(w, req, io.NopCloser(strings.NewReader("<svg/>")), Options{Filename: "../payload.svg"}))+ require.Equal(t, http.StatusOK, w.Code, "non-seekable readers return the complete body")+ require.Equal(t, "<svg/>", w.Body.String())+ require.Equal(t, "none", w.Header().Get("Accept-Ranges"))+ require.Equal(t, "attachment; filename=payload.svg", w.Header().Get("Content-Disposition"))+}diff --git a/internal/handler/chunk.go b/internal/handler/chunk.goindex dd832146d..162bc9523 100644--- a/internal/handler/chunk.go+++ b/internal/handler/chunk.go@@ -231,7 +231,12 @@ func (h *ChunkHandler) UpdateChunk(c *gin.Context) {c.Error(errors.NewConflictError("Chunk was modified by another user; refresh and retry"))return}- c.Error(errors.NewInternalServerError(err.Error()))+ var appErr *errors.AppError+ if stderrors.As(err, &appErr) {+ _ = c.Error(appErr)+ } else {+ _ = c.Error(errors.NewInternalServerError(err.Error()))+ }return}@@ -289,7 +294,12 @@ func (h *ChunkHandler) RevertChunk(c *gin.Context) {return}if err != nil {- c.Error(errors.NewBadRequestError(err.Error()))+ var appErr *errors.AppError+ if stderrors.As(err, &appErr) {+ _ = c.Error(appErr)+ } else {+ _ = c.Error(errors.NewBadRequestError(err.Error()))+ }return}knowledge, getErr := h.kgService.GetKnowledgeByID(c.Request.Context(), knowledgeID)diff --git a/internal/handler/document_write_scope_test.go b/internal/handler/document_write_scope_test.gonew file mode 100644index 000000000..370ce48ac--- /dev/null+++ b/internal/handler/document_write_scope_test.go@@ -0,0 +1,99 @@+package handler++import (+ "context"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin"+ "github.com/hibiken/asynq"+ "github.com/stretchr/testify/require"+)++type documentWriteHandlerKnowledge struct {+ interfaces.KnowledgeService+ called bool+}++func (*documentWriteHandlerKnowledge) GetKnowledgeByIDOnly(context.Context, string) (*types.Knowledge, error) {+ return &types.Knowledge{ID: "doc", TenantID: 7, KnowledgeBaseID: "kb"}, nil+}++func (s *documentWriteHandlerKnowledge) UpdateKnowledgeTagBatch(+ ctx context.Context,+ kb string,+ _ map[string][]string,+) error {+ if err := access.RequireKBWrite(ctx, &types.KnowledgeBase{ID: kb, TenantID: 7}); err != nil {+ return err+ }+ s.called = true+ return nil+}++type documentDeleteEnqueuer struct{ task *asynq.Task }++func (q *documentDeleteEnqueuer) Enqueue(task *asynq.Task, _ ...asynq.Option) (*asynq.TaskInfo, error) {+ q.task = task+ return &asynq.TaskInfo{ID: "delete-task"}, nil+}++func documentHandlerRouter() *gin.Engine {+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ ctx := types.WithCaller(+ c.Request.Context(),+ types.Caller{TenantID: 7, UserID: "user", Role: types.TenantRoleAdmin},+ )+ ctx = types.WithExecutionTenant(ctx, 7)+ c.Set(types.TenantIDContextKey.String(), uint64(7))+ c.Request = c.Request.WithContext(ctx)+ c.Next()+ })+ return r+}++func TestDocumentTagBodyRouteIssuesWriteGrant(t *testing.T) {+ for _, body := range []string{`{"kb_id":"kb","updates":{"doc":["tag"]}}`, `{"updates":{"doc":["tag"]}}`} {+ t.Run(body, func(t *testing.T) {+ kg := &documentWriteHandlerKnowledge{}+ h := &KnowledgeHandler{+ kgService: kg,+ kbService: &stubKBService{get: func(context.Context, string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: "kb", TenantID: 7}, nil+ }},+ }+ r := documentHandlerRouter()+ r.PUT("/tags", h.UpdateKnowledgeTagBatch)+ req := httptest.NewRequest(http.MethodPut, "/tags", strings.NewReader(body))+ req.Header.Set("Content-Type", "application/json")+ w := httptest.NewRecorder()+ r.ServeHTTP(w, req)+ require.Equal(t, 200, w.Code, w.Body.String())+ require.True(t, kg.called)+ })+ }+}++func TestSingleDocumentDeletePersistsAuthorizedKBInTask(t *testing.T) {+ q := &documentDeleteEnqueuer{}+ h := &KnowledgeHandler{kgService: &documentWriteHandlerKnowledge{}, asynqClient: q}+ r := documentHandlerRouter()+ r.DELETE("/:id", h.DeleteKnowledge)+ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodDelete, "/doc", nil))+ require.Equal(t, 200, w.Code, w.Body.String())+ require.NotNil(t, q.task)+ var payload types.KnowledgeListDeletePayload+ require.NoError(t, json.Unmarshal(q.task.Payload(), &payload))+ require.Equal(t, uint64(7), payload.TenantID)+ require.Equal(t, "kb", payload.KnowledgeBaseID)+ require.Equal(t, []string{"doc"}, payload.KnowledgeIDs)+}diff --git a/internal/handler/kb_access.go b/internal/handler/kb_access.gonew file mode 100644index 000000000..6cc1a4e1f--- /dev/null+++ b/internal/handler/kb_access.go@@ -0,0 +1,81 @@+package handler++import (+ stderrors "errors"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/repository"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin"+)++// resolvedKBAccess reuses only a grant for this caller and this resource. A+// Viewer grant cannot satisfy an Editor check after the tenant context switches.+func resolvedKBAccess(c *gin.Context, kbID string, required types.OrgMemberRole) (*access.KBAccess, bool) {+ grant, ok := middleware.KBAccessFromContext(c)+ return grant, ok && grant.KnowledgeBase != nil && grant.KnowledgeBase.ID == kbID &&+ grant.Caller == middleware.KBAccessRequest(c).Caller &&+ access.HasKBGrant(grant.WithGrant(c.Request.Context()), kbID, grant.EffectiveTenantID, required)+}++// resolveHandlerKBAccess is also used by body/query-based endpoints that cannot+// resolve a single KB in route middleware. It always enforces access, preserving+// the handler checks even when the middleware's RBAC rollout flag is disabled.+func resolveHandlerKBAccess(c *gin.Context, kbID string, kbService middleware.KBLookup,+ shares interfaces.KBShareService, agents interfaces.AgentShareService,+) (*access.KBAccess, error) {+ return resolveHandlerKBAccessFor(c, kbID, kbService, shares, agents, types.OrgRoleViewer)+}++func resolveHandlerKBAccessFor(c *gin.Context, kbID string, kbService middleware.KBLookup,+ shares interfaces.KBShareService, agents interfaces.AgentShareService, required types.OrgMemberRole,+) (*access.KBAccess, error) {+ ctx := c.Request.Context()+ request := middleware.KBAccessRequest(c)+ if request.Caller.TenantID == 0 {+ return nil, apperrors.NewUnauthorizedError("Unauthorized")+ }+ if kbID == "" {+ return nil, apperrors.NewBadRequestError("Knowledge base ID cannot be empty")+ }+ if err := requireTenantAPIKeyKnowledgeBase(ctx, kbID); err != nil {+ return nil, err+ }+ if grant, ok := resolvedKBAccess(c, kbID, required); ok {+ return grant, nil+ }+ kb, err := kbService.GetKnowledgeBaseByID(ctx, kbID)+ if err != nil {+ if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) {+ return nil, apperrors.NewNotFoundError("knowledge base not found")+ }+ logger.ErrorWithFields(ctx, err, nil)+ return nil, apperrors.NewInternalServerError(err.Error())+ }+ grant, err := access.ResolveKB(ctx, request, kb, required, shares, agents)+ if err == nil {+ // Preserve authorization for body-based routes without changing the+ // execution tenant until the handler performs its resource operation.+ c.Request = c.Request.WithContext(grant.WithGrant(ctx))+ }+ return grant, kbAccessHTTPError(err)+}++func kbAccessHTTPError(err error) error {+ switch {+ case stderrors.Is(err, access.ErrUnauthorized):+ return apperrors.NewUnauthorizedError("Unauthorized")+ case stderrors.Is(err, access.ErrNotFound):+ return apperrors.NewNotFoundError("knowledge base not found")+ case stderrors.Is(err, access.ErrForbidden):+ return apperrors.NewForbiddenError("Permission denied to access this knowledge base")+ case stderrors.Is(err, access.ErrInvalidAgentSource):+ return apperrors.NewBadRequestError("invalid agent_source_tenant_id")+ default:+ return err+ }+}diff --git a/internal/handler/kb_access_test.go b/internal/handler/kb_access_test.gonew file mode 100644index 000000000..2ad4ae39d--- /dev/null+++ b/internal/handler/kb_access_test.go@@ -0,0 +1,229 @@+package handler++import (+ "context"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/Tencent/WeKnora/internal/config"+ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++type handlerKBShareStub struct {+ interfaces.KBShareService+ calls int+ caller uint64+}++func (s *handlerKBShareStub) CheckTenantKBPermission(+ _ context.Context,+ _ string,+ caller uint64,+ _ types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ s.calls+++ s.caller = caller+ return types.OrgRoleViewer, true, nil+}++type handlerKnowledgeAccessStub struct {+ interfaces.KnowledgeService+ knowledge *types.Knowledge+}++func (s *handlerKnowledgeAccessStub) GetKnowledgeByIDOnly(context.Context, string) (*types.Knowledge, error) {+ return s.knowledge, nil+}++func TestKBGuardAndHandlersShareResolution(t *testing.T) {+ gin.SetMode(gin.TestMode)+ for _, ginCallerKey := range []bool{true, false} {+ name := "request context only"+ if ginCallerKey {+ name = "both context surfaces"+ }+ t.Run(name, func(t *testing.T) {+ kb := &types.KnowledgeBase{ID: "kb", TenantID: 2}+ lookups := 0+ svc := &stubKBOnlyService{getByID: func(context.Context, string) (*types.KnowledgeBase, error) {+ lookups+++ return kb, nil+ }}+ shares := &handlerKBShareStub{}+ kg := &handlerKnowledgeAccessStub{+ knowledge: &types.Knowledge{ID: "doc", KnowledgeBaseID: "kb", TenantID: 2},+ }+ h := &KnowledgeHandler{kbService: svc, kgService: kg, kbShareService: shares}+ kbHandler := &KnowledgeBaseHandler{service: svc, kbShareService: shares}+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ ctx := context.WithValue(c.Request.Context(), types.TenantIDContextKey, uint64(1))+ ctx = context.WithValue(ctx, types.TenantRoleContextKey, types.TenantRoleViewer)+ c.Request = c.Request.WithContext(ctx)+ if ginCallerKey {+ c.Set(types.TenantIDContextKey.String(), uint64(1))+ }+ c.Next()+ })+ enabled := true+ r.GET("/:id", middleware.RequireKBAccess(+ middleware.KBIDFromParam("id"),+ types.OrgRoleViewer,+ svc,+ shares,+ nil,+ &config.Config{Tenant: &config.TenantConfig{EnableRBAC: &enabled}},+ ), func(c *gin.Context) {+ _, _, effective, permission, err := kbHandler.validateAndGetKnowledgeBase(c)+ require.NoError(t, err)+ require.Equal(t, uint64(2), effective)+ require.Equal(t, types.OrgRoleViewer, permission)+ _, _, _, permission, err = h.validateKnowledgeBaseAccess(c)+ require.NoError(t, err)+ require.Equal(t, types.OrgRoleViewer, permission)+ _, ctx, err := h.resolveKnowledgeAndValidateKBAccess(c, "doc", types.OrgRoleViewer)+ require.NoError(t, err)+ require.Equal(t, uint64(2), types.MustTenantIDFromContext(ctx))+ require.Equal(t, uint64(1), types.CallerFromContext(ctx).TenantID)+ require.Equal(t, 1, lookups, "handlers must reuse the guarded KB")+ require.Equal(t, 1, shares.calls, "handlers must reuse the permission decision")+ // The effective tenant is 2, but the write must still be checked+ // as caller 1 and rejected, not upgraded to resource ownership.+ _, _, err = h.resolveKnowledgeAndValidateKBAccess(c, "doc", types.OrgRoleEditor)+ require.Error(t, err)+ require.Equal(t, uint64(1), shares.caller)+ c.Status(http.StatusNoContent)+ })+ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/kb", nil))+ require.Equal(t, http.StatusNoContent, w.Code, w.Body.String())+ })+ }+}++func TestKBHandlerDoesNotReuseGrantForAnotherResourceOrCaller(t *testing.T) {+ gin.SetMode(gin.TestMode)+ for _, tt := range []struct {+ name, requestedID string+ caller uint64+ }{+ {name: "another KB", requestedID: "other", caller: 1},+ {name: "another caller", requestedID: "kb", caller: 3},+ } {+ t.Run(tt.name, func(t *testing.T) {+ c, _ := gin.CreateTestContext(httptest.NewRecorder())+ c.Request = httptest.NewRequest(http.MethodGet, "/", nil)+ c.Set(types.TenantIDContextKey.String(), tt.caller)+ c.Set(middleware.KBAccessContextKey, &middleware.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{ID: "kb", TenantID: 2},+ Caller: types.Caller{+ TenantID: 1,+ Role: types.TenantRoleViewer,+ }, EffectiveTenantID: 2, Permission: types.OrgRoleAdmin,+ })+ svc := &stubKBOnlyService{getByID: func(context.Context, string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: tt.requestedID, TenantID: 2}, nil+ }}+ _, err := resolveHandlerKBAccess(c, tt.requestedID, svc, nil, nil)+ require.Error(t, err)+ })+ }+}++func TestKBHandlerAPIKeyScopeStillAppliesToCachedGrant(t *testing.T) {+ c, _ := gin.CreateTestContext(httptest.NewRecorder())+ ctx := types.WithTenantAPIKeyScope(+ context.Background(),+ types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"other"}},+ )+ c.Request = httptest.NewRequest(http.MethodGet, "/", nil).WithContext(ctx)+ c.Set(types.TenantIDContextKey.String(), uint64(1))+ c.Set(middleware.KBAccessContextKey, &middleware.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{ID: "kb", TenantID: 1},+ Caller: types.Caller{+ TenantID: 1,+ Role: types.TenantRoleViewer,+ }, EffectiveTenantID: 1, Permission: types.OrgRoleAdmin,+ })+ _, err := resolveHandlerKBAccess(c, "kb", nil, nil, nil)+ require.Error(t, err)+}++type handlerAgentAccessStub struct {+ interfaces.AgentShareService+ anyCalls int+}++func (s *handlerAgentAccessStub) GetSharedAgentForTenant(+ context.Context,+ uint64,+ types.TenantRole,+ string,+ ...uint64,+) (*types.CustomAgent, error) {+ return &types.CustomAgent{TenantID: 2, Config: types.CustomAgentConfig{KBSelectionMode: "none"}}, nil+}++func (s *handlerAgentAccessStub) TenantCanAccessKBViaSomeSharedAgent(+ context.Context,+ uint64,+ types.TenantRole,+ *types.KnowledgeBase,+) (bool, error) {+ s.anyCalls+++ return true, nil+}++func TestKBHandlersHonorExplicitAgentWithoutRouteGuard(t *testing.T) {+ for _, query := range []string{"", "?agent_id=restricted"} {+ t.Run(query, func(t *testing.T) {+ c, _ := gin.CreateTestContext(httptest.NewRecorder())+ c.Request = httptest.NewRequest(http.MethodGet, "/kb"+query, nil)+ c.Set(types.TenantIDContextKey.String(), uint64(1))+ c.Params = gin.Params{{Key: "id", Value: "kb"}}+ svc := &stubKBOnlyService{getByID: func(context.Context, string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: "kb", TenantID: 2}, nil+ }}+ agents := &handlerAgentAccessStub{}+ h := &KnowledgeHandler{kbService: svc, agentShareService: agents}+ kbHandler := &KnowledgeBaseHandler{service: svc, agentShareService: agents}+ _, _, _, _, kbErr := kbHandler.validateAndGetKnowledgeBase(c)+ _, _, _, _, knowledgeErr := h.validateKnowledgeBaseAccessWithKBID(c, "kb")+ if query == "" {+ require.NoError(t, kbErr)+ require.NoError(t, knowledgeErr)+ require.Equal(t, 2, agents.anyCalls)+ } else {+ require.Error(t, kbErr)+ require.Error(t, knowledgeErr)+ require.Zero(t, agents.anyCalls)+ }+ })+ }+}++func TestKBHandlerEnforcesAccessWhenRouteRBACIsDisabled(t *testing.T) {+ svc := &stubKBOnlyService{getByID: func(context.Context, string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: "kb", TenantID: 2}, nil+ }}+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ c.Set(types.TenantIDContextKey.String(), uint64(1))+ c.Next()+ })+ disabled := false+ r.GET("/:id", middleware.RequireKBAccess(middleware.KBIDFromParam("id"), types.OrgRoleViewer,+ svc, nil, nil, &config.Config{Tenant: &config.TenantConfig{EnableRBAC: &disabled}}), func(c *gin.Context) {+ _, err := resolveHandlerKBAccess(c, c.Param("id"), svc, nil, nil)+ require.Error(t, err)+ _ = c.Error(err)+ })+ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/kb", nil))+ require.Equal(t, http.StatusForbidden, w.Code)+}diff --git a/internal/handler/knowledge.go b/internal/handler/knowledge.goindex 68f98f605..058202233 100644--- a/internal/handler/knowledge.go+++ b/internal/handler/knowledge.go@@ -3,21 +3,18 @@ package handlerimport ("context""encoding/json"+ goerrors "errors""fmt"- "io"- "mime""net/http""strconv""strings""time"- goerrors "errors"-- "github.com/Tencent/WeKnora/internal/agent/tools"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/application/repository"- "github.com/Tencent/WeKnora/internal/application/service""github.com/Tencent/WeKnora/internal/config""github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/filetransport""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/middleware""github.com/Tencent/WeKnora/internal/tracing/langfuse"@@ -64,13 +61,11 @@ func NewKnowledgeHandler(// requireKBOwnershipOrAdmin enforces the same "KB creator OR Admin+" matrix// used by OwnedKBOrAdmin for routes whose KB id comes from the request body.func (h *KnowledgeHandler) requireKBOwnershipOrAdmin(c *gin.Context, kbID string) error {- creator, err := resolveKBCreatorByKBID(c, h.kbService, kbID)evalErr := middleware.EvaluateOwnershipOrRole(c.Request.Context(),h.cfg,types.TenantRoleAdmin,- creator,- err,+ func() (string, error) { return resolveKBCreatorByKBID(c, h.kbService, kbID) },)if evalErr == nil {return nil@@ -97,133 +92,74 @@ func (h *KnowledgeHandler) validateKnowledgeBaseAccess(c *gin.Context) (*types.K// validateKnowledgeBaseAccessWithKBID validates access to the given knowledge base ID (e.g. from query or body).// Enforces per-API-key KB scope before tenant/share/agent resolution.// Returns the knowledge base, kbID, effective tenant ID, permission, and error.-func (h *KnowledgeHandler) validateKnowledgeBaseAccessWithKBID(c *gin.Context, kbID string) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {- ctx := c.Request.Context()- tenantID := c.GetUint64(types.TenantIDContextKey.String())- if tenantID == 0 {- logger.Error(ctx, "Failed to get tenant ID")- return nil, "", 0, "", errors.NewUnauthorizedError("Unauthorized")- }- userID, userExists := c.Get(types.UserIDContextKey.String())- callerTenantRole := types.TenantRoleFromContext(ctx)+func (h *KnowledgeHandler) validateKnowledgeBaseAccessWithKBID(+ c *gin.Context,+ kbID string,+) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {kbID = secutils.SanitizeForLog(kbID)- if kbID == "" {- return nil, "", 0, "", errors.NewBadRequestError("Knowledge base ID cannot be empty")- }- if err := requireTenantAPIKeyKnowledgeBase(ctx, kbID); err != nil {+ grant, err := resolveHandlerKBAccess(c, kbID, h.kbService, h.kbShareService, h.agentShareService)+ if err != nil {return nil, kbID, 0, "", err}- kb, err := h.kbService.GetKnowledgeBaseByID(ctx, kbID)+ return grant.KnowledgeBase, kbID, grant.EffectiveTenantID, grant.Permission, nil+}++func (h *KnowledgeHandler) validateKnowledgeBaseWriteAccessWithKBID(+ c *gin.Context,+ kbID string,+) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {+ grant, err := resolveHandlerKBAccessFor(+ c,+ kbID,+ h.kbService,+ h.kbShareService,+ h.agentShareService,+ types.OrgRoleEditor,+ )if err != nil {- // Same not-found-vs-real-error split as knowledgebase.go's- // validateAndGetKnowledgeBase: ErrKnowledgeBaseNotFound is the- // expected outcome for a probed/stale kb id and must surface as- // 404, not the generic 500 the original code produced.- if goerrors.Is(err, repository.ErrKnowledgeBaseNotFound) {- return nil, kbID, 0, "", errors.NewNotFoundError("knowledge base not found")- }- logger.ErrorWithFields(ctx, err, nil)- return nil, kbID, 0, "", errors.NewInternalServerError(err.Error())- }- if kb.TenantID == tenantID {- return kb, kbID, tenantID, types.OrgRoleAdmin, nil- }- if h.kbShareService != nil {- permission, isShared, permErr := h.kbShareService.CheckTenantKBPermission(ctx, kbID, tenantID, callerTenantRole)- if permErr == nil && isShared {- sourceTenantID, srcErr := h.kbShareService.GetKBSourceTenant(ctx, kbID)- if srcErr == nil {- logger.Infof(ctx, "Tenant %d accessing shared KB %s with permission %s, source tenant: %d",- tenantID, kbID, permission, sourceTenantID)- return kb, kbID, sourceTenantID, permission, nil- }- }+ return nil, kbID, 0, "", err}- if h.agentShareService != nil {- can, err := h.agentShareService.TenantCanAccessKBViaSomeSharedAgent(ctx, tenantID, callerTenantRole, kb)- if err == nil && can {- logger.Infof(ctx, "Tenant %d accessing KB %s via some shared agent", tenantID, kbID)- return kb, kbID, kb.TenantID, types.OrgRoleViewer, nil- }+ if err := access.RequireKBWrite(grant.Context(c.Request.Context()), grant.KnowledgeBase); err != nil {+ return nil, kbID, 0, "", kbAccessHTTPError(err)}- _ = userID- _ = userExists- logger.Warnf(ctx, "Permission denied to access KB %s, tenant ID: %d, KB tenant: %d", kbID, tenantID, kb.TenantID)- return nil, kbID, 0, "", errors.NewForbiddenError("Permission denied to access this knowledge base")+ return grant.KnowledgeBase, kbID, grant.EffectiveTenantID, grant.Permission, nil}-// resolveKnowledgeAndValidateKBAccess resolves knowledge by ID and validates KB access (owner or shared with required permission).-// Returns the knowledge, context with effectiveTenantID set for downstream service calls, and error.-func (h *KnowledgeHandler) resolveKnowledgeAndValidateKBAccess(c *gin.Context, knowledgeID string, requiredPermission types.OrgMemberRole) (*types.Knowledge, context.Context, error) {+// resolveKnowledgeAndValidateKBAccess resolves a document and checks its parent+// KB using the same policy as KB routes. The persisted document supplies the KB+// and owner reference, so unguarded callers do not need an additional KB lookup.+func (h *KnowledgeHandler) resolveKnowledgeAndValidateKBAccess(+ c *gin.Context,+ knowledgeID string,+ requiredPermission types.OrgMemberRole,+) (*types.Knowledge, context.Context, error) {ctx := c.Request.Context()- tenantID := c.GetUint64(types.TenantIDContextKey.String())- if tenantID == 0 {+ request := middleware.KBAccessRequest(c)+ if request.Caller.TenantID == 0 {return nil, ctx, errors.NewUnauthorizedError("Unauthorized")}- userID, userExists := c.Get(types.UserIDContextKey.String())- callerTenantRole := types.TenantRoleFromContext(ctx)-knowledge, err := h.kgService.GetKnowledgeByIDOnly(ctx, knowledgeID)- if err != nil {+ if err != nil || knowledge == nil {return nil, ctx, errors.NewNotFoundError("Knowledge not found")}if err := requireTenantAPIKeyKnowledgeBase(ctx, knowledge.KnowledgeBaseID); err != nil {return nil, ctx, err}-- // Owner: knowledge belongs to caller's tenant- if knowledge.TenantID == tenantID {- return knowledge, context.WithValue(ctx, types.TenantIDContextKey, tenantID), nil- }-- // Shared KB: check organization permission- if h.kbShareService != nil {- permission, isShared, permErr := h.kbShareService.CheckTenantKBPermission(ctx, knowledge.KnowledgeBaseID, tenantID, callerTenantRole)- if permErr == nil && isShared && permission.HasPermission(requiredPermission) {- effectiveTenantID := knowledge.TenantID- return knowledge, context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID), nil+ if grant, ok := resolvedKBAccess(c, knowledge.KnowledgeBaseID, requiredPermission); ok {+ if grant.EffectiveTenantID != knowledge.TenantID {+ return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")}+ return knowledge, grant.Context(ctx), nil}- // Shared agent: request passes agent_id, or user has any shared agent that can access this KB- if h.agentShareService != nil && requiredPermission == types.OrgRoleViewer {- agentID := c.Query("agent_id")- if agentID != "" {- sourceTenantID, parseErr := types.ParseAgentSourceTenantID(c.Query(types.AgentSourceTenantIDParam))- if parseErr != nil {- return nil, ctx, errors.NewBadRequestError(parseErr.Error())- }- agent, err := h.agentShareService.GetSharedAgentForTenant(ctx, tenantID, callerTenantRole, agentID, sourceTenantID)- if err == nil && agent != nil {- if knowledge.TenantID != agent.TenantID {- return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")- }- mode := agent.Config.KBSelectionMode- if mode == "none" {- return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")- }- if mode == "all" {- return knowledge, context.WithValue(ctx, types.TenantIDContextKey, knowledge.TenantID), nil- }- if mode == "selected" {- for _, kbID := range agent.Config.KnowledgeBases {- if kbID == knowledge.KnowledgeBaseID {- return knowledge, context.WithValue(ctx, types.TenantIDContextKey, knowledge.TenantID), nil- }- }- return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")- }- }- } else {- kbRef := &types.KnowledgeBase{ID: knowledge.KnowledgeBaseID, TenantID: knowledge.TenantID}- can, err := h.agentShareService.TenantCanAccessKBViaSomeSharedAgent(ctx, tenantID, callerTenantRole, kbRef)- if err == nil && can {- return knowledge, context.WithValue(ctx, types.TenantIDContextKey, knowledge.TenantID), nil- }- }+ kb := &types.KnowledgeBase{ID: knowledge.KnowledgeBaseID, TenantID: knowledge.TenantID}+ grant, err := access.ResolveKB(ctx, request, kb, requiredPermission, h.kbShareService, h.agentShareService)+ if goerrors.Is(err, access.ErrForbidden) {+ return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")+ }+ if err != nil {+ return nil, ctx, kbAccessHTTPError(err)}- _ = userID- _ = userExists- return nil, ctx, errors.NewForbiddenError("Permission denied to access this knowledge")+ return knowledge, grant.Context(ctx), nil}// handleDuplicateKnowledgeError handles cases where duplicate knowledge is detected@@ -248,12 +184,13 @@ func (h *KnowledgeHandler) handleDuplicateKnowledgeError(c *gin.Context,// enqueueKnowledgeListDelete enqueues an async batch-delete task for the// given knowledge IDs and returns the asynq task ID.func (h *KnowledgeHandler) enqueueKnowledgeListDelete(- ctx context.Context, tenantID uint64, ids []string,+ ctx context.Context, tenantID uint64, kbID string, ids []string,) (string, error) {payload := types.KnowledgeListDeletePayload{- TenantID: tenantID,- KnowledgeIDs: ids,- Initiator: types.TaskInitiatorFromContext(ctx),+ KnowledgeBaseID: kbID,+ TenantID: tenantID,+ KnowledgeIDs: ids,+ Initiator: types.TaskInitiatorFromContext(ctx),}langfuse.InjectTracing(ctx, &payload)payloadBytes, err := json.Marshal(payload)@@ -272,13 +209,14 @@ func (h *KnowledgeHandler) enqueueKnowledgeListDelete(// enqueueKnowledgeListReparse enqueues an async batch-reparse task for the// given knowledge IDs and returns the asynq task ID.func (h *KnowledgeHandler) enqueueKnowledgeListReparse(- ctx context.Context, tenantID uint64, ids []string, processConfig *types.KnowledgeProcessOverrides,+ ctx context.Context, tenantID uint64, kbID string, ids []string, processConfig *types.KnowledgeProcessOverrides,) (string, error) {payload := types.KnowledgeListReparsePayload{- TenantID: tenantID,- KnowledgeIDs: ids,- ProcessConfig: processConfig,- Initiator: types.TaskInitiatorFromContext(ctx),+ KnowledgeBaseID: kbID,+ TenantID: tenantID,+ KnowledgeIDs: ids,+ ProcessConfig: processConfig,+ Initiator: types.TaskInitiatorFromContext(ctx),}langfuse.InjectTracing(ctx, &payload)payloadBytes, err := json.Marshal(payload)@@ -323,7 +261,7 @@ func (h *KnowledgeHandler) CreateKnowledgeFromFile(c *gin.Context) {c.Error(err)return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)// Check write permissionif permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {@@ -472,7 +410,7 @@ func (h *KnowledgeHandler) CreateKnowledgeFromURL(c *gin.Context) {c.Error(err)return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)// Check write permissionif permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {@@ -569,7 +507,7 @@ func (h *KnowledgeHandler) CreateManualKnowledge(c *gin.Context) {c.Error(err)return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)// Check write permissionif permission != types.OrgRoleAdmin && permission != types.OrgRoleEditor {@@ -955,7 +893,7 @@ func (h *KnowledgeHandler) ListKnowledge(c *gin.Context) {}// Update context with effective tenant ID for shared KB access- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)// Parse pagination parameters from query stringvar pagination types.Pagination@@ -1062,7 +1000,7 @@ func (h *KnowledgeHandler) ListKnowledgeFolders(c *gin.Context) {c.Error(err)return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)tree, err := h.kgService.ListKnowledgeFolderTree(ctx, kbID)if err != nil {@@ -1127,7 +1065,7 @@ func (h *KnowledgeHandler) MoveKnowledgeToFolder(c *gin.Context) {c.Error(err)return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)// Guard against cross-KB moves: the service layer scopes by tenant, so the// handler must confirm every entry belongs to the requested knowledge base.@@ -1186,7 +1124,7 @@ func (h *KnowledgeHandler) RenameKnowledgeFolder(c *gin.Context) {return}- _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccess(c)+ _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseWriteAccessWithKBID(c, c.Param("id"))if err != nil {c.Error(err)return@@ -1199,7 +1137,7 @@ func (h *KnowledgeHandler) RenameKnowledgeFolder(c *gin.Context) {c.Error(err)return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)affected, err := h.kgService.RenameKnowledgeFolder(ctx, kbID, req.From, req.To)if err != nil {@@ -1246,7 +1184,7 @@ func (h *KnowledgeHandler) requireKnowledgeWriteAccess(c *gin.Context,requestedKBID string,) (string, uint64, error) {- _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccessWithKBID(c, requestedKBID)+ _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseWriteAccessWithKBID(c, requestedKBID)if err != nil {return "", 0, err}@@ -1310,12 +1248,17 @@ func (h *KnowledgeHandler) DeleteKnowledge(c *gin.Context) {return}- _, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleEditor)+ knowledge, effCtx, err := h.resolveKnowledgeAndValidateKBAccess(c, id, types.OrgRoleEditor)if err != nil {c.Error(err)return}+ if err := access.RejectMovingKnowledge(knowledge); err != nil {+ _ = c.Error(err)+ return+ }+// Reuse the batch async pipeline so single-item delete shares the same// hardening (asynq retries, business-aware queue routing, marking-as-deleting// inside the worker) as BatchDeleteKnowledge / ClearKnowledgeBaseContents.@@ -1327,7 +1270,7 @@ func (h *KnowledgeHandler) DeleteKnowledge(c *gin.Context) {}logger.Infof(ctx, "Enqueuing knowledge delete, ID: %s", secutils.SanitizeForLog(id))- taskID, err := h.enqueueKnowledgeListDelete(effCtx, effectiveTenantID, []string{id})+ taskID, err := h.enqueueKnowledgeListDelete(effCtx, effectiveTenantID, knowledge.KnowledgeBaseID, []string{id})if err != nil {logger.Errorf(ctx, "Failed to enqueue knowledge delete task: %v", err)c.Error(errors.NewInternalServerError("Failed to enqueue delete task"))@@ -1384,7 +1327,7 @@ func (h *KnowledgeHandler) BatchDeleteKnowledge(c *gin.Context) {}// Validate KB access (editor or admin) using the kb_id from body.- _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccessWithKBID(c, req.KBID)+ _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseWriteAccessWithKBID(c, req.KBID)if err != nil {c.Error(err)return@@ -1397,11 +1340,10 @@ func (h *KnowledgeHandler) BatchDeleteKnowledge(c *gin.Context) {c.Error(err)return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)// Single batch fetch to validate that every id exists and belongs to the- // requested KB. The service-layer DeleteKnowledgeList only enforces tenant- // scope, not KB scope, so the handler must guard against cross-KB deletion.+ // requested KB before admitting a task with that exact KB scope.knowledgeList, err := h.kgService.GetKnowledgeBatch(ctx, effectiveTenantID, ids)if err != nil {logger.ErrorWithFields(ctx, err, nil)@@ -1413,6 +1355,10 @@ func (h *KnowledgeHandler) BatchDeleteKnowledge(c *gin.Context) {return}for _, k := range knowledgeList {+ if err := access.RejectMovingKnowledge(k); err != nil {+ _ = c.Error(err)+ return+ }if k.KnowledgeBaseID != kbID {c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge %s does not belong to knowledge base %s",@@ -1421,7 +1367,7 @@ func (h *KnowledgeHandler) BatchDeleteKnowledge(c *gin.Context) {}}- taskID, err := h.enqueueKnowledgeListDelete(ctx, effectiveTenantID, ids)+ taskID, err := h.enqueueKnowledgeListDelete(ctx, effectiveTenantID, kbID, ids)if err != nil {logger.Errorf(ctx, "Failed to enqueue batch knowledge delete task: %v", err)c.Error(errors.NewInternalServerError("Failed to enqueue batch delete task"))@@ -1458,7 +1404,7 @@ func (h *KnowledgeHandler) ClearKnowledgeBaseContents(c *gin.Context) {ctx := c.Request.Context()logger.Info(ctx, "Start clearing knowledge base contents")- kb, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccess(c)+ kb, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseWriteAccessWithKBID(c, c.Param("id"))if err != nil {c.Error(err)return@@ -1471,7 +1417,7 @@ func (h *KnowledgeHandler) ClearKnowledgeBaseContents(c *gin.Context) {return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)knowledgeList, err := h.kgService.ListKnowledgeByKnowledgeBaseID(ctx, kbID)if err != nil {@@ -1492,10 +1438,14 @@ func (h *KnowledgeHandler) ClearKnowledgeBaseContents(c *gin.Context) {knowledgeIDs := make([]string, 0, len(knowledgeList))for _, knowledge := range knowledgeList {+ if err := access.RejectMovingKnowledge(knowledge); err != nil {+ _ = c.Error(err)+ return+ }knowledgeIDs = append(knowledgeIDs, knowledge.ID)}- taskID, err := h.enqueueKnowledgeListDelete(ctx, effectiveTenantID, knowledgeIDs)+ taskID, err := h.enqueueKnowledgeListDelete(ctx, effectiveTenantID, kbID, knowledgeIDs)if err != nil {logger.Errorf(ctx, "Failed to enqueue knowledge list delete task: %v", err)c.Error(errors.NewInternalServerError("Failed to enqueue cleanup task"))@@ -1552,34 +1502,14 @@ func (h *KnowledgeHandler) DownloadKnowledgeFile(c *gin.Context) {c.Error(errors.NewInternalServerError("Failed to retrieve file").WithDetails(err.Error()))return}- defer file.Close()-- logger.Infof(- ctx,- "Knowledge file retrieved successfully, ID: %s, filename: %s",- secutils.SanitizeForLog(id),- secutils.SanitizeForLog(filename),- )-- // Set response headers for file downloadc.Header("Content-Description", "File Transfer")c.Header("Content-Transfer-Encoding", "binary")- cd := mime.FormatMediaType("attachment", map[string]string{"filename": filename})- c.Header("Content-Disposition", cd)- c.Header("Content-Type", "application/octet-stream")c.Header("Expires", "0")- c.Header("Cache-Control", "must-revalidate")- c.Header("Pragma", "public")-- // Stream file content to response- c.Stream(func(w io.Writer) bool {- if _, err := io.Copy(w, file); err != nil {- logger.Errorf(ctx, "Failed to send file: %v", err)- return false- }- logger.Debug(ctx, "File sending completed")- return false- })+ if err := filetransport.Serve(c.Writer, c.Request, file, filetransport.Options{+ Filename: filename, Download: true, ContentType: "application/octet-stream", CacheControl: "private, no-store",+ }); err != nil {+ logger.Errorf(ctx, "Failed to send file: %v", err)+ }}// mimeTypeByExt returns the MIME type for a given file extension.@@ -1621,25 +1551,11 @@ func (h *KnowledgeHandler) PreviewKnowledgeFile(c *gin.Context) {c.Error(errors.NewInternalServerError("Failed to retrieve file").WithDetails(err.Error()))return}- defer file.Close()-- contentType, inline := secutils.SafeContentTypeByFilename(filename)- c.Header("Content-Type", contentType)- c.Header("X-Content-Type-Options", "nosniff")- disposition := "inline"- if !inline {- disposition = "attachment"+ 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 preview: %v", err)}- c.Header("Content-Disposition", mime.FormatMediaType(disposition, map[string]string{"filename": filename}))- c.Header("Cache-Control", "private, max-age=3600")-- c.Stream(func(w io.Writer) bool {- if _, err := io.Copy(w, file); err != nil {- logger.Errorf(ctx, "Failed to stream preview: %v", err)- return false- }- return false- })}// GetKnowledgeBatchRequest defines parameters for batch knowledge retrieval@@ -1667,13 +1583,11 @@ type GetKnowledgeBatchRequest struct {func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {ctx := c.Request.Context()- tenantID, ok := c.Get(types.TenantIDContextKey.String())- if !ok {- logger.Error(ctx, "Failed to get tenant ID")+ effectiveTenantID := middleware.KBAccessRequest(c).Caller.TenantID+ if effectiveTenantID == 0 {c.Error(errors.NewUnauthorizedError("Unauthorized"))return}- effectiveTenantID := tenantID.(uint64)var req GetKnowledgeBatchRequestif err := c.ShouldBindQuery(&req); err != nil {@@ -1686,40 +1600,23 @@ func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {return}- // agentAllowedKBIDs restricts results to the agent's configured KB scope.- // nil = no agent restriction; empty slice = agent has no KB access (none mode).- var agentAllowedKBIDs []string-- // Optional agent_id: when using shared agent, resolve agent and use its tenant for batch retrieval (so shared KB files can be loaded after refresh)- if agentID := secutils.SanitizeForLog(req.AgentID); agentID != "" && h.agentShareService != nil {- userIDVal, ok := c.Get(types.UserIDContextKey.String())- if !ok {- c.Error(errors.NewUnauthorizedError("Unauthorized"))- return- }- userID, _ := userIDVal.(string)- currentTenantID := c.GetUint64(types.TenantIDContextKey.String())- if currentTenantID == 0 {- c.Error(errors.NewUnauthorizedError("Unauthorized"))- return- }- callerTenantRole := types.TenantRoleFromContext(ctx)- agent, err := h.agentShareService.GetSharedAgentForTenant(ctx, currentTenantID, callerTenantRole, agentID, req.AgentSourceTenantID)- if err != nil || agent == nil {- logger.Warnf(ctx, "GetKnowledgeBatch: invalid or inaccessible shared agent %s: %v", agentID, err)- c.Error(errors.NewForbiddenError("Invalid or inaccessible shared agent").WithDetails(err.Error()))+ // A nil scope means no agent selector. Every resolved scope, including+ // mode=all, binds results to the authorized agent's source tenant.+ var agentScope *types.SharedAgentKBScope+ if agentID := secutils.SanitizeForLog(req.AgentID); agentID != "" {+ agent, err := resolveSharedAgentForRequest(c, agentID, h.agentShareService)+ if err != nil {+ _ = c.Error(err)return}- _ = userID+ ctx = access.WithSharedAgent(ctx, agent)+ scope := types.NewSharedAgentKBScope(agent)+ agentScope = &scopeeffectiveTenantID = agent.TenantID- agentAllowedKBIDs = resolveAgentAllowedKBIDs(agent)-- if agentAllowedKBIDs != nil && len(agentAllowedKBIDs) == 0 {+ if scope.IsEmpty() {c.JSON(http.StatusOK, gin.H{"success": true, "data": []*types.Knowledge{}})return}- logger.Infof(ctx, "Batch retrieving knowledge with agent_id, effective tenant ID: %d, IDs count: %d, allowed KBs: %v",- effectiveTenantID, len(req.IDs), agentAllowedKBIDs)}var knowledges []*types.Knowledge@@ -1730,42 +1627,46 @@ func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {// Optional kb_id: validate KB access and use effective tenant for shared KBif kbID := secutils.SanitizeForLog(req.KBID); kbID != "" {- _, _, effID, _, err := h.validateKnowledgeBaseAccessWithKBID(c, kbID)- if err != nil {- c.Error(err)+ _, _, effID, _, accessErr := h.validateKnowledgeBaseAccessWithKBID(c, kbID)+ if accessErr != nil {+ _ = c.Error(accessErr)return}- if agentAllowedKBIDs != nil && !sliceContains(agentAllowedKBIDs, kbID) {+ if agentScope != nil && !agentScope.Allows(kbID, effID) {c.Error(errors.NewForbiddenError("Knowledge base not accessible through this agent"))return}scopeKBID = kbIDeffectiveTenantID = effID- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)logger.Infof(ctx, "Batch retrieving knowledge with kb_id, effective tenant ID: %d, IDs count: %d",effectiveTenantID, len(req.IDs))+ knowledges, err = h.kgService.GetKnowledgeBatch(ctx, effectiveTenantID, req.IDs)+ } else if agentScope != nil {+ // Keep the authorized agent's read scope and the original caller.+ ctx = types.WithExecutionTenant(ctx, effectiveTenantID)knowledges, err = h.kgService.GetKnowledgeBatch(ctx, effectiveTenantID, req.IDs)} else {- // No kb_id: use GetKnowledgeBatchWithSharedAccess (or effectiveTenantID may already be set by agent_id for shared agent)- logger.Infof(ctx, "Batch retrieving knowledge without kb_id, effective tenant ID: %d, IDs count: %d",- effectiveTenantID, len(req.IDs))-knowledges, err = h.kgService.GetKnowledgeBatchWithSharedAccess(ctx, effectiveTenantID, req.IDs)}+ if err != nil {+ logger.ErrorWithFields(ctx, err, nil)+ _ = c.Error(errors.NewInternalServerError("Failed to retrieve knowledge list").WithDetails(err.Error()))+ return+ }// Build the effective allowed-KB set from explicit kb_id, shared agent// scope, and per-API-key KB restrictions.var allowedKBSet map[string]boolif scopeKBID != "" {allowedKBSet = map[string]bool{scopeKBID: true}- } else if agentAllowedKBIDs != nil {- allowedKBSet = make(map[string]bool, len(agentAllowedKBIDs))- for _, id := range agentAllowedKBIDs {- allowedKBSet[id] = true- }}+ if agentScope != nil {+ knowledges = filterKnowledgeByAgentScope(knowledges, *agentScope)+ }+if apiKeySet := tenantAPIKeyAllowedKBSet(ctx); apiKeySet != nil {allowedKBSet = intersectKBAllowSet(allowedKBSet, apiKeySet)}@@ -1773,12 +1674,6 @@ func (h *KnowledgeHandler) GetKnowledgeBatch(c *gin.Context) {knowledges = filterKnowledgesByKBAllowSet(knowledges, allowedKBSet)}- if err != nil {- logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewInternalServerError("Failed to retrieve knowledge list").WithDetails(err.Error()))- return- }-logger.Infof(ctx, "Batch knowledge retrieval successful, requested count: %d, returned count: %d",len(req.IDs), len(knowledges))@@ -1842,7 +1737,12 @@ func (h *KnowledgeHandler) UpdateKnowledge(c *gin.Context) {if err := h.kgService.UpdateKnowledge(effCtx, &knowledge); err != nil {logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewInternalServerError(err.Error()))+ var appErr *errors.AppError+ if goerrors.As(err, &appErr) {+ _ = c.Error(appErr)+ } else {+ _ = c.Error(errors.NewInternalServerError(err.Error()))+ }return}updated, getErr := h.kgService.GetKnowledgeByID(effCtx, id)@@ -1874,7 +1774,12 @@ func (h *KnowledgeHandler) RegenerateKnowledgeSummary(c *gin.Context) {knowledge, err := h.kgService.GetKnowledgeByID(effCtx, id)if err != nil {logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewInternalServerError(err.Error()))+ var appErr *errors.AppError+ if goerrors.As(err, &appErr) {+ _ = c.Error(appErr)+ } else {+ _ = c.Error(errors.NewInternalServerError(err.Error()))+ }return}if knowledge.SummaryStatus == "" || knowledge.SummaryStatus == types.SummaryStatusNone {@@ -1887,7 +1792,12 @@ func (h *KnowledgeHandler) RegenerateKnowledgeSummary(c *gin.Context) {}if err != nil {logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewBadRequestError(err.Error()))+ var appErr *errors.AppError+ if goerrors.As(err, &appErr) {+ _ = c.Error(appErr)+ } else {+ _ = c.Error(errors.NewBadRequestError(err.Error()))+ }return}c.JSON(http.StatusOK, gin.H{"success": true, "data": knowledge})@@ -2098,7 +2008,7 @@ func (h *KnowledgeHandler) UpdateKnowledgeTagBatch(c *gin.Context) {c.Error(errors.NewUnauthorizedError("Unauthorized"))return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, tenantID)+ ctx = types.WithExecutionTenant(ctx, tenantID)var req knowledgeTagBatchRequestif err := c.ShouldBindJSON(&req); err != nil {@@ -2109,7 +2019,7 @@ func (h *KnowledgeHandler) UpdateKnowledgeTagBatch(c *gin.Context) {// Resolve effective tenant and the authorized KB scope.var authorizedKBID stringif kbID := secutils.SanitizeForLog(req.KBID); kbID != "" {- _, _, effID, permission, err := h.validateKnowledgeBaseAccessWithKBID(c, kbID)+ _, _, effID, permission, err := h.validateKnowledgeBaseWriteAccessWithKBID(c, kbID)if err != nil {c.Error(err)return@@ -2119,7 +2029,7 @@ func (h *KnowledgeHandler) UpdateKnowledgeTagBatch(c *gin.Context) {return}authorizedKBID = kbID- ctx = context.WithValue(ctx, types.TenantIDContextKey, effID)+ ctx = types.WithExecutionTenant(c.Request.Context(), effID)} else if len(req.Updates) > 0 {// No kb_id: infer from first knowledge ID so shared-KB updates work without client sending kb_idvar firstKnowledgeID string@@ -2137,6 +2047,11 @@ func (h *KnowledgeHandler) UpdateKnowledgeTagBatch(c *gin.Context) {ctx = effCtx}}+ if err := h.requireKBOwnershipOrAdmin(c, authorizedKBID); err != nil {+ _ = c.Error(err)+ return+ }+if err := h.kgService.UpdateKnowledgeTagBatch(ctx, authorizedKBID, req.Updates); err != nil {logger.ErrorWithFields(ctx, err, nil)c.Error(err)@@ -2198,7 +2113,12 @@ func (h *KnowledgeHandler) UpdateImageInfo(c *gin.Context) {err = h.kgService.UpdateImageInfo(effCtx, id, chunkID, secutils.SanitizeForLog(request.ImageInfo))if err != nil {logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewInternalServerError(err.Error()))+ var appErr *errors.AppError+ if goerrors.As(err, &appErr) {+ _ = c.Error(appErr)+ } else {+ _ = c.Error(errors.NewInternalServerError(err.Error()))+ }return}@@ -2262,36 +2182,15 @@ func (h *KnowledgeHandler) SearchKnowledge(c *gin.Context) {agentID := c.Query("agent_id")if agentID != "" {- userIDVal, ok := c.Get(types.UserIDContextKey.String())- if !ok {- c.Error(errors.NewUnauthorizedError("user ID not found"))- return- }- _ = userIDVal- currentTenantID := c.GetUint64(types.TenantIDContextKey.String())- if currentTenantID == 0 {- c.Error(errors.NewUnauthorizedError("workspace ID not found"))- return- }- callerTenantRole := types.TenantRoleFromContext(ctx)- requestedSourceTenantID, parseErr := types.ParseAgentSourceTenantID(c.Query(types.AgentSourceTenantIDParam))- if parseErr != nil {- c.Error(errors.NewBadRequestError(parseErr.Error()))- return- }- agent, err := h.agentShareService.GetSharedAgentForTenant(ctx, currentTenantID, callerTenantRole, agentID, requestedSourceTenantID)+ agent, err := resolveSharedAgentForRequest(c, agentID, h.agentShareService)if err != nil {- if goerrors.Is(err, service.ErrAgentShareNotFound) || goerrors.Is(err, service.ErrAgentSharePermission) || goerrors.Is(err, service.ErrAgentNotFoundForShare) {- c.Error(errors.NewForbiddenError("no permission for this shared agent"))- return- }- logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewInternalServerError("Failed to verify shared agent access").WithDetails(err.Error()))+ _ = c.Error(err)return}sourceTenantID := agent.TenantID- mode := agent.Config.KBSelectionMode- if mode == "none" {+ ctx = access.WithSharedAgent(ctx, agent)+ scope := types.NewSharedAgentKBScope(agent)+ if scope.IsEmpty() {c.JSON(http.StatusOK, gin.H{"success": true,"data": []interface{}{},@@ -2301,41 +2200,24 @@ func (h *KnowledgeHandler) SearchKnowledge(c *gin.Context) {return}var scopes []types.KnowledgeSearchScope- if mode == "selected" && len(agent.Config.KnowledgeBases) > 0 {- for _, kbID := range agent.Config.KnowledgeBases {+ if !scope.IsAll() {+ for _, kbID := range scope.IDs() {if kbID != "" {scopes = append(scopes, types.KnowledgeSearchScope{TenantID: sourceTenantID, KBID: kbID})}}}- if len(scopes) == 0 {+ if scope.IsAll() {kbs, err := h.kbService.ListKnowledgeBasesByTenantID(ctx, sourceTenantID)if err != nil {logger.ErrorWithFields(ctx, err, nil)c.Error(errors.NewInternalServerError("Failed to list knowledge bases").WithDetails(err.Error()))return}- // `all` mode: authoritative server-side capability filter. Mirrors the- // logic in ListKnowledgeBases so @file search, KB listing, and runtime- // all agree on what "mode=all" actually means for this agent. The- // filter is agent-mode aware so quick-answer (RAG-only) skips- // wiki-only KBs even though it has no `allowed_tools`.- filter := tools.DeriveKBFilterForAgent(agent.Config.AgentMode, agent.Config.AllowedTools)- removed := 0- for _, kb := range kbs {- if kb == nil || kb.Type != types.KnowledgeBaseTypeDocument {- continue- }- if !filter.IsEmpty() && !tools.KBSatisfiesAgentRequirements(kb.Capabilities(), agent.Config.AgentMode, agent.Config.AllowedTools) {- removed++- continue+ for _, kb := range filterKnowledgeBasesForSharedAgent(kbs, agent) {+ if kb.Type == types.KnowledgeBaseTypeDocument {+ scopes = append(scopes, types.KnowledgeSearchScope{TenantID: kb.TenantID, KBID: kb.ID})}- scopes = append(scopes, types.KnowledgeSearchScope{TenantID: sourceTenantID, KBID: kb.ID})- }- if removed > 0 {- logger.Infof(ctx,- "SearchKnowledge(agent=%s, mode=all): capability filter removed %d KBs",- agentID, removed)}}scopes = filterKnowledgeSearchScopesForAPIKey(ctx, scopes)@@ -2499,29 +2381,43 @@ func (h *KnowledgeHandler) MoveKnowledge(c *gin.Context) {return}- // Validate type match- if sourceKB.Type != targetKB.Type {- c.Error(errors.NewBadRequestError("Source and target knowledge bases must be the same type"))+ // Resolve explicit write grants independently for both body IDs.+ if _, err := resolveHandlerKBAccessFor(c, req.SourceKBID, h.kbService, nil, nil, types.OrgRoleEditor); err != nil {+ _ = c.Error(err)return}-- // Validate embedding model match- if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID {- c.Error(errors.NewBadRequestError("Source and target must use the same embedding model"))+ if _, err := resolveHandlerKBAccessFor(c, req.TargetKBID, h.kbService, nil, nil, types.OrgRoleEditor); err != nil {+ _ = c.Error(err)return}-- // reuse_vectors copies index entries directly between KBs, which only works- // inside the same VectorStore backend. A cross-store reuse_vectors move would- // route CopyIndices through the SOURCE store and then delete the source- // indices, corrupting the vector data. Reject it and point the caller at- // reparse mode, which re-indexes into the target store safely.- if req.Mode == "reuse_vectors" && !sourceKB.SharesStoreWith(targetKB) {- c.Error(errors.NewBadRequestError(- "reuse_vectors move across different vector stores is not supported; " +- "use reparse mode to move into a different store"))+ taskID := utils.GenerateTaskID("kg_move", tenantID.(uint64), req.SourceKBID)+ ctx, err = access.WithKBTransfer(c.Request.Context(), sourceKB, targetKB, access.KBTransferMove, taskID, false)+ if err != nil {+ _ = c.Error(kbAccessHTTPError(err))+ return+ }+ tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)+ if err := access.ValidateKBTransferCompatibility(sourceKB,+ targetKB,+ access.KBTransferMove,+ req.Mode,+ tenant); err != nil {+ _ = c.Error(errors.NewBadRequestError(err.Error()))return}+ uniqueIDs := make([]string, 0, len(req.KnowledgeIDs))+ seen := make(map[string]bool, len(req.KnowledgeIDs))+ for _, id := range req.KnowledgeIDs {+ if strings.TrimSpace(id) == "" {+ _ = c.Error(errors.NewBadRequestError("Knowledge ID cannot be empty"))+ return+ }+ if !seen[id] {+ seen[id] = true+ uniqueIDs = append(uniqueIDs, id)+ }+ }+ req.KnowledgeIDs = uniqueIDs// Validate all knowledge IDs belong to source KB and are in completed statusfor _, kID := range req.KnowledgeIDs {@@ -2530,8 +2426,13 @@ func (h *KnowledgeHandler) MoveKnowledge(c *gin.Context) {c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s not found", kID)))return}- if knowledge.KnowledgeBaseID != req.SourceKBID {- c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge item %s does not belong to the source knowledge base", kID)))+ if knowledge == nil || knowledge.ID != kID || knowledge.TenantID != tenantID.(uint64) ||+ knowledge.KnowledgeBaseID != req.SourceKBID {+ _ = c.Error(+ errors.NewBadRequestError(+ fmt.Sprintf("Knowledge item %s does not belong to the source knowledge base", kID),+ ),+ )return}if knowledge.ParseStatus != types.ParseStatusCompleted {@@ -2540,9 +2441,6 @@ func (h *KnowledgeHandler) MoveKnowledge(c *gin.Context) {}}- // Generate task ID- taskID := utils.GenerateTaskID("kg_move", tenantID.(uint64), req.SourceKBID)-// Create move payloadpayload := types.KnowledgeMovePayload{TenantID: tenantID.(uint64),@@ -2643,26 +2541,6 @@ func (h *KnowledgeHandler) GetKnowledgeMoveProgress(c *gin.Context) {})}-// resolveAgentAllowedKBIDs returns the set of knowledge base IDs that the-// shared agent is allowed to access based on its KBSelectionMode config.-// Returns nil when no restriction applies ("all" mode), or a concrete slice-// (possibly empty for "none" mode) when the results must be filtered.-func resolveAgentAllowedKBIDs(agent *types.CustomAgent) []string {- switch agent.Config.KBSelectionMode {- case "all":- return nil- case "none":- return []string{}- case "selected":- return agent.Config.KnowledgeBases- default:- if len(agent.Config.KnowledgeBases) > 0 {- return agent.Config.KnowledgeBases- }- return nil- }-}-// parseCommaSeparatedTagIDs splits a comma-separated string of tag IDs and// filters out empty strings and the "__untagged__" sentinel value.func parseCommaSeparatedTagIDs(raw string) []string {@@ -2701,15 +2579,6 @@ func parseFilterTime(raw string) (time.Time, error) {return time.Time{}, lastErr}-func sliceContains(ss []string, target string) bool {- for _, s := range ss {- if s == target {- return true- }- }- return false-}-type batchReparseKnowledgeRequest struct {KBID string `json:"kb_id" binding:"required"`IDs []string `json:"ids" binding:"required"`@@ -2763,7 +2632,7 @@ func (h *KnowledgeHandler) BatchReparseKnowledge(c *gin.Context) {return}- _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseAccessWithKBID(c, req.KBID)+ _, kbID, effectiveTenantID, permission, err := h.validateKnowledgeBaseWriteAccessWithKBID(c, req.KBID)if err != nil {c.Error(err)return@@ -2772,7 +2641,11 @@ func (h *KnowledgeHandler) BatchReparseKnowledge(c *gin.Context) {c.Error(errors.NewForbiddenError("no permission to reparse knowledge in this kb"))return}- ctx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ if err := h.requireKBOwnershipOrAdmin(c, kbID); err != nil {+ _ = c.Error(err)+ return+ }+ ctx = types.WithExecutionTenant(c.Request.Context(), effectiveTenantID)knowledgeList, err := h.kgService.GetKnowledgeBatch(ctx, effectiveTenantID, ids)if err != nil {@@ -2785,6 +2658,10 @@ func (h *KnowledgeHandler) BatchReparseKnowledge(c *gin.Context) {return}for _, k := range knowledgeList {+ if err := access.RejectMovingKnowledge(k); err != nil {+ _ = c.Error(err)+ return+ }if k.KnowledgeBaseID != kbID {c.Error(errors.NewBadRequestError(fmt.Sprintf("Knowledge %s does not belong to knowledge base %s",@@ -2793,7 +2670,7 @@ func (h *KnowledgeHandler) BatchReparseKnowledge(c *gin.Context) {}}- taskID, err := h.enqueueKnowledgeListReparse(ctx, effectiveTenantID, ids, req.ProcessConfig)+ taskID, err := h.enqueueKnowledgeListReparse(ctx, effectiveTenantID, kbID, ids, req.ProcessConfig)if err != nil {logger.Errorf(ctx, "Failed to enqueue batch knowledge reparse task: %v", err)c.Error(errors.NewInternalServerError("Failed to enqueue batch reparse task"))diff --git a/internal/handler/knowledge_mutation_admission_test.go b/internal/handler/knowledge_mutation_admission_test.gonew file mode 100644index 000000000..dcf709513--- /dev/null+++ b/internal/handler/knowledge_mutation_admission_test.go@@ -0,0 +1,253 @@+package handler++import (+ "context"+ "fmt"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/access"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++type mutationAdmissionKnowledge struct {+ interfaces.KnowledgeService+ rows []*types.Knowledge+ err error+ tagsCalled bool+ writeGrant bool+}++func (s *mutationAdmissionKnowledge) GetKnowledgeByIDOnly(context.Context, string) (*types.Knowledge, error) {+ return s.rows[0], nil+}++func (s *mutationAdmissionKnowledge) GetKnowledgeByID(context.Context, string) (*types.Knowledge, error) {+ return s.rows[0], nil+}++func (s *mutationAdmissionKnowledge) GetKnowledgeBatch(+ ctx context.Context,+ _ uint64,+ _ []string,+) ([]*types.Knowledge, error) {+ s.writeGrant = access.RequireKBWrite(ctx, &types.KnowledgeBase{ID: "kb", TenantID: 7}) == nil+ return s.rows, nil+}++func (s *mutationAdmissionKnowledge) ListKnowledgeByKnowledgeBaseID(+ context.Context,+ string,+) ([]*types.Knowledge, error) {+ return s.rows, nil+}++func (s *mutationAdmissionKnowledge) UpdateKnowledge(context.Context, *types.Knowledge) error {+ return s.err+}++func (s *mutationAdmissionKnowledge) UpdateImageInfo(context.Context, string, string, string) error {+ return s.err+}++func (s *mutationAdmissionKnowledge) RegenerateKnowledgeSummary(context.Context, string) (*types.Knowledge, error) {+ return nil, s.err+}++func (s *mutationAdmissionKnowledge) UpdateKnowledgeTagBatch(context.Context, string, map[string][]string) error {+ s.tagsCalled = true+ return s.err+}++func mutationRequest(r *gin.Engine, method, path, body string) *httptest.ResponseRecorder {+ req := httptest.NewRequest(method, path, strings.NewReader(body))+ req.Header.Set("Content-Type", "application/json")+ w := httptest.NewRecorder()+ r.ServeHTTP(w, req)+ return w+}++func admissionKnowledge(moving bool) *types.Knowledge {+ k := &types.Knowledge{ID: "doc", TenantID: 7, KnowledgeBaseID: "kb"}+ if moving {+ k.Metadata = []byte(`{"_knowledge_transfer":{"operation":"move","phase":"moving"}}`)+ }+ return k+}++func admissionKB(creator string) *stubKBService {+ return &stubKBService{get: func(context.Context, string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: "kb", TenantID: 7, CreatorID: creator}, nil+ }}+}++func TestMovingDocumentAdmissionRejectsBeforeEnqueue(t *testing.T) {+ for _, route := range []string{"single", "batch", "clear", "reparse"} {+ t.Run(route, func(t *testing.T) {+ kg := &mutationAdmissionKnowledge{rows: []*types.Knowledge{admissionKnowledge(true)}}+ if route == "batch" || route == "reparse" {+ kg.rows = append([]*types.Knowledge{{ID: "other", TenantID: 7, KnowledgeBaseID: "kb"}}, kg.rows...)+ }+ queue := &documentDeleteEnqueuer{}+ h := &KnowledgeHandler{+ cfg: transferHandlerConfig(),+ kbService: admissionKB("user"),+ kgService: kg,+ asynqClient: queue,+ }+ r := documentHandlerRouter()+ method, path, body := http.MethodDelete, "/doc", ""+ switch route {+ case "single":+ r.DELETE("/:id", h.DeleteKnowledge)+ case "batch":+ r.POST("/batch", h.BatchDeleteKnowledge)+ method, path, body = http.MethodPost, "/batch", `{"kb_id":"kb","ids":["other","doc"]}`+ case "clear":+ r.DELETE("/:id", h.ClearKnowledgeBaseContents)+ path = "/kb"+ case "reparse":+ r.POST("/reparse", h.BatchReparseKnowledge)+ method, path, body = http.MethodPost, "/reparse", `{"kb_id":"kb","ids":["other","doc"]}`+ }+ w := mutationRequest(r, method, path, body)+ require.Equal(t, 409, w.Code, w.Body.String())+ require.Nil(t, queue.task)+ })+ }+}++func TestBatchMutationRequiresCreatorOrAdminAndWriteGrant(t *testing.T) {+ for _, route := range []string{"reparse", "tags explicit", "tags inferred"} {+ for _, creator := range []string{"user", "colleague"} {+ t.Run(route+creator, func(t *testing.T) {+ kg := &mutationAdmissionKnowledge{rows: []*types.Knowledge{admissionKnowledge(false)}}+ queue := &documentDeleteEnqueuer{}+ h := &KnowledgeHandler{+ cfg: transferHandlerConfig(),+ kbService: admissionKB(creator),+ kgService: kg,+ asynqClient: queue,+ }+ r := transferHandlerRouter(nil)+ method, body := http.MethodPost, `{"kb_id":"kb","ids":["doc"]}`+ if route == "reparse" {+ r.POST("/batch", h.BatchReparseKnowledge)+ } else {+ r.PUT("/batch", h.UpdateKnowledgeTagBatch)+ method = http.MethodPut+ body = `{"kb_id":"kb","updates":{"doc":["tag"]}}`+ if route == "tags inferred" {+ body = `{"updates":{"doc":["tag"]}}`+ }+ }+ w := mutationRequest(r, method, "/batch", body)+ if creator == "user" {+ require.Equal(t, 200, w.Code, w.Body.String())+ if route == "reparse" {+ require.True(t, kg.writeGrant)+ require.NotNil(t, queue.task)+ } else {+ require.True(t, kg.tagsCalled)+ }+ } else {+ require.Equal(t, 403, w.Code, w.Body.String())+ require.Nil(t, queue.task)+ require.False(t, kg.tagsCalled)+ }+ })+ }+ }+}++type mutationChunkService struct {+ interfaces.ChunkService+ err error+}++func (s *mutationChunkService) GetChunkByID(context.Context, string) (*types.Chunk, error) {+ return &types.Chunk{ID: "chunk", KnowledgeID: "doc"}, nil+}++func (s *mutationChunkService) UpdateDocumentChunk(+ context.Context,+ string,+ *string,+ *bool,+ *int,+) (*types.Chunk, error) {+ return nil, s.err+}++func (s *mutationChunkService) RevertDocumentChunk(context.Context, string, int, *int) (*types.Chunk, error) {+ return nil, s.err+}++func TestMutationHandlersPreserveApplicationStatus(t *testing.T) {+ for _, status := range []int{409, 403} {+ for _, route := range []string{"metadata", "image", "summary", "chunk", "revert"} {+ t.Run(fmt.Sprint(status)+route, func(t *testing.T) {+ app := apperrors.NewConflictError("moving")+ if status == 403 {+ app = apperrors.NewForbiddenError("binding changed")+ }+ failure := fmt.Errorf("operation: %w", app)+ kg := &mutationAdmissionKnowledge{rows: []*types.Knowledge{admissionKnowledge(false)}, err: failure}+ h := &KnowledgeHandler{kgService: kg}+ chunks := &ChunkHandler{service: &mutationChunkService{err: failure}}+ r := documentHandlerRouter()+ method, path, body := http.MethodPut, "/doc", `{"title":"new"}`+ switch route {+ case "metadata":+ r.PUT("/:id", h.UpdateKnowledge)+ case "image":+ r.PUT("/:id/:chunk_id", h.UpdateImageInfo)+ path = "/doc/chunk"+ body = `{"image_info":"[]"}`+ case "summary":+ r.POST("/:id", h.RegenerateKnowledgeSummary)+ method = http.MethodPost+ body = ""+ case "chunk":+ r.PUT("/:knowledge_id/:id", chunks.UpdateChunk)+ path = "/doc/chunk"+ body = `{"content":"new"}`+ case "revert":+ r.POST("/:knowledge_id/:id", chunks.RevertChunk)+ method = http.MethodPost+ path = "/doc/chunk"+ body = `{"revision":0}`+ }+ w := mutationRequest(r, method, path, body)+ require.Equal(t, status, w.Code, w.Body.String())+ })+ }+ }+}++func TestBatchReparsePreservesAdminAndRBACRolloutPolicy(t *testing.T) {+ for _, enforced := range []bool{true, false} {+ t.Run(fmt.Sprint(enforced), func(t *testing.T) {+ cfg := transferHandlerConfig()+ cfg.Tenant.EnableRBAC = &enforced+ kg := &mutationAdmissionKnowledge{rows: []*types.Knowledge{admissionKnowledge(false)}}+ queue := &documentDeleteEnqueuer{}+ h := &KnowledgeHandler{cfg: cfg, kbService: admissionKB("colleague"), kgService: kg, asynqClient: queue}+ r := transferHandlerRouter(nil)+ if enforced {+ r = documentHandlerRouter()+ } // Admin may edit another creator's KB.+ r.POST("/batch", h.BatchReparseKnowledge)+ w := mutationRequest(r, http.MethodPost, "/batch", `{"kb_id":"kb","ids":["doc"]}`)+ require.Equal(t, 200, w.Code, w.Body.String())+ require.True(t, kg.writeGrant)+ require.NotNil(t, queue.task)+ })+ }+}diff --git a/internal/handler/knowledge_ownership_test.go b/internal/handler/knowledge_ownership_test.gonew file mode 100644index 000000000..6a368b32f--- /dev/null+++ b/internal/handler/knowledge_ownership_test.go@@ -0,0 +1,157 @@+package handler++import (+ "context"+ stderrors "errors"+ "fmt"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/repository"+ "github.com/Tencent/WeKnora/internal/config"+ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++func TestBodyKBOwnershipSkipsUnnecessaryLookup(t *testing.T) {+ for _, tt := range []struct {+ name string+ role types.TenantRole+ apiKey, superuser, disabled bool+ }{+ {name: "admin", role: types.TenantRoleAdmin},+ {name: "owner", role: types.TenantRoleOwner},+ {name: "API key", role: types.TenantRoleViewer, apiKey: true},+ {name: "cross tenant superuser", role: types.TenantRoleViewer, superuser: true},+ {name: "RBAC disabled", role: types.TenantRoleContributor, disabled: true},+ } {+ t.Run(tt.name, func(t *testing.T) {+ c := newKBLookupCtx(t, 1, "kb")+ ctx := context.WithValue(c.Request.Context(), types.TenantRoleContextKey, tt.role)+ ctx = context.WithValue(+ ctx,+ types.UserContextKey,+ &types.User{ID: "user", CanAccessAllTenants: tt.superuser},+ )+ if tt.apiKey {+ ctx = types.WithTenantAPIKeyScope(+ ctx,+ types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"kb"}},+ )+ }+ c.Request = c.Request.WithContext(ctx)+ enabled := !tt.disabled+ h := &KnowledgeHandler{+ cfg: &config.Config{+ Tenant: &config.TenantConfig{EnableRBAC: &enabled, EnableCrossTenantAccess: tt.superuser},+ },+ kbService: &stubKBService{get: func(context.Context, string) (*types.KnowledgeBase, error) {+ t.Fatal("body-carried KB ownership must be looked up lazily")+ return nil, stderrors.New("unavailable")+ }},+ }+ require.NoError(t, h.requireKBOwnershipOrAdmin(c, "kb"))+ })+ }+}++func TestBodyKBOwnershipPreservesStatusAndTenantBoundary(t *testing.T) {+ for _, tt := range []struct {+ name string+ kb *types.KnowledgeBase+ lookupErr error+ status int+ }{+ {+ name: "creator",+ kb: &types.KnowledgeBase{+ ID: "kb",+ TenantID: 1,+ CreatorID: "user",+ },+ status: http.StatusNoContent,+ },++ {+ name: "noncreator",+ kb: &types.KnowledgeBase{+ ID: "kb",+ TenantID: 1,+ CreatorID: "other",+ },+ status: http.StatusForbidden,+ },++ {name: "tenant owned", kb: &types.KnowledgeBase{ID: "kb", TenantID: 1}, status: http.StatusForbidden},+ {+ name: "same creator in another tenant",+ kb: &types.KnowledgeBase{+ ID: "kb",+ TenantID: 2,+ CreatorID: "user",+ },+ status: http.StatusNotFound,+ },++ {name: "nil resource", status: http.StatusNotFound},+ {+ name: "wrapped not found",+ lookupErr: fmt.Errorf("lookup: %w",+ repository.ErrKnowledgeBaseNotFound),+ status: http.StatusNotFound,+ },++ {+ name: "database failure",+ lookupErr: stderrors.New("database unavailable"),+ status: http.StatusInternalServerError,+ },+ } {+ t.Run(tt.name, func(t *testing.T) {+ enabled := true+ calls := 0+ h := &KnowledgeHandler{+ cfg: &config.Config{Tenant: &config.TenantConfig{EnableRBAC: &enabled}},+ kbService: &stubKBService{get: func(context.Context, string) (*types.KnowledgeBase, error) {+ calls+++ return tt.kb, tt.lookupErr+ }},+ }+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ ctx := context.WithValue(c.Request.Context(), types.TenantIDContextKey, uint64(1))+ ctx = context.WithValue(ctx, types.TenantRoleContextKey, types.TenantRoleContributor)+ ctx = context.WithValue(ctx, types.UserIDContextKey, "user")+ c.Request = c.Request.WithContext(ctx)+ c.Next()+ })+ r.POST("/write", func(c *gin.Context) {+ if err := h.requireKBOwnershipOrAdmin(c, "kb"); err != nil {+ _ = c.Error(err)+ return+ }+ c.Status(http.StatusNoContent)+ })+ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodPost, "/write", nil))+ require.Equal(t, tt.status, w.Code, w.Body.String())+ require.Equal(t, 1, calls)+ })+ }+}++func TestBodyWriteStillEnforcesAPIKeyKBScope(t *testing.T) {+ c := newKBLookupCtx(t, 1, "kb")+ c.Set(types.TenantIDContextKey.String(), uint64(1))+ ctx := types.WithTenantAPIKeyScope(+ c.Request.Context(),+ types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"allowed"}},+ )+ c.Request = c.Request.WithContext(ctx)+ h := &KnowledgeHandler{}+ _, _, err := h.requireKnowledgeWriteAccess(c, "outside-scope")+ require.Error(t, err, "skipping human ownership checks must not skip KB scope")+}diff --git a/internal/handler/knowledge_transfer_test.go b/internal/handler/knowledge_transfer_test.gonew file mode 100644index 000000000..8b56a92a1--- /dev/null+++ b/internal/handler/knowledge_transfer_test.go@@ -0,0 +1,176 @@+package handler++import (+ "context"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/Tencent/WeKnora/internal/config"+ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++type transferHandlerKnowledge struct{ interfaces.KnowledgeService }++func (*transferHandlerKnowledge) SaveKBCloneProgress(context.Context, *types.KBCloneProgress) error {+ return nil+}++func (*transferHandlerKnowledge) SaveKnowledgeMoveProgress(context.Context, *types.KnowledgeMoveProgress) error {+ return nil+}++func (*transferHandlerKnowledge) GetKnowledgeByID(_ context.Context, id string) (*types.Knowledge, error) {+ return &types.Knowledge{+ ID: id,+ TenantID: 7,+ KnowledgeBaseID: "source",+ ParseStatus: types.ParseStatusCompleted,+ }, nil+}++func transferHandlerRouter(scope *types.TenantAPIKeyScope) *gin.Engine {+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ ctx := types.WithCaller(+ c.Request.Context(),+ types.Caller{TenantID: 7, UserID: "user", Role: types.TenantRoleContributor},+ )+ ctx = types.WithExecutionTenant(ctx, 7)+ if scope != nil {+ ctx = types.WithTenantAPIKeyScope(ctx, *scope)+ }+ c.Set(types.TenantIDContextKey.String(), uint64(7))+ c.Request = c.Request.WithContext(ctx)+ c.Next()+ })+ return r+}++func transferHandlerConfig() *config.Config {+ enabled := true+ return &config.Config{Tenant: &config.TenantConfig{EnableRBAC: &enabled}}+}++func transferHandlerKB() *stubKBService {+ return &stubKBService{get: func(_ context.Context, id string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: id, TenantID: 7, CreatorID: "user"}, nil+ }}+}++func transferRequest(r *gin.Engine, body string) *httptest.ResponseRecorder {+ req := httptest.NewRequest(http.MethodPost, "/transfer", strings.NewReader(body))+ req.Header.Set("Content-Type", "application/json")+ w := httptest.NewRecorder()+ r.ServeHTTP(w, req)+ return w+}++func TestCopyAdmissionReservesDestinationAndPreservesCreator(t *testing.T) {+ q := &documentDeleteEnqueuer{}+ h := &KnowledgeBaseHandler{+ cfg: transferHandlerConfig(),+ service: transferHandlerKB(),+ knowledgeService: &transferHandlerKnowledge{},+ asynqClient: q,+ }+ r := transferHandlerRouter(nil)+ r.POST("/transfer", h.CopyKnowledgeBase)+ w := transferRequest(r, `{"source_id":"source"}`)+ require.Equal(t, 200, w.Code, w.Body.String())+ require.NotNil(t, q.task)+ var payload types.KBClonePayload+ require.NoError(t, json.Unmarshal(q.task.Payload(), &payload))+ require.NotEmpty(t, payload.TargetID)+ require.NotEqual(t, "source", payload.TargetID)+ require.True(t, payload.CreateTarget)+ require.Equal(t, "user", payload.CreatorID)+ require.Equal(t, uint64(7), payload.TenantID)+ require.Contains(t, w.Body.String(), payload.TargetID)+}++func TestCopyAdmissionRequiresExistingDestinationOwnership(t *testing.T) {+ q := &documentDeleteEnqueuer{}+ kb := &stubKBService{get: func(_ context.Context, id string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: id, TenantID: 7, CreatorID: "someone-else"}, nil+ }}+ h := &KnowledgeBaseHandler{+ cfg: transferHandlerConfig(),+ service: kb,+ knowledgeService: &transferHandlerKnowledge{},+ asynqClient: q,+ }+ r := transferHandlerRouter(nil)+ r.POST("/transfer", h.CopyKnowledgeBase)+ w := transferRequest(r, `{"source_id":"source","target_id":"target"}`)+ require.Equal(t, 403, w.Code, w.Body.String())+ require.Nil(t, q.task)+}++func TestCopyAdmissionKeepsManageCapabilityForNewDestination(t *testing.T) {+ for _, capability := range []string{"manage_kbs", "ingest"} {+ t.Run(capability, func(t *testing.T) {+ q := &documentDeleteEnqueuer{}+ h := &KnowledgeBaseHandler{+ cfg: transferHandlerConfig(),+ service: transferHandlerKB(),+ knowledgeService: &transferHandlerKnowledge{},+ asynqClient: q,+ }+ r := transferHandlerRouter(+ &types.TenantAPIKeyScope{+ Capabilities: types.StringArray{capability},+ KnowledgeBaseIDs: types.StringArray{"source"},+ },+ )+ r.POST("/transfer", h.CopyKnowledgeBase)+ w := transferRequest(r, `{"source_id":"source"}`)+ if capability == "manage_kbs" {+ require.Equal(t, 200, w.Code, w.Body.String())+ require.NotNil(t, q.task)+ } else {+ require.Equal(t, 403, w.Code, w.Body.String())+ require.Nil(t, q.task)+ }+ })+ }+}++func TestMoveAdmissionDeduplicatesIDsAndRequiresBothKBs(t *testing.T) {+ for _, both := range []bool{true, false} {+ ids := types.StringArray{"source"}+ if both {+ ids = append(ids, "target")+ }+ q := &documentDeleteEnqueuer{}+ h := &KnowledgeHandler{+ cfg: transferHandlerConfig(),+ kbService: transferHandlerKB(),+ kgService: &transferHandlerKnowledge{},+ asynqClient: q,+ }+ r := transferHandlerRouter(+ &types.TenantAPIKeyScope{Capabilities: types.StringArray{"ingest"}, KnowledgeBaseIDs: ids},+ )+ r.POST("/transfer", h.MoveKnowledge)+ w := transferRequest(+ r,+ `{"source_kb_id":"source","target_kb_id":"target","knowledge_ids":["doc","doc"],"mode":"reuse_vectors"}`,+ )+ if !both {+ require.Equal(t, 403, w.Code, w.Body.String())+ require.Nil(t, q.task)+ continue+ }+ require.Equal(t, 200, w.Code, w.Body.String())+ var payload types.KnowledgeMovePayload+ require.NoError(t, json.Unmarshal(q.task.Payload(), &payload))+ require.Equal(t, []string{"doc"}, payload.KnowledgeIDs)+ }+}diff --git a/internal/handler/knowledgebase.go b/internal/handler/knowledgebase.goindex f531b8f3e..30c12107d 100644--- a/internal/handler/knowledgebase.go+++ b/internal/handler/knowledgebase.go@@ -9,12 +9,13 @@ import ("strings""time"- "github.com/Tencent/WeKnora/internal/agent/tools"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/application/repository"- "github.com/Tencent/WeKnora/internal/application/service"+ "github.com/Tencent/WeKnora/internal/config""github.com/Tencent/WeKnora/internal/errors"apperrors "github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/middleware""github.com/Tencent/WeKnora/internal/storageurl""github.com/Tencent/WeKnora/internal/tracing/langfuse""github.com/Tencent/WeKnora/internal/types"@@ -22,11 +23,13 @@ import ("github.com/Tencent/WeKnora/internal/utils"secutils "github.com/Tencent/WeKnora/internal/utils""github.com/gin-gonic/gin"+ "github.com/google/uuid""github.com/hibiken/asynq")// KnowledgeBaseHandler defines the HTTP handler for knowledge base operationstype KnowledgeBaseHandler struct {+ cfg *config.Configservice interfaces.KnowledgeBaseServiceknowledgeService interfaces.KnowledgeServicekbShareService interfaces.KBShareService@@ -45,6 +48,7 @@ type KnowledgeBaseHandler struct {// NewKnowledgeBaseHandler creates a new knowledge base handler instancefunc NewKnowledgeBaseHandler(+ cfg *config.Config,service interfaces.KnowledgeBaseService,knowledgeService interfaces.KnowledgeService,kbShareService interfaces.KBShareService,@@ -56,6 +60,7 @@ func NewKnowledgeBaseHandler(storageResolver interfaces.StorageBackendResolver,) *KnowledgeBaseHandler {return &KnowledgeBaseHandler{+ cfg: cfg,service: service,knowledgeService: knowledgeService,kbShareService: kbShareService,@@ -348,7 +353,7 @@ func (h *KnowledgeBaseHandler) HybridSearch(c *gin.Context) {// Execute hybrid search with default search parameters// Note: For shared KBs, the service uses effectiveTenantID internally via context- results, err := h.service.HybridSearch(ctx, id, req)+ results, err := h.service.HybridSearch(c.Request.Context(), id, req)if err != nil {// Service-layer typed AppErrors (e.g. ErrVectorStoreBindingInvalid,// ErrVectorStoreUnavailable, BadRequest from multi-store fan-out)@@ -445,115 +450,15 @@ func (h *KnowledgeBaseHandler) CreateKnowledgeBase(c *gin.Context) {// Returns the knowledge base, knowledge base ID, effective tenant ID for embedding, permission level, and any errors encountered// For owned KBs, effectiveTenantID is the caller's tenant ID// For shared KBs, effectiveTenantID is the source tenant ID (owner's tenant)-func (h *KnowledgeBaseHandler) validateAndGetKnowledgeBase(c *gin.Context) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {- ctx := c.Request.Context()-- // Get tenant ID from context- tenantID, exists := c.Get(types.TenantIDContextKey.String())- if !exists {- logger.Error(ctx, "Failed to get tenant ID")- return nil, "", 0, "", apperrors.NewUnauthorizedError("Unauthorized")- }-- // Get user ID from context (needed for shared KB permission check)- userID, userExists := c.Get(types.UserIDContextKey.String())- callerTenantRole := types.TenantRoleFromContext(ctx)-- // Get knowledge base ID from URL parameter+func (h *KnowledgeBaseHandler) validateAndGetKnowledgeBase(+ c *gin.Context,+) (*types.KnowledgeBase, string, uint64, types.OrgMemberRole, error) {id := secutils.SanitizeForLog(c.Param("id"))- if id == "" {- logger.Error(ctx, "Knowledge base ID is empty")- return nil, "", 0, "", apperrors.NewBadRequestError("Knowledge base ID cannot be empty")- }- if err := requireTenantAPIKeyKnowledgeBase(ctx, id); err != nil {- return nil, id, 0, "", err- }-- // Verify tenant has permission to access this knowledge base- kb, err := h.service.GetKnowledgeBaseByID(ctx, id)+ grant, err := resolveHandlerKBAccess(c, id, h.service, h.kbShareService, h.agentShareService)if err != nil {- // repo.GetKnowledgeBaseByID surfaces ErrKnowledgeBaseNotFound for- // missing or cross-tenant rows. Map it to 404 here so the four- // callers (Get / Update / Delete / TogglePin / Copy / Hybrid-search- // path) don't have to wrap NewInternalServerError into a 500 for- // every probe of a non-existent id.- if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) {- return nil, id, 0, "", apperrors.NewNotFoundError("knowledge base not found")- }- logger.ErrorWithFields(ctx, err, nil)- return nil, id, 0, "", apperrors.NewInternalServerError(err.Error())- }-- // Check 1: Verify tenant ownership (owner has full access)- if kb.TenantID == tenantID.(uint64) {- return kb, id, tenantID.(uint64), types.OrgRoleAdmin, nil- }-- // Check 2: If not owner, check organization shared access- if h.kbShareService != nil {- // Check if caller's tenant has shared access through organization- permission, isShared, permErr := h.kbShareService.CheckTenantKBPermission(ctx, id, tenantID.(uint64), callerTenantRole)- if permErr == nil && isShared {- // Tenant has shared access, get the source tenant ID for embedding queries- sourceTenantID, srcErr := h.kbShareService.GetKBSourceTenant(ctx, id)- if srcErr == nil {- logger.Infof(ctx, "Tenant %d accessing shared KB %s with permission %s, source tenant: %d",- tenantID.(uint64), id, permission, sourceTenantID)- return kb, id, sourceTenantID, permission, nil- }- }- }-- // Check 3: Shared agent — allow if request has agent_id (and agent can access this KB) OR caller's tenant has any shared agent that can access this KB (e.g. opened from "通过智能体可见" list without agent_id)- if h.agentShareService != nil {- currentTenantID := tenantID.(uint64)- agentID := c.Query("agent_id")- if agentID != "" {- sourceTenantID, parseErr := types.ParseAgentSourceTenantID(c.Query(types.AgentSourceTenantIDParam))- if parseErr != nil {- return kb, id, 0, types.OrgMemberRole(""), apperrors.NewBadRequestError(parseErr.Error())- }- agent, err := h.agentShareService.GetSharedAgentForTenant(ctx, currentTenantID, callerTenantRole, agentID, sourceTenantID)- if err == nil && agent != nil {- if kb.TenantID != agent.TenantID {- logger.Warnf(ctx, "Shared agent workspace mismatch, KB %s tenant: %d, agent tenant: %d", id, kb.TenantID, agent.TenantID)- } else {- mode := agent.Config.KBSelectionMode- if mode == "none" {- // no-op, fall through- } else if mode == "all" {- logger.Infof(ctx, "Tenant %d accessing KB %s via shared agent %s (mode=all)", currentTenantID, id, agentID)- return kb, id, kb.TenantID, types.OrgRoleViewer, nil- } else if mode == "selected" {- for _, allowedID := range agent.Config.KnowledgeBases {- if allowedID == id {- logger.Infof(ctx, "Tenant %d accessing KB %s via shared agent %s (mode=selected)", currentTenantID, id, agentID)- return kb, id, kb.TenantID, types.OrgRoleViewer, nil- }- }- }- }- }- } else {- // No agent_id in query: allow if caller's tenant has any shared agent that can access this KB (e.g. from space list "通过智能体可见")- can, err := h.agentShareService.TenantCanAccessKBViaSomeSharedAgent(ctx, currentTenantID, callerTenantRole, kb)- if err == nil && can {- logger.Infof(ctx, "Tenant %d accessing KB %s via some shared agent (no agent_id in query)", currentTenantID, id)- return kb, id, kb.TenantID, types.OrgRoleViewer, nil- }- }+ return nil, id, 0, "", err}- _ = userID- _ = userExists-- // No permission: not owner and no shared access- logger.Warnf(- ctx,- "Tenant has no permission to access this knowledge base, knowledge base ID: %s, "+- "request tenant ID: %d, knowledge base tenant ID: %d",- id, tenantID.(uint64), kb.TenantID,- )- return nil, id, 0, "", apperrors.NewForbiddenError("No permission to operate")+ return grant.KnowledgeBase, id, grant.EffectiveTenantID, grant.Permission, nil}// GetKnowledgeBase godoc@@ -608,86 +513,26 @@ func (h *KnowledgeBaseHandler) ListKnowledgeBases(c *gin.Context) {agentID := c.Query("agent_id")if agentID != "" {- userIDVal, ok := c.Get(types.UserIDContextKey.String())- if !ok {- c.Error(apperrors.NewUnauthorizedError("user ID not found"))- return- }- _ = userIDVal- currentTenantID := c.GetUint64(types.TenantIDContextKey.String())- if currentTenantID == 0 {- c.Error(apperrors.NewUnauthorizedError("workspace ID not found"))- return- }- callerTenantRole := types.TenantRoleFromContext(ctx)- requestedSourceTenantID, parseErr := types.ParseAgentSourceTenantID(c.Query(types.AgentSourceTenantIDParam))- if parseErr != nil {- c.Error(apperrors.NewBadRequestError(parseErr.Error()))- return- }- agent, err := h.agentShareService.GetSharedAgentForTenant(ctx, currentTenantID, callerTenantRole, agentID, requestedSourceTenantID)+ agent, err := resolveSharedAgentForRequest(c, agentID, h.agentShareService)if err != nil {- if stderrors.Is(err, service.ErrAgentShareNotFound) || stderrors.Is(err, service.ErrAgentSharePermission) || stderrors.Is(err, service.ErrAgentNotFoundForShare) {- c.Error(apperrors.NewForbiddenError("no permission for this shared agent"))- return- }- logger.ErrorWithFields(ctx, err, nil)- c.Error(apperrors.NewInternalServerError(err.Error()))+ _ = c.Error(err)return}- mode := agent.Config.KBSelectionMode- if mode == "none" {+ currentTenantID := middleware.KBAccessRequest(c).Caller.TenantID+ scope := types.NewSharedAgentKBScope(agent)+ if scope.IsEmpty() {c.JSON(http.StatusOK, gin.H{"success": true, "data": []interface{}{}})return}- sourceTenantID := agent.TenantID- kbs, err := h.service.ListKnowledgeBasesByTenantID(ctx, sourceTenantID)+ kbs, err := h.service.ListKnowledgeBasesByTenantID(ctx, agent.TenantID)if err != nil {logger.ErrorWithFields(ctx, err, nil)c.Error(apperrors.NewInternalServerError(err.Error()))return}- if mode == "selected" && len(agent.Config.KnowledgeBases) > 0 {- allowed := make(map[string]bool)- for _, id := range agent.Config.KnowledgeBases {- allowed[id] = true- }- filtered := make([]*types.KnowledgeBase, 0, len(kbs))- for _, kb := range kbs {- if allowed[kb.ID] {- filtered = append(filtered, kb)- }- }- kbs = filtered- }+ kbs = filterKnowledgeBasesForSharedAgent(kbs, agent)kbs = filterKnowledgeBasesForAPIKeyScope(ctx, kbs)- // `all` mode: authoritative server-side capability filter so a client- // that bypassed the frontend (old tab, curl, rogue plugin) can't @ a- // KB whose capabilities don't match this agent. The filter combines- // tool-derived requirements (smart-reasoning) with the implicit- // RAG-only requirement of quick-answer mode (which has no- // `allowed_tools` but still needs vector/keyword chunks to work).- // Non-`all` modes already constrain the scope explicitly.- if mode == "all" {- filter := tools.DeriveKBFilterForAgent(agent.Config.AgentMode, agent.Config.AllowedTools)- if !filter.IsEmpty() {- before := len(kbs)- kept := make([]*types.KnowledgeBase, 0, before)- for _, kb := range kbs {- if tools.KBSatisfiesAgentRequirements(kb.Capabilities(), agent.Config.AgentMode, agent.Config.AllowedTools) {- kept = append(kept, kb)- }- }- if removed := before - len(kept); removed > 0 {- logger.Infof(ctx,- "ListKnowledgeBases(agent=%s, mode=all): capability filter removed %d of %d KBs",- agentID, removed, before)- }- kbs = kept- }- }-c.JSON(http.StatusOK, gin.H{"success": true,"data": h.buildKBListResponse(ctx, kbs, currentTenantID),@@ -1029,112 +874,86 @@ func (h *KnowledgeBaseHandler) CopyKnowledgeBase(c *gin.Context) {return}- // Get tenant ID from context- tenantID, exists := c.Get(types.TenantIDContextKey.String())- if !exists {- logger.Error(ctx, "Failed to get tenant ID")- c.Error(apperrors.NewUnauthorizedError("Unauthorized"))+ caller := types.CallerFromContext(ctx)+ if caller.TenantID == 0 {+ _ = c.Error(errors.NewUnauthorizedError("Unauthorized"))return}- kbIDs := []string{req.SourceID}- if req.TargetID != "" {- kbIDs = append(kbIDs, req.TargetID)- }- if err := requireTenantAPIKeyKnowledgeBases(ctx, kbIDs...); err != nil {+ tenantID := caller.TenantID+ sourceGrant, err := resolveHandlerKBAccessFor(c, req.SourceID, h.service, nil, nil, types.OrgRoleViewer)+ if err != nil {c.Error(err)return}-- // Validate source knowledge base exists and belongs to caller's tenant (prevent cross-tenant clone)- sourceKB, err := h.service.GetKnowledgeBaseByID(ctx, req.SourceID)- if err != nil {- if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) {- c.Error(errors.NewNotFoundError("Source knowledge base not found"))- return- }- logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewInternalServerError(err.Error()))+ sourceKB := sourceGrant.KnowledgeBase+ if sourceKB.TenantID != caller.TenantID {+ _ = c.Error(errors.NewForbiddenError("No permission to copy this knowledge base"))return}- if sourceKB.TenantID != tenantID.(uint64) {- logger.Warnf(ctx,- "Copy rejected: source knowledge base belongs to another tenant, source_id: %s, caller_tenant: %d, kb_tenant: %d",- secutils.SanitizeForLog(req.SourceID), tenantID.(uint64), sourceKB.TenantID)- c.Error(errors.NewForbiddenError("No permission to copy this knowledge base"))+ taskID := req.TaskID+ if taskID == "" {+ taskID = utils.GenerateTaskID("kb_clone", caller.TenantID, req.SourceID)+ } else if err := requireTaskProgressTenant(ctx, taskID); err != nil {+ _ = c.Error(err)return}-- // If target_id provided, validate target belongs to caller's tenant- // and run the pre-flight defenses synchronously so a mismatched- // clone is rejected with 400 before the task is enqueued. The same- // checks are re-applied inside the async worker (service.CopyKnowledgeBase)- // as defense in depth.- if req.TargetID != "" {- targetKB, err := h.service.GetKnowledgeBaseByID(ctx, req.TargetID)+ create := req.TargetID == ""+ targetKB := &types.KnowledgeBase{ID: uuid.NewString(), TenantID: caller.TenantID}+ if create {+ if !types.IsSyntheticUserID(caller.UserID) {+ targetKB.CreatorID = caller.UserID+ }+ } else {+ targetGrant, err := resolveHandlerKBAccessFor(c, req.TargetID, h.service, nil, nil, types.OrgRoleEditor)if err != nil {- if stderrors.Is(err, repository.ErrKnowledgeBaseNotFound) {- c.Error(errors.NewNotFoundError("Target knowledge base not found"))- return- }- logger.ErrorWithFields(ctx, err, nil)- c.Error(errors.NewInternalServerError(err.Error()))+ _ = c.Error(err)return}- if targetKB.TenantID != tenantID.(uint64) {- logger.Warnf(ctx, "Copy rejected: target knowledge base belongs to another tenant, target_id: %s",- secutils.SanitizeForLog(req.TargetID))+ targetKB = targetGrant.KnowledgeBase+ if targetKB.TenantID != caller.TenantID {c.Error(errors.NewForbiddenError("No permission to copy to this knowledge base"))return}- // Pre-flight defense 1: embedding model must match.- // Without this check the async clone would run with incompatible- // vector spaces and produce semantically broken results.- if sourceKB.EmbeddingModelID != targetKB.EmbeddingModelID {- c.Error(apperrors.NewBadRequestError(- "source and target knowledge bases use different embedding models; " +- "clone into a target with the same embedding model"))+ if err := middleware.EvaluateOwnershipOrRole(c.Request.Context(),+ h.cfg,+ types.TenantRoleAdmin,+ func() (string,+ error,+ ) {+ return targetKB.CreatorID,+ nil+ }); err != nil {+ _ = c.Error(errors.NewForbiddenError("No permission to replace this knowledge base's contents"))return}- // Pre-flight defense 2: vector store binding must match.- // Cross-store cloning would require copying physical vector data- // between stores, which is not yet supported.- if !sourceKB.SharesStoreWith(targetKB) {- c.Error(apperrors.NewBadRequestError(- "source and target knowledge bases are bound to different vector stores; " +- "cross-store cloning is not yet supported"))+ tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant)+ if err := access.ValidateKBTransferCompatibility(sourceKB,+ targetKB,+ access.KBTransferClone,+ "",+ tenant); err != nil {+ _ = c.Error(errors.NewBadRequestError(err.Error()))return}- // Pre-flight defense 3: compare concrete instance IDs, not just the- // provider type (COS-A and COS-B are different physical stores).- if tenant, _ := ctx.Value(types.TenantInfoContextKey).(*types.Tenant); tenant != nil {- defaultID, defaultProvider := "", ""- if tenant.DefaultStorageBackendID != nil {- defaultID = *tenant.DefaultStorageBackendID- }- if tenant.StorageEngineConfig != nil {- defaultProvider = tenant.StorageEngineConfig.DefaultProvider- }- if !sourceKB.SharesStorageBackendWith(targetKB, defaultID, defaultProvider) {- c.Error(apperrors.NewBadRequestError(- "source and target knowledge bases use different storage instances; cross-storage-backend cloning is not supported"))- return- }- }}-- // Generate task ID if not provided- taskID := req.TaskID- if taskID == "" {- taskID = utils.GenerateTaskID("kb_clone", tenantID.(uint64), req.SourceID)+ ctx, err = access.WithKBTransfer(c.Request.Context(), sourceKB, targetKB, access.KBTransferClone, taskID, create)+ if err != nil {+ _ = c.Error(kbAccessHTTPError(err))+ return}+ // Reserve the destination in the payload; enqueue failures do not leave+ // empty KBs and every worker delivery creates/resumes the same destination.+ req.TargetID = targetKB.ID// Create KB clone payloadpayload := types.KBClonePayload{- TenantID: tenantID.(uint64),- TaskID: taskID,- SourceID: req.SourceID,- TargetID: req.TargetID,- Initiator: types.TaskInitiatorFromContext(ctx),+ TenantID: tenantID,+ TaskID: taskID,+ SourceID: req.SourceID,+ TargetID: req.TargetID,+ CreateTarget: create,+ CreatorID: targetKB.CreatorID,+ Initiator: types.TaskInitiatorFromContext(ctx),}langfuse.InjectTracing(ctx, &payload)diff --git a/internal/handler/rbac_lookups.go b/internal/handler/rbac_lookups.goindex fbc181a96..cd048643b 100644--- a/internal/handler/rbac_lookups.go+++ b/internal/handler/rbac_lookups.go@@ -36,30 +36,7 @@ func (h *KnowledgeBaseHandler) KBCreatorLookup(c *gin.Context) (string, error) {if id == "" {return "", errors.New("missing :id param for KB creator lookup")}- ctx := c.Request.Context()- tenantID, ok := types.TenantIDFromContext(ctx)- if !ok {- // 没有空间上下文意味着 auth 中间件未完成;当作 lookup 失败让上层 503,- // 而不是 silently 走 fail-open 给一个不该有的访问。- return "", errors.New("workspace context missing")- }- kb, err := h.service.GetKnowledgeBaseByID(ctx, id)- if err != nil {- if errors.Is(err, apprepo.ErrKnowledgeBaseNotFound) {- return "", middleware.ErrResourceNotFound- }- return "", err- }- if kb == nil {- return "", middleware.ErrResourceNotFound- }- // 显式重校验空间:repo.GetKnowledgeBaseByID 不带 tenant 过滤,- // 万一未来 :id 被攻击者从他人空间 UUID 试探到,也不会借由- // "ownership match" 通过中间件。- if kb.TenantID != tenantID {- return "", middleware.ErrResourceNotFound- }- return kb.CreatorID, nil+ return resolveKBCreatorByKBID(c, h.service, id)}// KBCreatorLookupFromKbIDParam is the same lookup as KBCreatorLookup@@ -74,25 +51,7 @@ func (h *KnowledgeBaseHandler) KBCreatorLookupFromKbIDParam(c *gin.Context) (strif id == "" {return "", errors.New("missing :kbId param for KB creator lookup")}- ctx := c.Request.Context()- tenantID, ok := types.TenantIDFromContext(ctx)- if !ok {- return "", errors.New("workspace context missing")- }- kb, err := h.service.GetKnowledgeBaseByID(ctx, id)- if err != nil {- if errors.Is(err, apprepo.ErrKnowledgeBaseNotFound) {- return "", middleware.ErrResourceNotFound- }- return "", err- }- if kb == nil {- return "", middleware.ErrResourceNotFound- }- if kb.TenantID != tenantID {- return "", middleware.ErrResourceNotFound- }- return kb.CreatorID, nil+ return resolveKBCreatorByKBID(c, h.service, id)}// AgentCreatorLookup resolves :id -> CustomAgent.CreatedBy. Built-in@@ -226,30 +185,12 @@ func (h *WikiPageHandler) KBCreatorLookupFromKBPath(c *gin.Context) (string, errif kbID == "" {return "", errors.New("missing :kb_id param for wiki owner lookup")}- ctx := c.Request.Context()- tenantID, ok := types.TenantIDFromContext(ctx)- if !ok {- return "", errors.New("workspace context missing")- }- kb, err := h.kbService.GetKnowledgeBaseByID(ctx, kbID)- if err != nil {- if errors.Is(err, apprepo.ErrKnowledgeBaseNotFound) {- return "", middleware.ErrResourceNotFound- }- return "", err- }- if kb == nil {- return "", middleware.ErrResourceNotFound- }- if kb.TenantID != tenantID {- return "", middleware.ErrResourceNotFound- }- return kb.CreatorID, nil+ return resolveKBCreatorByKBID(c, h.kbService, kbID)}// resolveKBCreatorByKBID resolves a KB id to CreatorID, scoped to the-// caller's tenant. Used by cross-KB handlers whose body carries kb_id-// instead of a URL param (batch-delete, move, etc.).+// caller's tenant. Shared by KB, initialization and Wiki route lookups and+// cross-KB handlers whose body carries kb_id (batch-delete, move, etc.).func resolveKBCreatorByKBID(c *gin.Context,kbService interfaces.KnowledgeBaseService,diff --git a/internal/handler/session/artifact_download.go b/internal/handler/session/artifact_download.goindex 6186bed8b..945060b0d 100644--- a/internal/handler/session/artifact_download.go+++ b/internal/handler/session/artifact_download.go@@ -2,15 +2,18 @@ package sessionimport (stderrors "errors"- "io""mime""net/http""path/filepath""strconv""strings"+ "github.com/Tencent/WeKnora/internal/application/access"+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file""github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/filetransport""github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/storageurl""github.com/Tencent/WeKnora/internal/types"secutils "github.com/Tencent/WeKnora/internal/utils""github.com/gin-gonic/gin"@@ -180,12 +183,12 @@ func (h *Handler) DownloadMessageArtifact(c *gin.Context) {return}if index >= len(msg.Artifacts) {- c.Error(errors.NewNotFoundError("artifact index out of range"))+ _ = c.Error(errors.NewNotFoundError("artifact index out of range"))return}artifact := msg.Artifacts[index]if artifact.URL == "" {- c.Error(errors.NewNotFoundError("artifact storage path missing"))+ _ = c.Error(errors.NewNotFoundError("artifact storage path missing"))return}@@ -193,27 +196,64 @@ func (h *Handler) DownloadMessageArtifact(c *gin.Context) {c.Error(errors.NewInternalServerError("file service unavailable"))return}- reader, err := h.fileService.GetFile(ctx, artifact.URL)+ file, err := access.ResolveMessageArtifact(ctx, msg, index, h.agentShareService, h.resourceCatalog,+ access.MessageKBShareAuthorizer{ShareGuard: h.kbShareService, KBs: h.knowledgebaseService})if err != nil {- logger.Warnf(ctx, "artifact download read failed: session=%s message=%s idx=%d err=%v",- sessionID, messageID, index, err)- c.Error(errors.NewNotFoundError("artifact blob missing"))+ _ = c.Error(errors.NewNotFoundError("artifact not accessible"))return}- defer reader.Close()-- // Force download semantics — artifacts are never rendered inline, matching- // the /files endpoint's active-content protection.- c.Header("Content-Type", mimeTypeFor(artifact.FileName))- c.Header("X-Content-Type-Options", "nosniff")- c.Header("Content-Disposition", buildAttachmentHeader(artifact.FileName))- if artifact.FileSize > 0 {- c.Header("Content-Length", strconv.FormatInt(artifact.FileSize, 10))+ ctx = types.WithExecutionTenant(ctx, file.OwnerTenantID)+ fileService := h.fileService+ if h.tenantService != nil {+ tenant, lookupErr := h.tenantService.GetTenantByID(ctx, file.OwnerTenantID)+ if lookupErr != nil || tenant == nil {+ _ = c.Error(errors.NewNotFoundError("artifact workspace unavailable"))+ return+ }+ backendID, providerPath, scoped := types.ParseStorageBackendPath(file.Path)+ if !scoped {+ providerPath = file.Path+ }+ if file.StorageBackendID != "" {+ backendID = file.StorageBackendID+ }+ var ok bool+ fileService, _, ok = filesvc.ResolveTenantFileServiceWithFallback(+ ctx,+ "artifact download",+ tenant,+ backendID,+ types.ParseProviderScheme(providerPath),+ storageurl.LocalStorageBaseDir(),+ h.storageResolver,+ h.fileService,+ )+ if !ok {+ _ = c.Error(errors.NewNotFoundError("artifact storage unavailable"))+ return+ }}- c.Status(http.StatusOK)- if _, err := io.Copy(c.Writer, reader); err != nil {- logger.Warnf(ctx, "artifact download stream failed: session=%s message=%s idx=%d err=%v",+ reader, err := fileService.GetFile(ctx, file.Path)+ if err != nil {+ logger.Warnf(ctx, "artifact download read failed: session=%s message=%s idx=%d err=%v",sessionID, messageID, index, err)+ _ = c.Error(errors.NewNotFoundError("artifact blob missing"))+ return+ }+ if err := filetransport.Serve(c.Writer, c.Request, reader, filetransport.Options{+ Filename: artifact.FileName, Download: true, ContentType: mimeTypeFor(artifact.FileName),+ Disposition: buildAttachmentHeader(artifact.FileName),+ Size: artifact.FileSize,+ CacheControl: "private, no-store",+ }); err != nil {+ logger.Warnf(+ ctx,+ "artifact download stream failed: session=%s message=%s idx=%d err=%v",+ sessionID,+ messageID,+ index,+ err,+ )}}diff --git a/internal/handler/session/artifact_download_test.go b/internal/handler/session/artifact_download_test.goindex e58a1d202..6d6921d31 100644--- a/internal/handler/session/artifact_download_test.go+++ b/internal/handler/session/artifact_download_test.go@@ -21,9 +21,8 @@ import (// -----------------------------------------------------------------------------// Test doubles//-// The download handler only touches three collaborators: SessionService (for-// ownership check), MessageService (for the message + artifact list), and-// FileService (for the blob stream). We embed the full interfaces so the+// The download handler checks session ownership, persisted artifacts and+// source sharing before resolving the owner's file storage. We embed interfaces so the// zero-value struct compiles, then override just the methods each test// exercises. A stray call to an un-stubbed method deliberately nil-panics// so the failure surfaces immediately.@@ -58,18 +57,63 @@ func (s *stubMessageServiceForArtifacts) GetSessionArtifacts(ctx context.Context// fakeArtifactFileService serves canned bytes for a single URL.type fakeArtifactFileService struct {interfaces.FileService- url string- data []byte+ url string+ data []byte+ calls int}func (f *fakeArtifactFileService) GetFile(_ context.Context, url string) (io.ReadCloser, error) {+ f.calls++if url != f.url {return nil, stderrors.New("not found")}return io.NopCloser(strings.NewReader(string(f.data))), nil}-func (f *fakeArtifactFileService) SaveFile(_ context.Context, _ *multipart.FileHeader, _ uint64, _ string) (string, error) {+type artifactCatalogStub struct {+ interfaces.ResourceCatalog+ resource *types.StoredResource+}++func (s *artifactCatalogStub) ResolvePath(context.Context, string) (string, *types.StoredResource, error) {+ return s.resource.PhysicalPath, s.resource, nil+}++type artifactTenantStub struct {+ interfaces.TenantService+ t *testing.T+}++func (s *artifactTenantStub) GetTenantByID(ctx context.Context, id uint64) (*types.Tenant, error) {+ if id != 7 || types.MustTenantIDFromContext(ctx) != 7 || types.CallerFromContext(ctx).TenantID != 42 {+ s.t.Fatal("artifact storage must use its owner while preserving the caller")+ }+ return &types.Tenant{ID: id}, nil+}++type artifactStorageStub struct {+ interfaces.StorageBackendResolver+ t *testing.T+ file interfaces.FileService+}++func (s *artifactStorageStub) ResolveFileService(+ _ context.Context,+ tenant *types.Tenant,+ backendID, provider, _ string,+) (interfaces.FileService, string, error) {+ if tenant.ID != 7 || backendID != "backend-7" || provider != "local" {+ s.t.Fatalf("unexpected storage target: tenant=%d backend=%s provider=%s", tenant.ID, backendID, provider)+ }+ return s.file, provider, nil+}++func (f *fakeArtifactFileService) SaveFile(+ _ context.Context,+ _ *multipart.FileHeader,+ _ uint64,+ _ string,+) (string, error) {return "", nil}@@ -92,7 +136,10 @@ func (f *fakeArtifactFileService) DeleteFile(_ context.Context, _ string) errorfunc newArtifactTestRouter(h *Handler) *gin.Engine {gin.SetMode(gin.TestMode)r := gin.New()- r.Use(middleware.ErrorHandler())+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ c.Request = c.Request.WithContext(context.WithValue(c.Request.Context(), types.TenantIDContextKey, uint64(42)))+ c.Next()+ })// Match the production route's wildcard names (see router.go — GET tree// binds :id to align with /sessions/:id) so paramSessionID resolves via// the same code path exercised in prod.@@ -109,7 +156,7 @@ func newArtifactTestRouter(h *Handler) *gin.Engine {func TestDownloadMessageArtifact_HappyPath(t *testing.T) {sessionID := "sess-1"messageID := "msg-1"- url := "fake://tenant-42/report.pptx"+ url := "local://42/exports/report.pptx"body := []byte("PPTX-BYTES")h := &Handler{@@ -180,6 +227,60 @@ func TestDownloadMessageArtifact_SessionNotOwnedReturns404(t *testing.T) {}}+func TestDownloadMessageArtifact_SourceStorageAndShareRevocation(t *testing.T) {+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ const physical = "local://7/exports/report.pdf"+ shares := &resolveAgentShareStub{agent: &types.CustomAgent{ID: "agent", TenantID: 7}}+ ownerFiles := &fakeArtifactFileService{url: physical, data: []byte("PDF-BYTES")}+ globalFiles := &fakeArtifactFileService{}+ h := &Handler{+ sessionService: &stubSessionServiceForArtifacts{+ getSession: func(context.Context, string) (*types.Session, error) {+ return &types.Session{ID: "sess-1", TenantID: 42}, nil+ },+ },+ messageService: &stubMessageServiceForArtifacts{+ getMessage: func(context.Context, string, string) (*types.Message, error) {+ return &types.Message{+ ID: "msg-1", AgentID: "agent", AgentTenantID: 7,+ Artifacts: types.MessageArtifacts{{URL: ref, FileName: "report.pdf"}},+ }, nil+ },+ },+ agentShareService: shares,+ resourceCatalog: &artifactCatalogStub{resource: &types.StoredResource{+ TenantID: 7, PhysicalPath: physical, StorageBackendID: "backend-7",+ }},+ tenantService: &artifactTenantStub{t: t},+ storageResolver: &artifactStorageStub{t: t, file: ownerFiles},+ fileService: globalFiles,+ }+ router := newArtifactTestRouter(h)+ request := func() *httptest.ResponseRecorder {+ w := httptest.NewRecorder()+ router.ServeHTTP(+ w,+ httptest.NewRequest(http.MethodGet, "/sessions/sess-1/messages/msg-1/artifacts/0/download", nil),+ )+ return w+ }+ w := request()+ if w.Code != http.StatusOK || w.Body.String() != "PDF-BYTES" ||+ w.Header().Get("Cache-Control") != "private, no-store" {+ t.Fatalf("status=%d body=%q cache=%q", w.Code, w.Body.String(), w.Header().Get("Cache-Control"))+ }+ shares.agent = nil+ w = request()+ if w.Code != http.StatusNotFound || ownerFiles.calls != 1 || globalFiles.calls != 0 {+ t.Fatalf(+ "revoked artifact: status=%d owner reads=%d global reads=%d",+ w.Code,+ ownerFiles.calls,+ globalFiles.calls,+ )+ }+}+func TestDownloadMessageArtifact_IndexOutOfRange(t *testing.T) {sessionID := "sess-1"messageID := "msg-1"@@ -269,3 +370,11 @@ func TestBuildAttachmentHeader_CJK(t *testing.T) {t.Fatalf("filename* contains raw CJK: %q", got)}}++func (s *artifactCatalogStub) GetMessageFileBindings(+ _ context.Context,+ _ uint64,+ _, messageID string,+) (*types.MessageFileBindings, error) {+ return &types.MessageFileBindings{MessageArtifact: messageID == "msg-1"}, nil+}diff --git a/internal/handler/session/handler.go b/internal/handler/session/handler.goindex 7498998f8..779437b39 100644--- a/internal/handler/session/handler.go+++ b/internal/handler/session/handler.go@@ -28,6 +28,7 @@ type Handler struct {agentShareService interfaces.AgentShareService // Service for resolving shared agents (KB scope in retrieval)kbShareService interfaces.KBShareService // Service for resolving shared KB permissionsfileService interfaces.FileService // Service for file storage (image uploads)+ resourceCatalog interfaces.ResourceCatalogstorageResolver interfaces.StorageBackendResolvermodelService interfaces.ModelService // Service for model management (VLM access)attachmentProcessor *AttachmentProcessor // Processor for file attachments@@ -52,6 +53,7 @@ func NewHandler(agentShareService interfaces.AgentShareService,kbShareService interfaces.KBShareService,fileService interfaces.FileService,+ resourceCatalog interfaces.ResourceCatalog,storageResolver interfaces.StorageBackendResolver,modelService interfaces.ModelService,documentReader interfaces.DocumentReader,@@ -72,6 +74,7 @@ func NewHandler(agentShareService: agentShareService,kbShareService: kbShareService,fileService: fileService,+ resourceCatalog: resourceCatalog,storageResolver: storageResolver,modelService: modelService,temporaryDocuments: temporaryDocuments,diff --git a/internal/handler/session/qa.go b/internal/handler/session/qa.goindex 795491c38..1e37fe580 100644--- a/internal/handler/session/qa.go+++ b/internal/handler/session/qa.go@@ -14,6 +14,7 @@ import ("sync""time"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/event""github.com/Tencent/WeKnora/internal/logger"@@ -236,7 +237,7 @@ func (h *Handler) parseQARequest(c *gin.Context, logPrefix string) (*qaRequestCotenantID := c.GetUint64(types.TenantIDContextKey.String())attachmentRuntimeCtx := ctxif effectiveTenantID != 0 {- attachmentRuntimeCtx = context.WithValue(ctx, types.TenantIDContextKey, effectiveTenantID)+ attachmentRuntimeCtx = types.WithExecutionTenant(ctx, effectiveTenantID)}// Use ASR only when the agent has audio upload enabled.@@ -631,8 +632,16 @@ func (h *Handler) setupSSEStream(reqCtx *qaRequestContext, generateTitle bool) *baseCtx := reqCtx.ctxif reqCtx.effectiveTenantID != 0 && h.tenantService != nil {if tenant, err := h.tenantService.GetTenantByID(reqCtx.ctx, reqCtx.effectiveTenantID); err == nil && tenant != nil {- baseCtx = context.WithValue(context.WithValue(reqCtx.ctx, types.TenantIDContextKey, reqCtx.effectiveTenantID), types.TenantInfoContextKey, tenant)- logger.Infof(reqCtx.ctx, "Using effective tenant %d for shared agent (model/KB/MCP)", reqCtx.effectiveTenantID)+ baseCtx = types.WithExecutionTenant(reqCtx.ctx, reqCtx.effectiveTenantID)+ if reqCtx.customAgent != nil {+ baseCtx = access.WithSharedAgent(baseCtx, reqCtx.customAgent)+ }+ baseCtx = context.WithValue(baseCtx, types.TenantInfoContextKey, tenant)+ logger.Infof(+ reqCtx.ctx,+ "Using effective tenant %d for shared agent (model/KB/MCP)",+ reqCtx.effectiveTenantID,+ )}}// The session's sandbox stays bound to the session owner even when thediff --git a/internal/handler/session/temporary_document.go b/internal/handler/session/temporary_document.goindex 22eaef45b..32918417d 100644--- a/internal/handler/session/temporary_document.go+++ b/internal/handler/session/temporary_document.go@@ -2,13 +2,12 @@ package sessionimport ("fmt"- "io"- "mime""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"@@ -151,25 +150,11 @@ func (h *Handler) PreviewTemporaryDocument(c *gin.Context) {c.Error(apperrors.NewInternalServerError("Failed to retrieve attachment").WithDetails(err.Error()))return}- defer file.Close()-- contentType, inline := secutils.SafeContentTypeByFilename(filename)- c.Header("Content-Type", contentType)- c.Header("X-Content-Type-Options", "nosniff")- disposition := "inline"- if !inline {- disposition = "attachment"- }- c.Header("Content-Disposition", mime.FormatMediaType(disposition, map[string]string{"filename": filename}))- c.Header("Cache-Control", "private, max-age=3600")-- c.Stream(func(w io.Writer) bool {- if _, err := io.Copy(w, file); err != nil {- logger.Errorf(ctx, "Failed to stream attachment preview: %v", err)- return false- }- return false- })+ 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) {diff --git a/internal/handler/session/wiki_fixer_scope.go b/internal/handler/session/wiki_fixer_scope.goindex bc65131f3..0f4871bc5 100644--- a/internal/handler/session/wiki_fixer_scope.go+++ b/internal/handler/session/wiki_fixer_scope.go@@ -3,6 +3,7 @@ package sessionimport ("context"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/types"secutils "github.com/Tencent/WeKnora/internal/utils"@@ -12,9 +13,7 @@ type wikiFixerKBLookup interface {GetKnowledgeBaseByIDOnly(ctx context.Context, id string) (*types.KnowledgeBase, error)}-type wikiFixerKBSharePermission interface {- CheckTenantKBPermission(ctx context.Context, kbID string, callerTenantID uint64, callerTenantRole types.TenantRole) (types.OrgMemberRole, bool, error)-}+type wikiFixerKBSharePermission = access.KBShareLookupfunc (h *Handler) resolveWikiFixerTenantScope(ctx context.Context,@@ -64,12 +63,13 @@ func resolveBuiltinWikiFixerTenantScope(return agent, 0}- permission, isShared, err := kbShare.CheckTenantKBPermission(ctx, kb.ID, currentTenantID, callerTenantRole)+ permissions := access.NewKBSharePermissions(ctx, kbShare, currentTenantID, callerTenantRole)+ allowed, err := permissions.Check(kb.ID, types.OrgRoleEditor)if err != nil {logger.Warnf(ctx, "wiki fixer: failed to check shared KB %s permission: %v", secutils.SanitizeForLog(kb.ID), err)return agent, 0}- if !isShared || !permission.HasPermission(types.OrgRoleEditor) {+ if !allowed {return agent, 0}diff --git a/internal/handler/shared_agent_access.go b/internal/handler/shared_agent_access.gonew file mode 100644index 000000000..dfcd47f06--- /dev/null+++ b/internal/handler/shared_agent_access.go@@ -0,0 +1,82 @@+package handler++import (+ stderrors "errors"++ "github.com/Tencent/WeKnora/internal/agent/tools"+ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/application/service"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/gin-gonic/gin"+)++// resolveSharedAgentForRequest is the identity/share boundary for KB listing,+// document search and batch restoration. KB-scope enforcement follows lookup.+func resolveSharedAgentForRequest(+ c *gin.Context,+ agentID string,+ agents access.SharedAgentLookup,+) (*types.CustomAgent, error) {+ ctx := c.Request.Context()+ request := middleware.KBAccessRequest(c)+ userID := request.Caller.UserID+ if request.Caller.TenantID == 0 || userID == "" {+ return nil, apperrors.NewUnauthorizedError("Unauthorized")+ }+ source, err := types.ParseAgentSourceTenantID(request.AgentSourceTenantID)+ if err != nil {+ return nil, apperrors.NewBadRequestError(err.Error())+ }+ if agents == nil {+ return nil, apperrors.NewForbiddenError("no permission for this shared agent")+ }+ agent, err := agents.GetSharedAgentForTenant(ctx, request.Caller.TenantID, request.Caller.Role, agentID, source)+ if err != nil {+ if stderrors.Is(err, service.ErrAgentShareNotFound) || stderrors.Is(err, service.ErrAgentSharePermission) ||+ stderrors.Is(err, service.ErrAgentNotFoundForShare) {+ return nil, apperrors.NewForbiddenError("no permission for this shared agent")+ }+ logger.ErrorWithFields(ctx, err, nil)+ return nil, apperrors.NewInternalServerError("Failed to verify shared agent access")+ }+ if agent == nil || agent.TenantID == 0 || (source != 0 && agent.TenantID != source) {+ return nil, apperrors.NewForbiddenError("no permission for this shared agent")+ }+ return agent, nil+}++func filterKnowledgeByAgentScope(knowledges []*types.Knowledge, scope types.SharedAgentKBScope) []*types.Knowledge {+ filtered := make([]*types.Knowledge, 0, len(knowledges))+ for _, knowledge := range knowledges {+ if knowledge != nil && scope.Allows(knowledge.KnowledgeBaseID, knowledge.TenantID) {+ filtered = append(filtered, knowledge)+ }+ }+ return filtered+}++// Scope filtering is shared by @KB listing and @file search. Capability checks+// constrain dynamic "all" selections; explicit selections keep their existing+// behavior. This filter does not replace API-key scope checks at the endpoint.+func filterKnowledgeBasesForSharedAgent(kbs []*types.KnowledgeBase, agent *types.CustomAgent) []*types.KnowledgeBase {+ scope := types.NewSharedAgentKBScope(agent)+ filtered := make([]*types.KnowledgeBase, 0, len(kbs))+ if scope.IsEmpty() {+ return filtered+ }+ filter := tools.DeriveKBFilterForAgent(agent.Config.AgentMode, agent.Config.AllowedTools)+ for _, kb := range kbs {+ if kb == nil || !scope.Allows(kb.ID, kb.TenantID) {+ continue+ }+ if scope.IsAll() && !filter.IsEmpty() &&+ !tools.KBSatisfiesAgentRequirements(kb.Capabilities(), agent.Config.AgentMode, agent.Config.AllowedTools) {+ continue+ }+ filtered = append(filtered, kb)+ }+ return filtered+}diff --git a/internal/handler/shared_agent_access_test.go b/internal/handler/shared_agent_access_test.gonew file mode 100644index 000000000..13632e90c--- /dev/null+++ b/internal/handler/shared_agent_access_test.go@@ -0,0 +1,245 @@+package handler++import (+ "context"+ "encoding/json"+ "errors"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++type scopedAgentStub struct {+ interfaces.AgentShareService+ agent *types.CustomAgent+ err error+ caller, source uint64+}++func (s *scopedAgentStub) GetSharedAgentForTenant(+ _ context.Context,+ caller uint64,+ _ types.TenantRole,+ _ string,+ source ...uint64,+) (*types.CustomAgent, error) {+ s.caller, s.source = caller, source[0]+ return s.agent, s.err+}++type scopedKBStub struct {+ interfaces.KnowledgeBaseService+ calls int+ kbs []*types.KnowledgeBase+}++func (s *scopedKBStub) ListKnowledgeBasesByTenantID(context.Context, uint64) ([]*types.KnowledgeBase, error) {+ s.calls+++ return s.kbs, nil+}++type scopedKnowledgeStub struct {+ interfaces.KnowledgeService+ batchCalls, searchCalls int+ knowledges []*types.Knowledge+ batchErr error+}++func (s *scopedKnowledgeStub) GetKnowledgeBatch(context.Context, uint64, []string) ([]*types.Knowledge, error) {+ s.batchCalls+++ return s.knowledges, s.batchErr+}++func (s *scopedKnowledgeStub) SearchKnowledgeForScopes(+ _ context.Context,+ scopes []types.KnowledgeSearchScope,+ _ string,+ _, _ int,+ _ []string,+) ([]*types.Knowledge, bool, int64, error) {+ s.searchCalls+++ var out []*types.Knowledge+ for _, k := range s.knowledges {+ if k == nil {+ continue+ }+ for _, scope := range scopes {+ if k.TenantID == scope.TenantID && k.KnowledgeBaseID == scope.KBID {+ out = append(out, k)+ break+ }+ }+ }+ return out, false, int64(len(out)), nil+}++func TestSharedAgentScopesAgreeAcrossListSearchAndBatch(t *testing.T) {+ gin.SetMode(gin.TestMode)+ for _, tt := range []struct {+ name, mode string+ ids []string+ expected []string+ restricted bool+ }{+ {name: "all", mode: "all", expected: []string{"a", "b"}},+ {name: "selected", mode: "selected", ids: []string{"a"}, expected: []string{"a"}},+ {name: "selected empty", mode: "selected"},+ {name: "selected blank", mode: "selected", ids: []string{""}},+ {name: "none", mode: "none", ids: []string{"a"}},+ {name: "unknown", mode: "invalid", ids: []string{"a"}},+ {name: "API key intersects all", mode: "all", restricted: true, expected: []string{"b"}},+ {name: "API key intersects selection", mode: "selected", ids: []string{"a"}, restricted: true},+ } {+ t.Run(tt.name, func(t *testing.T) {+ agents := &scopedAgentStub{+ agent: &types.CustomAgent{+ ID: "agent",+ TenantID: 2,+ Config: types.CustomAgentConfig{KBSelectionMode: tt.mode, KnowledgeBases: tt.ids},+ },+ }+ kbs := &scopedKBStub{kbs: []*types.KnowledgeBase{+ {ID: "a", TenantID: 2, Type: types.KnowledgeBaseTypeDocument},+ {ID: "b", TenantID: 2, Type: types.KnowledgeBaseTypeDocument},+ {ID: "foreign", TenantID: 3, Type: types.KnowledgeBaseTypeDocument},+ nil,+ }}+ knowledges := &scopedKnowledgeStub{knowledges: []*types.Knowledge{+ {ID: "a", TenantID: 2, KnowledgeBaseID: "a"},+ {ID: "b", TenantID: 2, KnowledgeBaseID: "b"},+ {ID: "foreign", TenantID: 3, KnowledgeBaseID: "a"},+ nil,+ }}+ kh := &KnowledgeHandler{kgService: knowledges, kbService: kbs, agentShareService: agents}+ bh := &KnowledgeBaseHandler{service: kbs, agentShareService: agents}+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ c.Set(types.TenantIDContextKey.String(), uint64(1))+ c.Set(types.UserIDContextKey.String(), "user")+ ctx := context.WithValue(c.Request.Context(), types.TenantIDContextKey, uint64(1))+ if tt.restricted {+ ctx = types.WithTenantAPIKeyScope(+ ctx,+ types.TenantAPIKeyScope{KnowledgeBaseIDs: types.StringArray{"b"}},+ )+ }+ c.Request = c.Request.WithContext(ctx)+ c.Next()+ })+ r.GET("/kbs", bh.ListKnowledgeBases)+ r.GET("/search", kh.SearchKnowledge)+ r.GET("/batch", kh.GetKnowledgeBatch)+ for _, path := range []string{"/kbs", "/search", "/batch"} {+ w := httptest.NewRecorder()+ r.ServeHTTP(+ w,+ httptest.NewRequest(+ http.MethodGet,+ path+"?agent_id=agent&agent_source_tenant_id=2&keyword=test&ids=a&ids=b",+ nil,+ ),+ )+ require.Equal(t, http.StatusOK, w.Code, "%s: %s", path, w.Body.String())+ var body struct {+ Data []struct {+ ID string `json:"id"`+ } `json:"data"`+ }+ require.NoError(t, json.Unmarshal(w.Body.Bytes(), &body))+ var ids []string+ for _, row := range body.Data {+ ids = append(ids, row.ID)+ }+ require.ElementsMatch(t, tt.expected, ids, path)+ }+ require.Equal(t, uint64(1), agents.caller)+ require.Equal(t, uint64(2), agents.source)+ if types.NewSharedAgentKBScope(agents.agent).IsEmpty() {+ require.Zero(t, kbs.calls)+ require.Zero(t, knowledges.batchCalls)+ require.Zero(t, knowledges.searchCalls)+ }+ })+ }+}++func TestSharedAgentLookupFailuresDoNotReachBatchRetrieval(t *testing.T) {+ for _, tt := range []struct {+ name string+ agent *types.CustomAgent+ err error+ source string+ status int+ }{+ {name: "revoked or missing", status: http.StatusForbidden},+ {name: "source mismatch", agent: &types.CustomAgent{TenantID: 3}, source: "2", status: http.StatusForbidden},+ {name: "invalid source", source: "invalid", status: http.StatusBadRequest},+ {name: "lookup unavailable", err: errors.New("offline"), status: http.StatusInternalServerError},+ } {+ t.Run(tt.name, func(t *testing.T) {+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ c.Set(types.TenantIDContextKey.String(), uint64(1))+ c.Set(types.UserIDContextKey.String(), "user")+ c.Next()+ })+ h := &KnowledgeHandler{agentShareService: &scopedAgentStub{agent: tt.agent, err: tt.err}}+ r.GET("/batch", h.GetKnowledgeBatch)+ w := httptest.NewRecorder()+ r.ServeHTTP(+ w,+ httptest.NewRequest(+ http.MethodGet,+ "/batch?ids=a&agent_id=agent&agent_source_tenant_id="+tt.source,+ nil,+ ),+ )+ require.Equal(t, tt.status, w.Code, w.Body.String())+ })+ }+}++func TestSharedAgentCapabilityFilterRetainsExplicitSelection(t *testing.T) {+ kb := &types.KnowledgeBase{ID: "wiki", TenantID: 2, IndexingStrategy: types.IndexingStrategy{WikiEnabled: true}}+ agent := &types.CustomAgent{+ TenantID: 2,+ Config: types.CustomAgentConfig{AgentMode: "quick-answer", KBSelectionMode: "all"},+ }+ require.Empty(t, filterKnowledgeBasesForSharedAgent([]*types.KnowledgeBase{kb}, agent))+ agent.Config.KBSelectionMode = "selected"+ agent.Config.KnowledgeBases = []string{"wiki"}+ require.Len(t, filterKnowledgeBasesForSharedAgent([]*types.KnowledgeBase{kb}, agent), 1)+}++func TestExplicitKBBatchReadPropagatesRepositoryFailure(t *testing.T) {+ gin.SetMode(gin.TestMode)+ kbs := &scopedBatchKBStub{}+ knowledge := &scopedKnowledgeStub{batchErr: errors.New("storage unavailable")}+ h := &KnowledgeHandler{kgService: knowledge, kbService: kbs}+ r := gin.New()+ r.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ ctx := types.WithExecutionTenant(c.Request.Context(), 1)+ ctx = types.WithCaller(ctx, types.Caller{TenantID: 1, UserID: "user", Role: types.TenantRoleAdmin})+ c.Request = c.Request.WithContext(ctx)+ c.Next()+ })+ r.GET("/batch", h.GetKnowledgeBatch)+ w := httptest.NewRecorder()+ r.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/batch?kb_id=kb&ids=doc", nil))+ require.Equal(t, http.StatusInternalServerError, w.Code, w.Body.String())+ require.Equal(t, 1, knowledge.batchCalls)+}++type scopedBatchKBStub struct {+ interfaces.KnowledgeBaseService+}++func (*scopedBatchKBStub) GetKnowledgeBaseByID(context.Context, string) (*types.KnowledgeBase, error) {+ return &types.KnowledgeBase{ID: "kb", TenantID: 1}, nil+}diff --git a/internal/handler/tag.go b/internal/handler/tag.goindex 3145d179f..59b2a2b58 100644--- a/internal/handler/tag.go+++ b/internal/handler/tag.go@@ -2,16 +2,17 @@ package handlerimport ("context"+ stderrors "errors"+ "io""net/http""strconv"- "github.com/gin-gonic/gin"-"github.com/Tencent/WeKnora/internal/errors""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces"secutils "github.com/Tencent/WeKnora/internal/utils"+ "github.com/gin-gonic/gin")// TagHandler handles knowledge base tag operations.@@ -235,19 +236,42 @@ func (h *TagHandler) DeleteTag(c *gin.Context) {contentOnly := c.Query("content_only") == "true"var req DeleteTagRequest- _ = c.ShouldBindJSON(&req)+ if err := c.ShouldBindJSON(&req); err != nil && !stderrors.Is(err, io.EOF) {+ _ = c.Error(errors.NewBadRequestError("删除选项不合法"))+ return+ }var excludeUUIDs []stringif len(req.ExcludeIDs) > 0 {tenantID := types.MustTenantIDFromContext(ctx)+ wanted := make(map[int64]bool, len(req.ExcludeIDs))+ for _, id := range req.ExcludeIDs {+ if id <= 0 {+ _ = c.Error(errors.NewBadRequestError("排除条目 ID 必须为正整数"))+ return+ }+ wanted[id] = true+ }chunks, err := h.getChunksBySeqIDs(ctx, tenantID, req.ExcludeIDs)if err != nil {- logger.Warnf(ctx, "Failed to resolve exclude_ids: %v", err)- } else {- excludeUUIDs = make([]string, len(chunks))- for i, chunk := range chunks {- excludeUUIDs[i] = chunk.ID+ _ = c.Error(err)+ return+ }+ for _, chunk := range chunks {+ if chunk == nil || !wanted[chunk.SeqID] {+ continue}+ if chunk.TenantID != tenantID || chunk.KnowledgeBaseID != c.Param("id") ||+ chunk.ChunkType != types.ChunkTypeFAQ {+ _ = c.Error(errors.NewForbiddenError("排除条目不属于当前知识库"))+ return+ }+ excludeUUIDs = append(excludeUUIDs, chunk.ID)+ delete(wanted, chunk.SeqID)+ }+ if len(wanted) != 0 {+ _ = c.Error(errors.NewNotFoundError("排除条目不存在"))+ return}}diff --git a/internal/handler/tag_delete_test.go b/internal/handler/tag_delete_test.gonew file mode 100644index 000000000..446937635--- /dev/null+++ b/internal/handler/tag_delete_test.go@@ -0,0 +1,109 @@+package handler++import (+ "context"+ "errors"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/Tencent/WeKnora/internal/middleware"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin"+ "github.com/stretchr/testify/require"+)++type tagDeleteServiceSpy struct {+ interfaces.KnowledgeTagService+ calls int+ excluded []string+}++func (s *tagDeleteServiceSpy) DeleteTag(_ context.Context, _ string, _, _ bool, excluded []string) error {+ s.calls+++ s.excluded = excluded+ return nil+}++type tagDeleteChunks struct {+ interfaces.ChunkRepository+ chunks []*types.Chunk+ err error+}++func (s *tagDeleteChunks) ListChunksBySeqID(context.Context, uint64, []int64) ([]*types.Chunk, error) {+ return s.chunks, s.err+}++func TestTagDeletionNeverIgnoresInvalidExclusions(t *testing.T) {+ gin.SetMode(gin.TestMode)+ for _, tt := range []struct {+ name, body string+ chunks []*types.Chunk+ err error+ status int+ }{+ {name: "invalid JSON", body: `{`, status: 400},+ {name: "missing exclusion", body: `{"exclude_ids":[1]}`, status: 404},+ {name: "lookup failure", body: `{"exclude_ids":[1]}`, err: errors.New("database unavailable"), status: 500},+ {+ name: "foreign exclusion",+ body: `{"exclude_ids":[1]}`,+ chunks: []*types.Chunk{{+ ID: "one",+ SeqID: 1,+ TenantID: 7,+ KnowledgeBaseID: "other",+ ChunkType: types.ChunkTypeFAQ,+ }},+ status: 403,+ },++ {+ name: "valid exclusion",+ body: `{"exclude_ids":[1]}`,+ chunks: []*types.Chunk{{+ ID: "one",+ SeqID: 1,+ TenantID: 7,+ KnowledgeBaseID: "kb",+ ChunkType: types.ChunkTypeFAQ,+ }},+ status: 200,+ },++ {name: "optional empty body", status: 200},+ } {+ t.Run(tt.name, func(t *testing.T) {+ svc := &tagDeleteServiceSpy{}+ h := &TagHandler{tagService: svc, chunkRepo: &tagDeleteChunks{chunks: tt.chunks, err: tt.err}}+ router := gin.New()+ router.Use(middleware.ErrorHandler(), func(c *gin.Context) {+ c.Request = c.Request.WithContext(+ context.WithValue(c.Request.Context(), types.TenantIDContextKey, uint64(7)),+ )+ c.Next()+ })+ router.DELETE("/knowledge-bases/:id/tags/:tag_id", h.DeleteTag)+ w := httptest.NewRecorder()+ req := httptest.NewRequest(+ http.MethodDelete,+ "/knowledge-bases/kb/tags/tag?force=true",+ strings.NewReader(tt.body),+ )+ req.Header.Set("Content-Type", "application/json")+ router.ServeHTTP(w, req)+ require.Equal(t, tt.status, w.Code, w.Body.String())+ if tt.status == 200 {+ require.Equal(t, 1, svc.calls)+ if tt.body != "" {+ require.Equal(t, []string{"one"}, svc.excluded)+ }+ } else {+ require.Zero(t, svc.calls)+ }+ })+ }+}diff --git a/internal/middleware/auth_context.go b/internal/middleware/auth_context.goindex 471213060..f3e2a3410 100644--- a/internal/middleware/auth_context.go+++ b/internal/middleware/auth_context.go@@ -77,5 +77,10 @@ func applyAuthSession(c *gin.Context, s authSession) {set(key, v)}+ userID := ""+ if s.User != nil {+ userID = s.User.ID+ }+ ctx = types.WithCaller(ctx, types.Caller{TenantID: s.TenantID, UserID: userID, Role: s.Role})c.Request = c.Request.WithContext(ctx)}diff --git a/internal/middleware/auth_context_test.go b/internal/middleware/auth_context_test.goindex d756f16d5..7986ec77a 100644--- a/internal/middleware/auth_context_test.go+++ b/internal/middleware/auth_context_test.go@@ -34,6 +34,10 @@ func TestApplyAuthSessionSetsBothSurfaces(t *testing.T) {})ctx := c.Request.Context()+ caller := types.Caller{TenantID: 7, UserID: "u1", Role: types.TenantRoleAdmin}+ if got := types.CallerFromContext(types.WithExecutionTenant(ctx, 9)); got != caller {+ t.Fatalf("execution switch changed authenticated caller: %+v", got)+ }if got, ok := types.TenantIDFromContext(ctx); !ok || got != 7 {t.Fatalf("ctx tenant id = %d, ok=%v", got, ok)}diff --git a/internal/middleware/kb_access.go b/internal/middleware/kb_access.goindex 66bbfc1c1..456d55312 100644--- a/internal/middleware/kb_access.go+++ b/internal/middleware/kb_access.go@@ -4,6 +4,7 @@ import ("context"stderrors "errors"+ "github.com/Tencent/WeKnora/internal/application/access"apprepo "github.com/Tencent/WeKnora/internal/application/repository""github.com/Tencent/WeKnora/internal/config"apperrors "github.com/Tencent/WeKnora/internal/errors"@@ -13,54 +14,10 @@ import ("github.com/gin-gonic/gin")-// kb_access.go centralises the share-fallback that previously lived as-// near-identical 30-line helpers in five handler files (chunk.go,-// faq.go, tag.go, knowledge.go, knowledgebase.go). Each was a copy of-// the same three checks:-//-// 1. KB belongs to caller's tenant -> grant own access-// 2. Org-shared KB -> grant min(share, role) cap-// 3. Shared agent carries the KB -> grant Viewer (read-only)-//-// Putting the resolution in a route-level gin.HandlerFunc makes the-// route declaration the single source of truth for "what permission-// is required" and "where does the kb_id come from". Handlers no-// longer carry an effectiveCtxForKB / validateAndGetKnowledgeBase-// helper — the guard runs first, stashes the resolution under-// KBAccessContextKey and rewrites c.Request to carry the-// effective-tenant-ID context, then handlers just read TenantIDFromContext-// the way they always did.-//-// Plan 3's 3-D cap (tenant Viewer pinned to OrgRoleViewer) is enforced-// inside CheckTenantKBPermission itself, so the guard here just-// propagates the result.-//-// ⚠️ Tenant id has TWO surfaces on a gin.Context:-//-// - c.Request.Context() (read via types.TenantIDFromContext)-// - c.Keys[TenantIDContextKey] (read via c.Get / c.GetUint64)-//-// The guard rewrites ONLY the request context — c.Keys is intentionally-// left at the caller's own tenant so handlers that still run their own-// share resolution (currently knowledge.go / knowledgebase.go, which-// branch on the ?agent_id query) keep working unchanged. New handlers-// MUST read tenant from c.Request.Context() (the "effective" tenant-// for shared KBs); reading from c.Keys after this guard runs gives-// the caller's own tenant, which is almost always the wrong answer-// for KB-scoped routes. The FAQ / Tag / Chunk handlers in this PR-// were converted to the ctx-based read; the migration of knowledge.go-// / knowledgebase.go is a follow-up.--// KBAccess captures the result of a successful KB access resolution.-// Stashed on gin.Context under KBAccessContextKey so handlers that-// need the resolved KB / permission (e.g. to render-// my_permission in the response) can pull it without re-running the-// resolution.-type KBAccess struct {- KnowledgeBase *types.KnowledgeBase- EffectiveTenantID uint64- Permission types.OrgMemberRole-}+// KBAccess aliases the shared policy result. This adapter resolves route+// parameters, applies the RBAC rollout switch, and scopes downstream services+// to the resource tenant. Gin's tenant key retains the authenticated caller.+type KBAccess = access.KBAccess// KBAccessContextKey is the gin.Context key under which a successful// KB access resolution is stored.@@ -75,10 +32,10 @@ func KBAccessFromContext(c *gin.Context) (*KBAccess, bool) {return nil, false}a, ok := v.(*KBAccess)- return a, ok+ return a, ok && a != nil}-// KBLookup is the minimum surface ResolveKBAccess needs from the+// KBLookup is the minimum surface the guard needs from the// knowledge-base service: a single method that turns an ID into a// KnowledgeBase pointer (or repo.ErrKnowledgeBaseNotFound). Defining// it as a tiny dedicated interface keeps the guard testable without@@ -254,9 +211,9 @@ func RequireKBAccess(// regardless of whether RBAC enforcement is active.enforcing := rbacEnforcementEnabled(cfg)- access, err := resolveKBAccessOnce(ctx, c, kbID, requiredPermission, kbService, kbShareService, agentShareService)+ grant, err := resolveKBAccess(ctx, c, kbID, requiredPermission, kbService, kbShareService, agentShareService)switch {- case stderrors.Is(err, errKBAccessUnauthorized):+ case stderrors.Is(err, access.ErrUnauthorized):if !enforcing {logger.Warnf(ctx, "[rbac] kb-access would 401 (enforcement off): kb=%s", kbID)c.Next()@@ -265,14 +222,14 @@ func RequireKBAccess(_ = c.Error(apperrors.NewUnauthorizedError("Unauthorized"))c.Abort()return- case stderrors.Is(err, errKBAccessNotFound):+ case stderrors.Is(err, access.ErrNotFound):// 404 still fires when enforcement is off — a missing KB is// not an authorisation event, the client genuinely asked// for nothing._ = c.Error(apperrors.NewNotFoundError("knowledge base not found"))c.Abort()return- case stderrors.Is(err, errKBAccessForbidden):+ case stderrors.Is(err, access.ErrForbidden):if !enforcing {logger.Warnf(ctx, "[rbac] kb-access would 403 (enforcement off): kb=%s required=%s",kbID, requiredPermission)@@ -282,7 +239,7 @@ func RequireKBAccess(_ = c.Error(apperrors.NewForbiddenError("Permission denied to access this knowledge base"))c.Abort()return- case stderrors.Is(err, errKBAccessBadRequest):+ case stderrors.Is(err, access.ErrInvalidAgentSource):_ = c.Error(apperrors.NewBadRequestError("invalid agent_source_tenant_id"))c.Abort()return@@ -299,25 +256,37 @@ func RequireKBAccess(// effective tenant id. Handlers reading tenant from context now// see the source-tenant for shared KBs (so retrieval queries// hit the right embedding store) without having to know.- c.Set(KBAccessContextKey, access)- newCtx := context.WithValue(ctx, types.TenantIDContextKey, access.EffectiveTenantID)+ c.Set(KBAccessContextKey, grant)+ newCtx := grant.Context(ctx)c.Request = c.Request.WithContext(newCtx)c.Next()}}-// resolveKBAccessOnce performs the actual three-step resolution. Kept-// unexported and using package-private sentinel errors so the guard's-// error mapping is the only public surface.-//-// The shared-agent step honours the ?agent_id query parameter when-// present, mirroring the in-handler resolution in-// knowledgebase.go's validateAndGetKnowledgeBase: a request with a-// specific agent_id is validated against THAT agent's KB scope (mode =-// all / selected / none), not against "any shared agent". Falling-// back to "any shared agent" when agent_id is empty preserves the-// "通过智能体可见" KB list entry point.-func resolveKBAccessOnce(+// KBAccessRequest captures caller identity before a guard scopes the request+// context to a shared resource. The stored grant also supports nested guards.+func KBAccessRequest(c *gin.Context) access.KBRequest {+ ctx := c.Request.Context()+ caller := types.CallerFromContext(ctx)+ if _, captured := ctx.Value(types.CallerContextKey).(types.Caller); !captured {+ // Compatibility for direct handler invocations that only seed Gin.+ if tenantID, ok := c.Get(types.TenantIDContextKey.String()); ok {+ caller.TenantID, _ = tenantID.(uint64)+ } else if grant, found := KBAccessFromContext(c); found {+ caller = grant.Caller+ }+ if userID, ok := c.Get(types.UserIDContextKey.String()); ok {+ caller.UserID, _ = userID.(string)+ }+ }+ return access.KBRequest{+ Caller: caller,+ AgentID: c.Query("agent_id"),+ AgentSourceTenantID: c.Query(types.AgentSourceTenantIDParam),+ }+}++func resolveKBAccess(ctx context.Context,c *gin.Context,kbID string,@@ -326,140 +295,16 @@ func resolveKBAccessOnce(kbShareService interfaces.KBShareService,agentShareService interfaces.AgentShareService,) (*KBAccess, error) {- tenantID, ok := types.TenantIDFromContext(ctx)- if !ok || tenantID == 0 {- return nil, errKBAccessUnauthorized+ request := KBAccessRequest(c)+ if request.Caller.TenantID == 0 {+ return nil, access.ErrUnauthorized}- callerTenantRole := types.TenantRoleFromContext(ctx)-kb, err := kbService.GetKnowledgeBaseByID(ctx, kbID)if err != nil {if stderrors.Is(err, apprepo.ErrKnowledgeBaseNotFound) {- return nil, errKBAccessNotFound+ return nil, access.ErrNotFound}return nil, err}- if kb == nil {- return nil, errKBAccessNotFound- }-- // 1. Own KB.- if kb.TenantID == tenantID {- return &KBAccess{- KnowledgeBase: kb,- EffectiveTenantID: tenantID,- Permission: types.OrgRoleAdmin,- }, nil- }-- // 2. Org-shared KB. Plan 3's 3-D cap is applied inside- // CheckTenantKBPermission; we just check the result satisfies- // the minimum requirement.- if kbShareService != nil {- permission, isShared, permErr := kbShareService.CheckTenantKBPermission(ctx, kbID, tenantID, callerTenantRole)- if permErr == nil && isShared && permission.HasPermission(requiredPermission) {- source, srcErr := kbShareService.GetKBSourceTenant(ctx, kbID)- if srcErr == nil {- logger.Infof(ctx, "[kb_access] tenant %d -> shared KB %s perm=%s source=%d",- tenantID, kbID, permission, source)- return &KBAccess{- KnowledgeBase: kb,- EffectiveTenantID: source,- Permission: permission,- }, nil- }- }- }-- // 3. Shared agent that carries this KB — only ever grants read.- if requiredPermission == types.OrgRoleViewer && agentShareService != nil {- access, agentErr := resolveSharedAgentAccess(ctx, c, tenantID, callerTenantRole, kb, agentShareService)- if agentErr != nil {- return nil, agentErr- }- if access != nil {- return access, nil- }- }-- logger.Warnf(ctx, "[kb_access] tenant %d -> KB %s denied (required=%s)", tenantID, kbID, requiredPermission)- return nil, errKBAccessForbidden+ return access.ResolveKB(ctx, request, kb, requiredPermission, kbShareService, agentShareService)}--// resolveSharedAgentAccess implements the agent-share fallback,-// mirroring knowledgebase.go's in-handler logic so the guard and the-// (still-present) handler resolver agree on which requests pass.-//-// - If ?agent_id=X is provided, validate against THAT agent's-// KBSelectionMode (all / selected / none). A mismatch means deny;-// we do NOT fall back to "any shared agent" because the client-// explicitly named one (typically from a @-mention or a deep link-// scoped to that agent).-// - If ?agent_id is empty, allow when any shared agent reachable by-// the caller can access this KB ("通过智能体可见" KB list entry).-func resolveSharedAgentAccess(- ctx context.Context,- c *gin.Context,- tenantID uint64,- callerTenantRole types.TenantRole,- kb *types.KnowledgeBase,- agentShareService interfaces.AgentShareService,-) (*KBAccess, error) {- agentID := c.Query("agent_id")- if agentID != "" {- sourceTenantID, err := types.ParseAgentSourceTenantID(c.Query(types.AgentSourceTenantIDParam))- if err != nil {- return nil, errKBAccessBadRequest- }- agent, err := agentShareService.GetSharedAgentForTenant(ctx, tenantID, callerTenantRole, agentID, sourceTenantID)- if err != nil || agent == nil {- return nil, nil- }- if kb.TenantID != agent.TenantID {- logger.Warnf(ctx, "[kb_access] shared agent workspace mismatch: kb=%s kb.tenant=%d agent.tenant=%d",- kb.ID, kb.TenantID, agent.TenantID)- return nil, nil- }- switch agent.Config.KBSelectionMode {- case "all":- logger.Infof(ctx, "[kb_access] tenant %d -> KB %s via shared agent %s (mode=all)",- tenantID, kb.ID, agentID)- return &KBAccess{- KnowledgeBase: kb,- EffectiveTenantID: kb.TenantID,- Permission: types.OrgRoleViewer,- }, nil- case "selected":- for _, allowedID := range agent.Config.KnowledgeBases {- if allowedID == kb.ID {- logger.Infof(ctx, "[kb_access] tenant %d -> KB %s via shared agent %s (mode=selected)",- tenantID, kb.ID, agentID)- return &KBAccess{- KnowledgeBase: kb,- EffectiveTenantID: kb.TenantID,- Permission: types.OrgRoleViewer,- }, nil- }- }- }- return nil, nil- }-- can, err := agentShareService.TenantCanAccessKBViaSomeSharedAgent(ctx, tenantID, callerTenantRole, kb)- if err == nil && can {- logger.Infof(ctx, "[kb_access] tenant %d -> KB %s via some shared agent", tenantID, kb.ID)- return &KBAccess{- KnowledgeBase: kb,- EffectiveTenantID: kb.TenantID,- Permission: types.OrgRoleViewer,- }, nil- }- return nil, nil-}--var (- errKBAccessUnauthorized = stderrors.New("kb_access: unauthorized")- errKBAccessNotFound = stderrors.New("kb_access: not found")- errKBAccessForbidden = stderrors.New("kb_access: forbidden")- errKBAccessBadRequest = stderrors.New("kb_access: bad request")-)diff --git a/internal/middleware/kb_access_test.go b/internal/middleware/kb_access_test.goindex d552ab8f2..57e722034 100644--- a/internal/middleware/kb_access_test.go+++ b/internal/middleware/kb_access_test.go@@ -33,13 +33,12 @@ func (s *stubKBLookup) GetKnowledgeBaseByID(_ context.Context, id string) (*type}// stubKBShareForGuard implements just the methods the guard touches —-// CheckTenantKBPermission and GetKBSourceTenant. The other methods on+// CheckTenantKBPermission. The other methods on// the interface panic so any unintended new dependency surfaces// immediately.type stubKBShareForGuard struct {permission map[string]types.OrgMemberRoleshared map[string]bool- source map[string]uint64}func (s *stubKBShareForGuard) CheckTenantKBPermission(_ context.Context, kbID string, _ uint64, _ types.TenantRole) (types.OrgMemberRole, bool, error) {@@ -50,48 +49,57 @@ func (s *stubKBShareForGuard) CheckTenantKBPermission(_ context.Context, kbID st}func (s *stubKBShareForGuard) GetKBSourceTenant(_ context.Context, kbID string) (uint64, error) {- if v, ok := s.source[kbID]; ok {- return v, nil- }- return 0, errors.New("not found")+ panic("the loaded KB already carries its authoritative tenant")}func (s *stubKBShareForGuard) ShareKnowledgeBase(context.Context, string, string, string, uint64, types.OrgMemberRole) (*types.KnowledgeBaseShare, error) {panic("not implemented")}+func (s *stubKBShareForGuard) UpdateSharePermission(context.Context, string, types.OrgMemberRole, string, uint64) error {panic("not implemented")}+func (s *stubKBShareForGuard) RemoveShare(context.Context, string, string, uint64) error {panic("not implemented")}+func (s *stubKBShareForGuard) ListSharesByKnowledgeBase(context.Context, string, uint64) ([]*types.KnowledgeBaseShare, error) {panic("not implemented")}+func (s *stubKBShareForGuard) ListSharesByOrganization(context.Context, string) ([]*types.KnowledgeBaseShare, error) {panic("not implemented")}+func (s *stubKBShareForGuard) ListSharedKnowledgeBases(context.Context, uint64, types.TenantRole) ([]*types.SharedKnowledgeBaseInfo, error) {panic("not implemented")}+func (s *stubKBShareForGuard) ListSharedKnowledgeBasesInOrganization(context.Context, string, uint64, types.TenantRole) ([]*types.OrganizationSharedKnowledgeBaseItem, error) {panic("not implemented")}+func (s *stubKBShareForGuard) ListSharedKnowledgeBaseIDsByOrganizations(context.Context, []string, uint64) (map[string][]string, error) {panic("not implemented")}+func (s *stubKBShareForGuard) GetShare(context.Context, string) (*types.KnowledgeBaseShare, error) {panic("not implemented")}+func (s *stubKBShareForGuard) GetShareByKBAndOrg(context.Context, string, string) (*types.KnowledgeBaseShare, error) {panic("not implemented")}+func (s *stubKBShareForGuard) HasTenantKBPermission(context.Context, string, uint64, types.TenantRole, types.OrgMemberRole) (bool, error) {panic("not implemented")}+func (s *stubKBShareForGuard) CountSharesByKnowledgeBaseIDs(context.Context, []string) (map[string]int64, error) {panic("not implemented")}+func (s *stubKBShareForGuard) CountByOrganizations(context.Context, []string) (map[string]int64, error) {panic("not implemented")}@@ -121,36 +129,47 @@ func (s *stubAgentShareForGuard) TenantCanAccessKBViaSomeSharedAgent(_ context.Cfunc (s *stubAgentShareForGuard) ShareAgent(context.Context, string, string, string, uint64, types.OrgMemberRole) (*types.AgentShare, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) RemoveShare(context.Context, string, string, uint64) error {panic("not implemented")}+func (s *stubAgentShareForGuard) ListSharesByAgent(context.Context, string, uint64) ([]*types.AgentShare, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) ListSharesByOrganization(context.Context, string) ([]*types.AgentShare, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) ListSharedAgents(context.Context, uint64, types.TenantRole) ([]*types.SharedAgentInfo, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) ListSharedAgentsInOrganization(context.Context, string, uint64, types.TenantRole) ([]*types.OrganizationSharedAgentItem, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) ListSharedAgentsInOrganizations(context.Context, []string, uint64, types.TenantRole) (map[string][]*types.OrganizationSharedAgentItem, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) SetSharedAgentDisabledByMe(context.Context, uint64, string, uint64, bool) error {panic("not implemented")}+func (s *stubAgentShareForGuard) GetShare(context.Context, string) (*types.AgentShare, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) GetShareByAgentAndOrg(context.Context, string, string) (*types.AgentShare, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) GetShareByAgentIDForTenant(context.Context, uint64, string, uint64) (*types.AgentShare, error) {panic("not implemented")}+func (s *stubAgentShareForGuard) CountByOrganizations(context.Context, []string) (map[string]int64, error) {panic("not implemented")}@@ -277,7 +296,6 @@ func TestRequireKBAccess_SharedKB_RewritesTenantContext(t *testing.T) {share := &stubKBShareForGuard{permission: map[string]types.OrgMemberRole{"kb-shared": types.OrgRoleEditor},shared: map[string]bool{"kb-shared": true},- source: map[string]uint64{"kb-shared": 200},}_, c := runGuard(t, 100, "kb-shared",types.OrgRoleEditor,@@ -297,7 +315,6 @@ func TestRequireKBAccess_SharedKB_PermissionBelowMin_Aborts(t *testing.T) {share := &stubKBShareForGuard{permission: map[string]types.OrgMemberRole{"kb-shared": types.OrgRoleViewer},shared: map[string]bool{"kb-shared": true},- source: map[string]uint64{"kb-shared": 200},}_, c := runGuard(t, 100, "kb-shared",types.OrgRoleEditor, // require Editor@@ -500,7 +517,6 @@ func TestRequireKBAccess_Forbidden_FailOpenWhenRBACDisabled(t *testing.T) {share := &stubKBShareForGuard{permission: map[string]types.OrgMemberRole{"kb-shared": types.OrgRoleViewer},shared: map[string]bool{"kb-shared": true},- source: map[string]uint64{"kb-shared": 200},}kbsvc := &stubKBLookup{kbs: map[string]*types.KnowledgeBase{"kb-shared": {ID: "kb-shared", TenantID: 200},diff --git a/internal/middleware/rbac.go b/internal/middleware/rbac.goindex 2dc314acf..746783bca 100644--- a/internal/middleware/rbac.go+++ b/internal/middleware/rbac.go@@ -6,6 +6,7 @@ import ("net/http""sync"+ "github.com/Tencent/WeKnora/internal/application/access""github.com/Tencent/WeKnora/internal/config""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/types"@@ -20,7 +21,7 @@ import (// own 404 — middleware-level 403 would hide real "URL is wrong" failures// behind a permissions error, which breaks client diagnostics and// operator dashboards.-var ErrResourceNotFound = errors.New("rbac: resource not found")+var ErrResourceNotFound = access.ErrResourceNotFound// CreatorLookup resolves the creator user ID for the resource targeted// by the current request, based on whatever is on the gin.Context (URL@@ -75,7 +76,7 @@ func RequireRole(min types.TenantRole, cfg *config.Config) gin.HandlerFunc {c.Next()return}- role := types.TenantRoleFromContext(ctx)+ role := types.CallerFromContext(ctx).Roleif role.HasPermission(min) {c.Next()return@@ -100,7 +101,7 @@ func RequireRole(min types.TenantRole, cfg *config.Config) gin.HandlerFunc {// dedup inside the service so probing clients can't fill the// table.if svc := AuditServiceFromContext(c); svc != nil {- tenantID, _ := types.TenantIDFromContext(ctx)+ tenantID := types.CallerFromContext(ctx).TenantID_ = svc.LogDenied(ctx, c, tenantID, uid, string(role), min)}c.JSON(http.StatusForbidden, gin.H{@@ -175,7 +176,7 @@ func RequireSystemAdmin(cfg *config.Config) gin.HandlerFunc {uid, c.Request.URL.Path)// Durable audit row for the reject — same dedup as RequireRole.if svc := AuditServiceFromContext(c); svc != nil {- tenantID, _ := types.TenantIDFromContext(ctx)+ tenantID := types.CallerFromContext(ctx).TenantID_ = svc.LogDenied(ctx, c, tenantID, uid, "user", "system_admin")}c.JSON(http.StatusForbidden, gin.H{@@ -194,7 +195,8 @@ func RequireSystemAdmin(cfg *config.Config) gin.HandlerFunc {// is responsible for translating the URL into the resource's creator// user ID (see CreatorLookup for the return-value contract).//-// Decision order:+// API-key principals skip this human ownership gate; route capabilities and+// allowed KB scope remain mandatory. For human callers, decision order is:// 1. role >= min -> allow without running lookup.// 2. cross-tenant superuser -> allow without running lookup.// 3. enforcement off -> log, allow without running lookup. This is the@@ -213,81 +215,35 @@ func RequireOwnershipOrRole(min types.TenantRole, lookup CreatorLookup, cfg *conwarnOnNilConfig(cfg)return func(c *gin.Context) {ctx := c.Request.Context()- // API-key principals are authorized solely by the APIKeyGate.- // Ownership ("creator OR Admin+") is a human concept that cannot- // apply to a machine principal (its synthetic system-user never- // matches creator_id), so short-circuit here. KB-scope for API- // keys is still enforced by the KBAccess guards + handler checks.- if _, ok := types.TenantAPIKeyScopeFromContext(ctx); ok {- c.Next()- return- }- role := types.TenantRoleFromContext(ctx)-- // 1. Fast path: role meets the bar.- if role.HasPermission(min) {- c.Next()- return+ request := ownershipRequestFromContext(ctx, cfg)+ var resolveCreator func() (string, error)+ if lookup != nil {+ resolveCreator = func() (string, error) { return lookup(c) }}-- // 2. Cross-tenant superuser bypass — same reasoning as RequireRole.- if IsCrossTenantSuperuser(ctx, cfg) {- c.Next()- return- }-- uid, _ := types.UserIDFromContext(ctx)-- // 3. Fail-open shortcut: when enforcement is off, do NOT run the- // lookup. Running it would add a hidden DB roundtrip on every- // mutating request during the rollout window — see #1318 review.- if !rbacEnforcementEnabled(cfg) {- logger.Warnf(ctx,- "[rbac] ownership/role would be checked (enforcement off, lookup skipped): "+- "user=%s have=%s need=%s path=%s",- uid, role, min, c.Request.URL.Path)- c.Next()- return- }-- creator, err := lookup(c)+ decision, err := access.CheckOwnershipOrRole(request, min, resolveCreator)+ logOwnershipDecision(ctx, request, min, decision, err, c.Request.URL.Path)switch {- case errors.Is(err, ErrResourceNotFound):- // 4. Hand off to the handler so the client sees a real 404- // rather than a fake "no permission" 403.+ case err == nil, errors.Is(err, ErrResourceNotFound):+ // A missing resource remains the handler's responsibility so it+ // can produce its existing 404 response.c.Next()return- case err != nil:- // 5. Genuine failure — surface it as 5xx so monitoring catches it.+ case errors.Is(err, ErrOwnershipForbidden) && !decision.LookupFailed:+ if svc := AuditServiceFromContext(c); svc != nil {+ tenantID := types.CallerFromContext(ctx).TenantID+ _ = svc.LogDenied(ctx, c, tenantID, request.UserID, string(request.Role), min)+ }+ c.JSON(http.StatusForbidden, gin.H{+ "error": "Forbidden: must own the resource or have the required role",+ })+ default:logger.Errorf(ctx,"[rbac] creator lookup failed: user=%s path=%s err=%v",- uid, c.Request.URL.Path, err)+ request.UserID, c.Request.URL.Path, err)c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Service Unavailable: cannot verify resource ownership",})- c.Abort()- return- }-- // 6. Ownership match wins even when role is below min — that's the- // whole point: Contributors can edit their own resources.- if creator != "" && creator == uid {- c.Next()- return- }-- // 7-8. Tenant-owned (creator=="") or non-creator with insufficient role.- logger.Warnf(ctx,- "[rbac] ownership/role insufficient: user=%s have=%s need=%s creator=%q path=%s",- uid, role, min, creator, c.Request.URL.Path)- // Same durable audit hook as RequireRole — subject to dedup.- if svc := AuditServiceFromContext(c); svc != nil {- tenantID, _ := types.TenantIDFromContext(ctx)- _ = svc.LogDenied(ctx, c, tenantID, uid, string(role), min)}- c.JSON(http.StatusForbidden, gin.H{- "error": "Forbidden: must own the resource or have the required role",- })c.Abort()}}@@ -303,61 +259,55 @@ func rbacEnforcementEnabled(cfg *config.Config) bool {// ErrOwnershipForbidden is returned by EvaluateOwnershipOrRole when the// caller is neither the resource creator nor meets the minimum role.-var ErrOwnershipForbidden = errors.New("rbac: ownership or role insufficient")+var ErrOwnershipForbidden = access.ErrOwnershipForbidden-// EvaluateOwnershipOrRole applies the same decision matrix as-// RequireOwnershipOrRole for handlers that resolve creator_id out-of-band-// (e.g. KB id carried in a JSON body rather than a URL param).-//-// Returns nil when access is allowed. ErrResourceNotFound means the-// handler should issue its own 404. ErrOwnershipForbidden maps to 403.-// Any other error is a transient lookup failure (503).+// EvaluateOwnershipOrRole is the handler adapter for the same lazy decision+// used by RequireOwnershipOrRole. Body/query-based callers supply a closure so+// ownership lookup is skipped on exactly the same fast paths as URL routes.+// Not-found, forbidden and lookup failures remain distinct; each handler maps+// them to its existing response format and status.func EvaluateOwnershipOrRole(ctx context.Context,cfg *config.Config,min types.TenantRole,- creatorID string,- lookupErr error,+ lookup func() (string, error),) error {- // API-key principals are authorized solely by the APIKeyGate (route- // policy) plus the KB allow-list handlers enforce separately- // (requireTenantAPIKeyKnowledgeBase(s)). Ownership ("creator OR Admin+")- // is a human concept that never applies to a machine principal, so- // short-circuit here — exactly as RequireOwnershipOrRole does for the- // middleware form. Without this, a scoped key (synthesized as Viewer for- // legacy-guard compatibility) would be 403'd by the body-carried-KB- // ownership checks even though the gate + allow-list already admitted it.- if _, ok := types.TenantAPIKeyScopeFromContext(ctx); ok {- return nil- }- role := types.TenantRoleFromContext(ctx)- if role.HasPermission(min) {- return nil- }- if IsCrossTenantSuperuser(ctx, cfg) {- return nil+ request := ownershipRequestFromContext(ctx, cfg)+ decision, err := access.CheckOwnershipOrRole(request, min, lookup)+ logOwnershipDecision(ctx, request, min, decision, err, "")+ return err+}++func ownershipRequestFromContext(ctx context.Context, cfg *config.Config) access.OwnershipRequest {+ caller := types.CallerFromContext(ctx)+ _, apiKey := types.TenantAPIKeyScopeFromContext(ctx)+ return access.OwnershipRequest{+ UserID: caller.UserID,+ Role: caller.Role,+ APIKey: apiKey,+ CrossTenantSuperuser: IsCrossTenantSuperuser(ctx, cfg),+ Enforce: rbacEnforcementEnabled(cfg),}- if !rbacEnforcementEnabled(cfg) {- uid, _ := types.UserIDFromContext(ctx)+}++func logOwnershipDecision(+ ctx context.Context,+ request access.OwnershipRequest,+ required types.TenantRole,+ decision access.OwnershipDecision,+ err error,+ path string,+) {+ switch {+ case decision.EnforcementSkipped:logger.Warnf(ctx,- "[rbac] ownership/role would be checked (enforcement off, lookup skipped): user=%s have=%s need=%s",- uid, role, min)- return nil- }- if errors.Is(lookupErr, ErrResourceNotFound) {- return ErrResourceNotFound- }- if lookupErr != nil {- return lookupErr- }- uid, _ := types.UserIDFromContext(ctx)- if creatorID != "" && creatorID == uid {- return nil+ "[rbac] ownership/role would be checked (enforcement off, lookup skipped): user=%s have=%s need=%s path=%s",+ request.UserID, request.Role, required, path)+ case errors.Is(err, ErrOwnershipForbidden) && !decision.LookupFailed:+ logger.Warnf(ctx,+ "[rbac] ownership/role insufficient: user=%s have=%s need=%s creator=%q path=%s",+ request.UserID, request.Role, required, decision.CreatorID, path)}- logger.Warnf(ctx,- "[rbac] ownership/role insufficient: user=%s have=%s need=%s creator=%q",- uid, role, min, creatorID)- return ErrOwnershipForbidden}// isCrossTenantSuperuser was moved to access.go (renamed todiff --git a/internal/middleware/rbac_api_key_shortcircuit_test.go b/internal/middleware/rbac_api_key_shortcircuit_test.goindex f767ced39..573a54892 100644--- a/internal/middleware/rbac_api_key_shortcircuit_test.go+++ b/internal/middleware/rbac_api_key_shortcircuit_test.go@@ -108,7 +108,10 @@ func TestEvaluateOwnershipOrRole_ShortCircuitsAPIKey(t *testing.T) {ctx = context.WithValue(ctx, types.TenantRoleContextKey, types.TenantRoleViewer)if err := EvaluateOwnershipOrRole(ctx, cfgRBAC(true),- types.TenantRoleAdmin, "some-other-human-user", nil); err != nil {+ types.TenantRoleAdmin, func() (string, error) {+ t.Fatal("API-key principals must not query resource ownership")+ return "some-other-human-user", nil+ }); err != nil {t.Fatalf("API-key principal should short-circuit EvaluateOwnershipOrRole, got %v", err)}}@@ -118,7 +121,9 @@ func TestEvaluateOwnershipOrRole_ShortCircuitsAPIKey(t *testing.T) {func TestEvaluateOwnershipOrRole_JWTViewerStillDenied(t *testing.T) {ctx := context.WithValue(context.Background(), types.TenantRoleContextKey, types.TenantRoleViewer)err := EvaluateOwnershipOrRole(ctx, cfgRBAC(true),- types.TenantRoleAdmin, "some-other-human-user", nil)+ types.TenantRoleAdmin, func() (string, error) {+ return "some-other-human-user", nil+ })if err == nil {t.Fatal("JWT Viewer with foreign creator must be denied by EvaluateOwnershipOrRole")}diff --git a/internal/middleware/rbac_audit_test.go b/internal/middleware/rbac_audit_test.goindex a4e295bd2..37d0f321c 100644--- a/internal/middleware/rbac_audit_test.go+++ b/internal/middleware/rbac_audit_test.go@@ -2,6 +2,8 @@ package middlewareimport ("context"+ "errors"+ "fmt""net/http""net/http/httptest""sync"@@ -135,3 +137,58 @@ func TestRequireRole_NilAuditServiceDoesNotPanic(t *testing.T) {t.Fatalf("expected 403 even with nil audit service, got %d", w.Code)}}++func TestOwnershipAuditOnlyRecordsPolicyDenials(t *testing.T) {+ for _, tt := range []struct {+ name string+ creator string+ lookupErr error+ disabled bool+ status int+ auditCalls int+ }{+ {name: "creator allowed", creator: "u1", status: http.StatusOK},+ {name: "policy denied", creator: "other", status: http.StatusForbidden, auditCalls: 1},+ {+ name: "not found passes to handler",+ lookupErr: fmt.Errorf("load: %w",+ ErrResourceNotFound),+ status: http.StatusOK,+ },++ {+ name: "database failure",+ lookupErr: errors.New("database unavailable"),+ status: http.StatusServiceUnavailable,+ },++ {+ name: "lookup returned denial sentinel",+ lookupErr: ErrOwnershipForbidden,+ status: http.StatusServiceUnavailable,+ },++ {name: "enforcement disabled", disabled: true, creator: "other", status: http.StatusOK},+ } {+ t.Run(tt.name, func(t *testing.T) {+ audit := &stubDenyAudit{}+ lookup := func(*gin.Context) (string, error) {+ if tt.disabled {+ t.Fatal("disabled enforcement must skip lookup")+ }+ return tt.creator, tt.lookupErr+ }+ w := auditableHarness(t, types.TenantRoleContributor, "u1", 7, audit,+ RequireOwnershipOrRole(types.TenantRoleAdmin, lookup, cfgRBAC(!tt.disabled)))+ if w.Code != tt.status || len(audit.calls) != tt.auditCalls {+ t.Fatalf(+ "status=%d audit calls=%d; want status=%d audit calls=%d",+ w.Code,+ len(audit.calls),+ tt.status,+ tt.auditCalls,+ )+ }+ })+ }+}diff --git a/internal/router/files.go b/internal/router/files.goindex 5ad7c8760..a00b58c81 100644--- a/internal/router/files.go+++ b/internal/router/files.go@@ -2,23 +2,25 @@ package routerimport ("context"+ "errors""io"- "mime""net/http""os""path/filepath""strconv""strings"+ "github.com/Tencent/WeKnora/internal/application/access"filesvc "github.com/Tencent/WeKnora/internal/application/service/file"- "github.com/gin-gonic/gin"-"github.com/Tencent/WeKnora/internal/config"+ apperrors "github.com/Tencent/WeKnora/internal/errors"+ "github.com/Tencent/WeKnora/internal/filetransport""github.com/Tencent/WeKnora/internal/logger""github.com/Tencent/WeKnora/internal/middleware""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces"secutils "github.com/Tencent/WeKnora/internal/utils"+ "github.com/gin-gonic/gin")// files.go hosts every file-proxy surface the router exposes:@@ -42,247 +44,11 @@ type getRouteRegistrar interface {GET(string, ...gin.HandlerFunc) gin.IRoutes}-// messageFileLookup is the narrow message-service surface needed by the-// message-scoped file proxy. Keeping it small makes the authorization boundary-// independently testable.-type messageFileLookup interface {- GetMessage(ctx context.Context, sessionID, messageID string) (*types.Message, error)-}--// sharedAgentFileLookup verifies that a source workspace's agent is still-// shared to the caller. Revoking the share therefore also revokes historical-// message-file access.-type sharedAgentFileLookup interface {- GetSharedAgentForTenant(- ctx context.Context,- tenantID uint64,- callerTenantRole types.TenantRole,- agentID string,- sourceTenantID ...uint64,- ) (*types.CustomAgent, error)-}--// kbSharePermissionGuard is the org-share surface the message-scoped proxy-// needs for its shared-KB fallback.-type kbSharePermissionGuard interface {- HasTenantKBPermission(- ctx context.Context,- kbID string,- callerTenantID uint64,- callerTenantRole types.TenantRole,- requiredRole types.OrgMemberRole,- ) (bool, error)-}--// kbTenantLookup resolves knowledge bases without a tenant filter, so a-// message's persisted retrieval evidence can be mapped back to the knowledge-// bases the chunks were retrieved from.-type kbTenantLookup interface {- GetKnowledgeBasesByIDsOnly(ctx context.Context, ids []string) ([]*types.KnowledgeBase, error)-}--// knowledgeOwnerLookup resolves a knowledge entry to its knowledge base for-// message references that predate the denormalized knowledge_base_id field.-type knowledgeOwnerLookup interface {- GetKnowledgeByIDOnly(ctx context.Context, id string) (*types.Knowledge, error)-}--// messageKBShareAuthorizer bundles the read-only lookups behind the-// message proxy's org-shared-KB fallback. A nil ShareGuard or KBs lookup-// disables the fallback, which keeps older call sites and tests on the-// shared-agent-only behavior. A nil Knowledges lookup only disables the-// pre-denormalization KnowledgeID path.-type messageKBShareAuthorizer struct {- ShareGuard kbSharePermissionGuard- KBs kbTenantLookup- Knowledges knowledgeOwnerLookup-}--// resourceAccessibleViaSharedKB reports whether the message's persisted-// retrieval evidence proves the resource came from an org-shared KB the-// caller may read. This is the fallback for replies whose agent belongs to-// the caller's own workspace while the retrieved resources belong to the-// workspace that shared the knowledge base (#3022).-//-// Evidence required from one retrieval record: a canonical resource://-// handle (not a prefix of a longer token) appears in the chunk text or-// image_info, its knowledge base belongs to the resource's tenant, and-// that KB is org-shared to the caller with at least viewer permission.-// Smart-reasoning turns persist that evidence on AgentSteps when-// KnowledgeReferences was never filled. Any lookup failure fails closed.-func (a messageKBShareAuthorizer) resourceAccessibleViaSharedKB(- ctx context.Context,- message *types.Message,- resource *types.StoredResource,- callerTenantID uint64,- callerTenantRole types.TenantRole,-) bool {- if a.ShareGuard == nil || a.KBs == nil || message == nil || resource == nil {- return false- }- handle, ok := types.ParseResourcePath(types.BuildResourcePath(resource.Handle))- if !ok {- return false- }-- kbIDs := a.collectSharedKBEvidenceIDs(ctx, message, handle)- if len(kbIDs) == 0 {- return false- }-- kbs, err := a.KBs.GetKnowledgeBasesByIDsOnly(ctx, kbIDs)- if err != nil {- return false- }- for _, kb := range kbs {- if kb == nil || kb.TenantID != resource.TenantID {- continue- }- shared, err := a.ShareGuard.HasTenantKBPermission(- ctx, kb.ID, callerTenantID, callerTenantRole, types.OrgRoleViewer)- if err == nil && shared {- return true- }- }- return false-}--func (a messageKBShareAuthorizer) collectSharedKBEvidenceIDs(- ctx context.Context,- message *types.Message,- handle string,-) []string {- seenKB := make(map[string]bool)- seenKnowledge := make(map[string]bool)- var kbIDs, knowledgeIDs []string- addKB := func(id string) {- if id == "" || seenKB[id] {- return- }- seenKB[id] = true- kbIDs = append(kbIDs, id)- }- addKnowledge := func(id string) {- if id == "" || seenKnowledge[id] {- return- }- seenKnowledge[id] = true- knowledgeIDs = append(knowledgeIDs, id)- }-- for _, ref := range message.KnowledgeReferences {- if !searchResultHasResourceHandle(ref, handle) {- continue- }- if ref.KnowledgeBaseID != "" {- addKB(ref.KnowledgeBaseID)- continue- }- addKnowledge(ref.KnowledgeID)- }- collectKBEvidenceFromValue(message.AgentSteps, handle, "", "", addKB, addKnowledge)-- if a.Knowledges != nil {- for _, knowledgeID := range knowledgeIDs {- knowledge, err := a.Knowledges.GetKnowledgeByIDOnly(ctx, knowledgeID)- if err != nil || knowledge == nil {- continue- }- addKB(knowledge.KnowledgeBaseID)- }- }- return kbIDs-}--func searchResultHasResourceHandle(ref *types.SearchResult, handle string) bool {- if ref == nil {- return false- }- return textHasResourceHandle(ref.Content, handle) ||- textHasResourceHandle(ref.MatchedContent, handle) ||- textHasResourceHandle(ref.ImageInfo, handle)-}--func textHasResourceHandle(text, handle string) bool {- if text == "" || handle == "" {- return false- }- want := types.BuildResourcePath(handle)- for _, ref := range types.ScanResourceReferences(text) {- if ref == want {- return true- }- }- return false-}--func collectKBEvidenceFromValue(- v interface{},- handle, kbID, knowledgeID string,- addKB, addKnowledge func(string),-) {- switch val := v.(type) {- case string:- if !textHasResourceHandle(val, handle) {- return- }- if kbID != "" {- addKB(kbID)- return- }- addKnowledge(knowledgeID)- case types.AgentSteps:- for _, step := range val {- collectKBEvidenceFromValue(step, handle, kbID, knowledgeID, addKB, addKnowledge)- }- case types.AgentStep:- collectKBEvidenceFromValue(val.ToolCalls, handle, kbID, knowledgeID, addKB, addKnowledge)- case []types.ToolCall:- for _, call := range val {- collectKBEvidenceFromValue(call, handle, kbID, knowledgeID, addKB, addKnowledge)- }- case types.ToolCall:- if val.Result != nil {- collectKBEvidenceFromValue(val.Result.Output, handle, kbID, knowledgeID, addKB, addKnowledge)- collectKBEvidenceFromValue(val.Result.Data, handle, kbID, knowledgeID, addKB, addKnowledge)- }- case map[string]interface{}:- nextKB := firstNonEmptyString(- stringFromAnyMap(val, "knowledge_base_id"),- stringFromAnyMap(val, "knowledge_base"),- kbID,- )- nextKnowledge := firstNonEmptyString(stringFromAnyMap(val, "knowledge_id"), knowledgeID)- for _, nested := range val {- collectKBEvidenceFromValue(nested, handle, nextKB, nextKnowledge, addKB, addKnowledge)- }- case []interface{}:- for _, item := range val {- collectKBEvidenceFromValue(item, handle, kbID, knowledgeID, addKB, addKnowledge)- }- case []map[string]interface{}:- for _, item := range val {- collectKBEvidenceFromValue(item, handle, kbID, knowledgeID, addKB, addKnowledge)- }- }-}--func stringFromAnyMap(m map[string]interface{}, key string) string {- if m == nil {- return ""- }- s, _ := m[key].(string)- return strings.TrimSpace(s)-}--func firstNonEmptyString(values ...string) string {- for _, value := range values {- if strings.TrimSpace(value) != "" {- return strings.TrimSpace(value)- }- }- return ""-}+type (+ messageFileLookup = access.MessageFileLookup+ sharedAgentFileLookup = access.SharedAgentFileLookup+ messageKBShareAuthorizer = access.MessageKBShareAuthorizer+)// localStorageBaseDir resolves LOCAL_STORAGE_BASE_DIR with the container// default.@@ -372,68 +138,17 @@ func resolveFileService(return filesvc.NewFileServiceFromStorageConfig(provider, tenant.StorageEngineConfig, absDir)}-// resolveTenantFileServiceWithFallback is resolveFileService plus the-// fallback rule shared by /files and the KB-scoped proxy: when tenant-level-// resolution fails and the requested provider matches the process-global-// STORAGE_TYPE, serve through the global file service instead of failing.-// Returns ok=false (already logged) when no service can be resolved; the-// caller decides the HTTP status.-func resolveTenantFileServiceWithFallback(- ctx context.Context,- logTag string,- tenant *types.Tenant,- backendID, provider, absDir string,- storageResolver interfaces.StorageBackendResolver,- globalFileService interfaces.FileService,-) (fileSvc interfaces.FileService, resolvedProvider string, ok bool) {- var err error- if storageResolver != nil {- fileSvc, resolvedProvider, err = storageResolver.ResolveFileService(ctx, tenant, backendID, provider, absDir)- } else if tenant.StorageEngineConfig != nil {- fileSvc, resolvedProvider, err = filesvc.NewFileServiceFromStorageConfig(provider, tenant.StorageEngineConfig, absDir)- } else {- err = http.ErrMissingFile- }- if err == nil {- return fileSvc, resolvedProvider, true- }-- globalStorageType := strings.ToLower(strings.TrimSpace(os.Getenv("STORAGE_TYPE")))- if globalStorageType == "" {- globalStorageType = "local"- }- if provider == globalStorageType && globalFileService != nil {- logger.Warnf(ctx, "[Router] %s tenant storage config missing or invalid, fallback to global file service: tenant_id=%d provider=%s err=%v",- logTag, tenant.ID, provider, err)- return globalFileService, globalStorageType, true- }- logger.Warnf(ctx, "[Router] %s resolve file service failed without fallback: tenant_id=%d provider=%s global_storage_type=%s err=%v",- logTag, tenant.ID, provider, globalStorageType, err)- return nil, "", false-}-// streamStoredFile writes the shared success response of every file proxy:// safe content type, nosniff, disposition for non-inline types, the route's// cache policy, then the body (skipped for HEAD). Closes reader.func streamStoredFile(c *gin.Context, reader io.ReadCloser, contentType string, inline bool, cacheControl, logTag string, fileNames ...string) {- defer reader.Close()- c.Header("Content-Type", contentType)- c.Header("X-Content-Type-Options", "nosniff")- disposition := "inline"- if !inline {- disposition = "attachment"- }+ name := ""if len(fileNames) > 0 {- c.Header("Content-Disposition", mime.FormatMediaType(disposition, map[string]string{"filename": filepath.Base(fileNames[0])}))- } else if !inline {- c.Header("Content-Disposition", disposition)+ name = fileNames[0]}- c.Header("Cache-Control", cacheControl)- c.Status(http.StatusOK)- if c.Request.Method == http.MethodHead {- return- }- if _, err := io.Copy(c.Writer, reader); err != nil {+ if err := filetransport.Serve(c.Writer, c.Request, reader, filetransport.Options{+ Filename: name, Download: !inline, ContentType: contentType, CacheControl: cacheControl,+ }); err != nil {logger.Warnf(c.Request.Context(), "[Router] %s write response failed: %v", logTag, err)}}@@ -486,7 +201,7 @@ func newFileServeHandler(}backendID, provider := parseStorageTarget(filePath)- fileSvc, resolvedProvider, ok := resolveTenantFileServiceWithFallback(+ fileSvc, resolvedProvider, ok := filesvc.ResolveTenantFileServiceWithFallback(c.Request.Context(), "/files", tenant, backendID, provider, absDir, storageResolver, globalFileService)if !ok {c.Status(http.StatusBadRequest)@@ -591,9 +306,6 @@ func serveResourceGrants(fileName = resource.PhysicalPath}contentType, inline := secutils.SafeContentTypeByFilename(fileName)- if resource.MimeType != "" && inline {- contentType = resource.MimeType- }streamStoredFile(c, reader, contentType, inline, "private, max-age=300","resource grant (resource_id="+resource.ID+")", fileName)}@@ -603,13 +315,10 @@ func serveResourceGrants(// serveKBScopedFiles registers the KB-scoped file proxy used to render images// embedded in a knowledge base's content (chunks / wiki pages). Unlike the-// tenant-scoped /files route — which enforces file_path.tenant == caller.tenant-// and therefore cannot serve objects owned by another tenant — this route is-// gated by RequireKBAccess. That guard resolves org-shared / agent-visible KBs-// and rewrites the request context's tenant ID to the KB's *owner* (source)-// tenant, so images stored under the owner tenant (local://<owner>/exports/...)-// become reachable by tenants that legitimately share the KB, while still-// enforcing that the requested path belongs to that owner tenant.+// tenant-scoped /files route, this route consumes RequireKBAccess's exact KB+// grant. The file must be owned by that KB's tenant and have a live document+// binding or an exact reference in the KB's chunks/wiki pages. Only then does+// storage execute under the owner tenant.//// Route:// - GET /api/v1/knowledge-bases/:id/files?file_path=<provider://...>@@ -622,14 +331,8 @@ func serveKBScopedFiles(resourceCatalogs ...interfaces.ResourceCatalog,) {logger.Infof(context.Background(), "[Router] Serving KB-scoped files from /knowledge-bases/:id/files")- // API-key access mirrors /files: KB-restricted keys are denied (an- // arbitrary file_path under the KB owner tenant cannot be bounded to a- // key's allow-list), while full-access and tenant-wide retrieve keys pass- // — KBAccessRead still confines them to KBs they may read (own /- // org-shared / agent-visible), exactly as it does for a JWT Viewer. The- // route is declared to the gate with the retrieve policy so it is reachable- // at all; AllowFileServeAPIKey then applies the stricter not-KB-restricted- // constraint.+ // Preserve the existing file-route API-key policy: KB-restricted keys are+ // denied; full-access and tenant-wide retrieve keys still need KBAccessRead.g.apiKeyRoute(r, http.MethodGet, "/knowledge-bases/:id/files",apiKeyRetrieve(apiKeyFullAccess()),middleware.AllowFileServeAPIKey(),@@ -644,24 +347,6 @@ func serveKBScopedFiles()}-// newKBScopedFileServeHandler builds the handler backing serveKBScopedFiles.-// The effective (owner) tenant is taken from the request context, which-// RequireKBAccess has already rewritten to the KB's source tenant. The owner-// tenant's storage config is loaded via TenantService so the file is fetched-// from the backend that actually holds it — the caller's own storage config is-// irrelevant here.-func newKBScopedFileServeHandler(- tenantService interfaces.TenantService,- globalFileService interfaces.FileService,- resolvers ...interfaces.StorageBackendResolver,-) gin.HandlerFunc {- var storageResolver interfaces.StorageBackendResolver- if len(resolvers) > 0 {- storageResolver = resolvers[0]- }- return newKBScopedFileServeHandlerWithResources(tenantService, globalFileService, storageResolver, nil)-}-func firstResourceCatalog(catalogs []interfaces.ResourceCatalog) interfaces.ResourceCatalog {if len(catalogs) == 0 {return nil@@ -675,71 +360,32 @@ func newKBScopedFileServeHandlerWithResources(storageResolver interfaces.StorageBackendResolver,resourceCatalog interfaces.ResourceCatalog,) gin.HandlerFunc {- absDir := localStorageAbsDir()-return func(c *gin.Context) {- ctx := c.Request.Context()-- filePath, ok := requireFilePathQuery(c)- if !ok {- return- }-- // RequireKBAccess rewrote the request context tenant ID to the KB's- // owner (source) tenant for shared KBs; for own KBs it equals the- // caller's tenant. Either way it is the tenant that owns this KB's- // storage objects, so the requested path must belong to it.- ownerTenantID, ok := types.TenantIDFromContext(ctx)- if !ok || ownerTenantID == 0 {- c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized: workspace context missing"})- return- }- filePath, _, ok = resolveCatalogResource(c, resourceCatalog, filePath, ownerTenantID)- if !ok {- return- }-- if err := secutils.ValidateKBScopedStoragePath(filePath, ownerTenantID); err != nil {- logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files denied path not allowed for KB proxy: owner_tenant_id=%d file_path=%q err=%v",- ownerTenantID, filePath, err)- c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: file path not accessible"})- return- }-- tenant, err := tenantService.GetTenantByID(ctx, ownerTenantID)- if err != nil || tenant == nil {- logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files owner tenant lookup failed: owner_tenant_id=%d err=%v",- ownerTenantID, err)- c.Status(http.StatusNotFound)- return- }-- backendID, provider := parseStorageTarget(filePath)- fileSvc, resolvedProvider, ok := resolveTenantFileServiceWithFallback(- ctx, "/knowledge-bases/:id/files", tenant, backendID, provider, absDir, storageResolver, globalFileService)+ reference, ok := requireFilePathQuery(c)if !ok {- c.Status(http.StatusBadRequest)return}-- reader, err := fileSvc.GetFile(ctx, filePath)- if err != nil {- logger.Warnf(ctx, "[Router] /knowledge-bases/:id/files get file failed: owner_tenant_id=%d provider=%s path=%q err=%v",- ownerTenantID, resolvedProvider, filePath, err)- c.Status(http.StatusNotFound)+ grant, _ := middleware.KBAccessFromContext(c)+ bindings, _ := resourceCatalog.(interfaces.KBResourceLookup)+ file, err := access.ResolveKBFile(+ c.Request.Context(),+ grant,+ c.Param("id"),+ reference,+ resourceCatalog,+ bindings,+ )+ if fileAccessError(c, err) {return}-- contentType, inline := secutils.SafeContentTypeByFilename(filePath)- // Cross-tenant shared content — keep it private so shared proxies /- // CDNs do not cache one tenant's view for another.- streamStoredFile(c, reader, contentType, inline, "private, max-age=86400", "/knowledge-bases/:id/files", filePath)+ serveAuthorizedFile(c, file, tenantService, globalFileService, storageResolver, "KB files")}}// newMessageScopedFileServeHandler serves resources rendered inside one// assistant message. The message service first proves that the caller owns the-// containing session. For cross-workspace resources we then require either the+// containing session, and the persisted message must reference the exact file.+// For cross-workspace resources we then require either the// message's agent to still be shared from the resource-owning workspace, or —// when the reply was produced by the caller's own agent over an org-shared// knowledge base — that the resource's KB is still shared to the caller.@@ -756,145 +402,81 @@ func newMessageScopedFileServeHandler(resourceCatalog interfaces.ResourceCatalog,kbShareAuth messageKBShareAuthorizer,) gin.HandlerFunc {- absDir := localStorageAbsDir()-return func(c *gin.Context) {- ctx := c.Request.Context()- filePath, ok := requireFilePathQuery(c)+ reference, ok := requireFilePathQuery(c)if !ok {return}-- callerTenantID, ok := types.TenantIDFromContext(ctx)- if !ok || callerTenantID == 0 {- c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized: workspace context missing"})- return- }- if messageService == nil {- c.Status(http.StatusNotFound)- return- }-- message, err := messageService.GetMessage(ctx, c.Param("id"), c.Param("message_id"))- if err != nil || message == nil {- // Do not reveal whether a message exists outside the caller's session.- c.Status(http.StatusNotFound)- return- }-- resolvedPath := filePath- var resource *types.StoredResource- if resourceCatalog != nil {- resolvedPath, resource, err = resourceCatalog.ResolvePath(ctx, filePath)- if err != nil {- c.Status(http.StatusNotFound)- return- }- }-- ownerTenantID := message.AgentTenantID- kbShareAuthorized := false- if resource != nil {- ownerTenantID = resource.TenantID- // A modern message records its source tenant. A resource from any- // other tenant cannot be smuggled through that message even if the- // caller happens to have another shared agent with the same ID —- // unless the reply's own retrieval references prove the resource- // came from an org-shared KB the caller may still read (#3022).- if message.AgentTenantID != 0 && message.AgentTenantID != ownerTenantID {- kbShareAuthorized = kbShareAuth.resourceAccessibleViaSharedKB(- ctx, message, resource, callerTenantID, types.TenantRoleFromContext(ctx))- if !kbShareAuthorized {- c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: resource not accessible from this message"})- return- }- }- }- if ownerTenantID == 0 {- c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: message resource workspace missing"})- return- }-- if ownerTenantID != callerTenantID && !kbShareAuthorized {- // Messages written before agent_tenant_id was populated have no- // recorded source tenant; offer them the same org-shared KB- // fallback before the shared-agent relation is demanded.- if message.AgentTenantID == 0 {- kbShareAuthorized = kbShareAuth.resourceAccessibleViaSharedKB(- ctx, message, resource, callerTenantID, types.TenantRoleFromContext(ctx))- }- if !kbShareAuthorized {- if message.AgentID == "" || agentShareService == nil {- c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: shared agent access required"})- return- }- agent, shareErr := agentShareService.GetSharedAgentForTenant(- ctx,- callerTenantID,- types.TenantRoleFromContext(ctx),- message.AgentID,- ownerTenantID,- )- if shareErr != nil || agent == nil || agent.TenantID != ownerTenantID {- c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: shared agent access revoked"})- return- }- }- }-- // Registered resources carry authoritative tenant ownership. Legacy- // provider paths must still encode the authorized owner tenant.- if resource == nil {- if err := secutils.ValidateStoragePathTenant(resolvedPath, ownerTenantID); err != nil {- logger.Warnf(ctx,- "[Router] message files denied cross-tenant or invalid path: owner_tenant_id=%d file_path=%q err=%v",- ownerTenantID, resolvedPath, err)- c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: file path not accessible"})- return- }- }-- ownerTenant, err := tenantService.GetTenantByID(ctx, ownerTenantID)- if err != nil || ownerTenant == nil {- c.Status(http.StatusNotFound)- return- }-- backendID, provider := parseStorageTarget(resolvedPath)- fileSvc, resolvedProvider, ok := resolveTenantFileServiceWithFallback(- ctx,- "/sessions/:id/messages/:message_id/files",- ownerTenant,- backendID,- provider,- absDir,- storageResolver,- globalFileService,- )- if !ok {- c.Status(http.StatusBadRequest)+ file, err := access.ResolveMessageFile(c.Request.Context(), c.Param("id"), c.Param("message_id"), reference,+ messageService, agentShareService, resourceCatalog, kbShareAuth)+ if fileAccessError(c, err) {return}+ serveAuthorizedFile(c, file, tenantService, globalFileService, storageResolver, "message files")+ }+}- reader, err := fileSvc.GetFile(ctx, resolvedPath)- if err != nil {- logger.Warnf(ctx,- "[Router] message files get file failed: owner_tenant_id=%d provider=%s path=%q err=%v",- ownerTenantID, resolvedProvider, resolvedPath, err)- c.Status(http.StatusNotFound)- return- }+// Storage consumes the authorized locator; it never infers permissions from+// a context tenant or attempts a different resource after an authorization error.+func serveAuthorizedFile(c *gin.Context, file access.FileAccess, tenants interfaces.TenantService,+ global interfaces.FileService, resolver interfaces.StorageBackendResolver, tag string,+) {+ ctx := types.WithExecutionTenant(c.Request.Context(), file.OwnerTenantID)+ tenant, err := tenants.GetTenantByID(ctx, file.OwnerTenantID)+ if err != nil || tenant == nil {+ c.Status(http.StatusNotFound)+ return+ }+ backendID, provider := parseStorageTarget(file.Path)+ if file.StorageBackendID != "" {+ backendID = file.StorageBackendID+ }+ svc, _, ok := filesvc.ResolveTenantFileServiceWithFallback(+ ctx,+ tag,+ tenant,+ backendID,+ provider,+ localStorageAbsDir(),+ resolver,+ global,+ )+ if !ok {+ c.Status(http.StatusBadRequest)+ return+ }+ reader, err := svc.GetFile(ctx, file.Path)+ if err != nil {+ c.Status(http.StatusNotFound)+ return+ }+ if err := filetransport.Serve(c.Writer, c.Request, reader, filetransport.Options{+ Filename: file.Filename, CacheControl: "private, no-store",+ }); err != nil {+ logger.Warnf(ctx, "%s stream failed: %v", tag, err)+ }+}- contentType, inline := secutils.SafeContentTypeByFilename(resolvedPath)- if resource != nil && resource.MimeType != "" && inline {- contentType = resource.MimeType- }- fileName := resolvedPath- if resource != nil && strings.TrimSpace(resource.OriginalName) != "" {- fileName = resource.OriginalName+func fileAccessError(c *gin.Context, err error) bool {+ if err == nil {+ return false+ }+ switch {+ case errors.Is(err, access.ErrNotFound):+ c.Status(http.StatusNotFound)+ case errors.Is(err, access.ErrUnauthorized):+ c.JSON(http.StatusUnauthorized, gin.H{"error": "unauthorized: workspace context missing"})+ case errors.Is(err, access.ErrForbidden):+ c.JSON(http.StatusForbidden, gin.H{"error": "forbidden: file not accessible from this resource"})+ default:+ if app, ok := apperrors.IsAppError(err); ok {+ c.JSON(app.HTTPCode, gin.H{"error": app.Message})+ } else {+ logger.Warnf(c.Request.Context(), "file authorization failed: %v", err)+ c.Status(http.StatusServiceUnavailable)}- streamStoredFile(c, reader, contentType, inline, "private, max-age=86400", "message files", fileName)}+ return true}// serveMessageScopedFiles registers the authenticated proxy used by the chatdiff --git a/internal/router/rbac.go b/internal/router/rbac.goindex ce872ead6..f7f370eab 100644--- a/internal/router/rbac.go+++ b/internal/router/rbac.go@@ -546,7 +546,7 @@ func (g *rbacGuards) PathTenantMatch() gin.HandlerFunc {// validateAndGetKnowledgeBase helpers that used to be re-implemented// in chunk.go, faq.go, tag.go, knowledge.go and knowledgebase.go;// the share-fallback logic now lives in exactly one place-// (middleware/kb_access.go).+// (application/access/knowledgebase.go).// KBAccessRead gates a KB-scoped read route on the caller having at// least Viewer-level access. The agent-share fallback only activatesdiff --git a/internal/router/router_files_test.go b/internal/router/router_files_test.goindex afe089a3f..f03418244 100644--- a/internal/router/router_files_test.go+++ b/internal/router/router_files_test.go@@ -11,10 +11,10 @@ import ("testing""time"- "github.com/gin-gonic/gin"-+ "github.com/Tencent/WeKnora/internal/middleware""github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/gin-gonic/gin")var _ interfaces.FileService = (*stubFileService)(nil)@@ -24,7 +24,9 @@ type stubFileService struct {}type stubResourceCatalog struct {- resource *types.StoredResource+ resource *types.StoredResource+ fileBindings *types.MessageFileBindings+ bound func(context.Context, uint64, string, string) (bool, error)}type stubMessageFileLookup struct {@@ -58,6 +60,17 @@ func (s *stubSharedAgentFileLookup) GetSharedAgentForTenant(return s.get(ctx, tenantID, callerTenantRole, agentID, sourceTenantID...)}+func (s *stubResourceCatalog) IsReferencedByKnowledgeBase(+ ctx context.Context,+ tenant uint64,+ kb, ref string,+) (bool, error) {+ if s.bound == nil {+ return false, nil+ }+ return s.bound(ctx, tenant, kb, ref)+}+func (s *stubResourceCatalog) Register(context.Context,uint64,@@ -382,9 +395,8 @@ func TestServeFilesAPIKeyScopeMatrix(t *testing.T) {}// newKBScopedFilesTestEngine wires newKBScopedFileServeHandler behind a-// middleware that injects effectiveTenantID into the request context, mirroring-// what RequireKBAccess does after resolving an org-shared KB to its source-// tenant. This lets the handler be exercised without the full RBAC stack.+// middleware that carries the exact KB grant and owner execution tenant,+// mirroring RequireKBAccess without the full RBAC stack.func newKBScopedFilesTestEngine(effectiveTenantID uint64,tenantSvc interfaces.TenantService,@@ -394,10 +406,24 @@ func newKBScopedFilesTestEngine(engine.GET("/knowledge-bases/:id/files",func(c *gin.Context) {ctx := context.WithValue(c.Request.Context(), types.TenantIDContextKey, effectiveTenantID)- c.Request = c.Request.WithContext(ctx)+ grant := &middleware.KBAccess{+ KnowledgeBase: &types.KnowledgeBase{ID: "kb-1", TenantID: effectiveTenantID},+ Caller: types.CallerFromContext(ctx),+ EffectiveTenantID: effectiveTenantID,+ Permission: types.OrgRoleViewer,+ }+ c.Set(middleware.KBAccessContextKey, grant)+ c.Request = c.Request.WithContext(grant.Context(ctx))c.Next()},- newKBScopedFileServeHandler(tenantSvc, global),+ newKBScopedFileServeHandlerWithResources(+ tenantSvc,+ global,+ nil,+ &stubResourceCatalog{bound: func(_ context.Context, _ uint64, kb, ref string) (bool, error) {+ return kb == "kb-1" && ref == "local://10008/exports/img.jpg", nil+ }},+ ),)return engine}@@ -515,6 +541,26 @@ func TestKBScopedFilesRequiresFilePath(t *testing.T) {}}+func TestKBScopedFilesRejectsUnboundFileBeforeStorage(t *testing.T) {+ gin.SetMode(gin.TestMode)+ engine := newKBScopedFilesTestEngine(10008,+ &stubTenantService{get: func(context.Context, uint64) (*types.Tenant, error) {+ t.Fatal("an unbound file must be rejected before resolving storage")+ return nil, nil+ }},+ &stubFileService{getFile: func(context.Context, string) (io.ReadCloser, error) {+ t.Fatal("an unbound file must never be opened")+ return nil, nil+ }},+ )+ w := httptest.NewRecorder()+ engine.ServeHTTP(w, httptest.NewRequest(http.MethodGet,+ "/knowledge-bases/kb-1/files?file_path="+url.QueryEscape("local://10008/exports/another-kb.png"), nil))+ if w.Code != http.StatusForbidden {+ t.Fatalf("status=%d, want 403", w.Code)+ }+}+func newMessageScopedFilesTestEngine(callerTenantID uint64,messageService messageFileLookup,@@ -555,13 +601,15 @@ func TestMessageScopedFilesServesSharedAgentResource(t *testing.T) {physical = "local://7/exports/chart.png")var requestedPath string+ revoked := false+ storageCalls := 0engine := newMessageScopedFilesTestEngine(callerTenantID,&stubMessageFileLookup{get: func(_ context.Context, sessionID, messageID string) (*types.Message, error) {if sessionID != "session-1" || messageID != "message-1" {t.Fatalf("unexpected message scope %s/%s", sessionID, messageID)}- return &types.Message{AgentID: "agent-1", AgentTenantID: ownerTenantID}, nil+ return &types.Message{ID: "message-1", AgentID: "agent-1", AgentTenantID: ownerTenantID, Content: ref}, nil}},&stubSharedAgentFileLookup{get: func(_ context.Context,@@ -573,21 +621,28 @@ func TestMessageScopedFilesServesSharedAgentResource(t *testing.T) {if tenantID != callerTenantID || agentID != "agent-1" || len(sourceTenantID) != 1 || sourceTenantID[0] != ownerTenantID {t.Fatalf("unexpected shared-agent lookup tenant=%d agent=%s source=%v", tenantID, agentID, sourceTenantID)}+ if revoked {+ return nil, nil+ }return &types.CustomAgent{ID: agentID, TenantID: ownerTenantID}, nil}},&stubTenantService{get: func(_ context.Context, id uint64) (*types.Tenant, error) {return &types.Tenant{ID: id}, nil}},&stubFileService{getFile: func(_ context.Context, filePath string) (io.ReadCloser, error) {+ storageCalls++requestedPath = filePathreturn io.NopCloser(strings.NewReader("shared-agent-image")), nil}},- &stubResourceCatalog{resource: &types.StoredResource{- TenantID: ownerTenantID,- PhysicalPath: physical,- OriginalName: "chart.png",- MimeType: "image/png",- }},+ &stubResourceCatalog{+ fileBindings: &types.MessageFileBindings{MessageArtifact: true},+ resource: &types.StoredResource{+ TenantID: ownerTenantID,+ PhysicalPath: physical,+ OriginalName: "chart.png",+ MimeType: "image/png",+ },+ },messageKBShareAuthorizer{},)@@ -605,6 +660,15 @@ func TestMessageScopedFilesServesSharedAgentResource(t *testing.T) {if got := recorder.Header().Get("Content-Disposition"); !strings.Contains(got, "chart.png") {t.Fatalf("Content-Disposition = %q, want original filename chart.png", got)}+ if got := recorder.Header().Get("Cache-Control"); got != "private, no-store" {+ t.Fatalf("Cache-Control = %q, want private, no-store", got)+ }+ revoked = true+ recorder = httptest.NewRecorder()+ engine.ServeHTTP(recorder, req.Clone(context.Background()))+ if recorder.Code != http.StatusForbidden || storageCalls != 1 {+ t.Fatalf("revoked request: status=%d storage calls=%d", recorder.Code, storageCalls)+ }}func TestMessageScopedFilesServesSameTenantResource(t *testing.T) {@@ -623,7 +687,7 @@ func TestMessageScopedFilesServesSameTenantResource(t *testing.T) {if sessionID != "session-1" || messageID != "message-1" {t.Fatalf("unexpected message scope %s/%s", sessionID, messageID)}- return &types.Message{AgentTenantID: tenantID}, nil+ return &types.Message{AgentTenantID: tenantID, Content: ref}, nil}},&stubSharedAgentFileLookup{get: func(context.Context, uint64, types.TenantRole, string, ...uint64,@@ -690,7 +754,7 @@ func TestMessageScopedFilesRejectsRevokedSharedAgent(t *testing.T) {engine := newMessageScopedFilesTestEngine(42,&stubMessageFileLookup{get: func(context.Context, string, string) (*types.Message, error) {- return &types.Message{AgentID: "agent-1", AgentTenantID: 7}, nil+ return &types.Message{AgentID: "agent-1", AgentTenantID: 7, Content: ref}, nil}},&stubSharedAgentFileLookup{get: func(context.Context, uint64, types.TenantRole, string, ...uint64,@@ -719,6 +783,56 @@ func TestMessageScopedFilesRejectsRevokedSharedAgent(t *testing.T) {}}+func TestMessageScopedFilesRejectsUnreferencedFilesBeforeStorage(t *testing.T) {+ gin.SetMode(gin.TestMode)+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ for _, content := range []string{"", ref + "suffix"} {+ t.Run(content, func(t *testing.T) {+ engine := newMessageScopedFilesTestEngine(+ 42,+ &stubMessageFileLookup{get: func(context.Context, string, string) (*types.Message, error) {+ return &types.Message{+ AgentID: "agent-1", AgentTenantID: 7, Content: content,+ AgentSteps: types.AgentSteps{+ {ToolCalls: []types.ToolCall{{Args: map[string]interface{}{"file": ref}}}},+ },+ }, nil+ }},+ &stubSharedAgentFileLookup{+ get: func(context.Context,+ uint64,+ types.TenantRole,+ string,+ ...uint64) (*types.CustomAgent,+ error,+ ) {+ t.Fatal("tool arguments and handle prefixes must not authorize a message file")+ return nil, nil+ },+ },+ &stubTenantService{get: func(context.Context, uint64) (*types.Tenant, error) {+ t.Fatal("unreferenced files must be denied before resolving storage")+ return nil, nil+ }},+ &stubFileService{getFile: func(context.Context, string) (io.ReadCloser, error) {+ t.Fatal("unreferenced files must never be opened")+ return nil, nil+ }},+ &stubResourceCatalog{+ resource: &types.StoredResource{TenantID: 7, PhysicalPath: "local://7/exports/chart.png"},+ },+ messageKBShareAuthorizer{},+ )+ w := httptest.NewRecorder()+ engine.ServeHTTP(w, httptest.NewRequest(http.MethodGet,+ "/sessions/session-1/messages/message-1/files?file_path="+url.QueryEscape(ref), nil))+ if w.Code != http.StatusForbidden {+ t.Fatalf("status=%d, want 403", w.Code)+ }+ })+ }+}+func TestMessageScopedFilesRejectsResourceOutsideMessageTenant(t *testing.T) {gin.SetMode(gin.TestMode)const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"@@ -726,7 +840,7 @@ func TestMessageScopedFilesRejectsResourceOutsideMessageTenant(t *testing.T) {engine := newMessageScopedFilesTestEngine(42,&stubMessageFileLookup{get: func(context.Context, string, string) (*types.Message, error) {- return &types.Message{AgentID: "agent-1", AgentTenantID: 8}, nil+ return &types.Message{AgentID: "agent-1", AgentTenantID: 8, Content: ref}, nil}},&stubSharedAgentFileLookup{get: func(context.Context, uint64, types.TenantRole, string, ...uint64,@@ -760,14 +874,11 @@ type stubKBShareGuard struct {) (bool, error)}-func (s *stubKBShareGuard) HasTenantKBPermission(- ctx context.Context,- kbID string,- callerTenantID uint64,- callerTenantRole types.TenantRole,- requiredRole types.OrgMemberRole,-) (bool, error) {- return s.hasPermission(ctx, kbID, callerTenantID, callerTenantRole, requiredRole)+func (s *stubKBShareGuard) CheckTenantKBPermission(+ ctx context.Context, kbID string, callerTenantID uint64, callerTenantRole types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ allowed, err := s.hasPermission(ctx, kbID, callerTenantID, callerTenantRole, types.OrgRoleViewer)+ return types.OrgRoleViewer, allowed, err}type stubKBTenantLookup struct {@@ -861,13 +972,16 @@ func newOrgSharedKBTestEngineFromMessage(requestedPath = pathreturn io.NopCloser(strings.NewReader("shared-kb-image")), nil}},- &stubResourceCatalog{resource: &types.StoredResource{- Handle: "ShArEdKbHaNdLe00000000",- TenantID: ownerTenantID,- PhysicalPath: physical,- OriginalName: "quadrant.jpg",- MimeType: "image/jpeg",- }},+ &stubResourceCatalog{+ bound: func(context.Context, uint64, string, string) (bool, error) { return true, nil },+ resource: &types.StoredResource{+ Handle: "ShArEdKbHaNdLe00000000",+ TenantID: ownerTenantID,+ PhysicalPath: physical,+ OriginalName: "quadrant.jpg",+ MimeType: "image/jpeg",+ },+ },messageKBShareAuthorizer{ShareGuard: shareGuard,KBs: &stubKBTenantLookup{kbs: kbs},@@ -999,12 +1113,15 @@ func TestMessageScopedFilesServesLegacyMessageViaOrgSharedKB(t *testing.T) {&stubFileService{getFile: func(_ context.Context, _ string) (io.ReadCloser, error) {return io.NopCloser(strings.NewReader("legacy-shared-kb-image")), nil}},- &stubResourceCatalog{resource: &types.StoredResource{- Handle: "ShArEdKbHaNdLe00000000",- TenantID: ownerTenantID,- PhysicalPath: "local://10005/images/quadrant.jpg",- MimeType: "image/jpeg",- }},+ &stubResourceCatalog{+ bound: func(context.Context, uint64, string, string) (bool, error) { return true, nil },+ resource: &types.StoredResource{+ Handle: "ShArEdKbHaNdLe00000000",+ TenantID: ownerTenantID,+ PhysicalPath: "local://10005/images/quadrant.jpg",+ MimeType: "image/jpeg",+ },+ },messageKBShareAuthorizer{ShareGuard: &stubKBShareGuard{hasPermission: func(context.Context, string, uint64, types.TenantRole, types.OrgMemberRole,@@ -1055,12 +1172,15 @@ func TestMessageScopedFilesOrgSharedKBResolvesKnowledgeOwner(t *testing.T) {&stubFileService{getFile: func(_ context.Context, _ string) (io.ReadCloser, error) {return io.NopCloser(strings.NewReader("resolved-kb-image")), nil}},- &stubResourceCatalog{resource: &types.StoredResource{- Handle: "ShArEdKbHaNdLe00000000",- TenantID: 10005,- PhysicalPath: "local://10005/images/quadrant.jpg",- MimeType: "image/jpeg",- }},+ &stubResourceCatalog{+ bound: func(context.Context, uint64, string, string) (bool, error) { return true, nil },+ resource: &types.StoredResource{+ Handle: "ShArEdKbHaNdLe00000000",+ TenantID: 10005,+ PhysicalPath: "local://10005/images/quadrant.jpg",+ MimeType: "image/jpeg",+ },+ },messageKBShareAuthorizer{ShareGuard: &stubKBShareGuard{hasPermission: func(context.Context, string, uint64, types.TenantRole, types.OrgMemberRole,@@ -1194,12 +1314,15 @@ func TestMessageScopedFilesOrgSharedKBFailsClosedOnShareError(t *testing.T) {t.Fatal("GetFile should not run after share lookup error")return nil, nil}},- &stubResourceCatalog{resource: &types.StoredResource{- Handle: "ShArEdKbHaNdLe00000000",- TenantID: 10005,- PhysicalPath: "local://10005/images/quadrant.jpg",- MimeType: "image/jpeg",- }},+ &stubResourceCatalog{+ bound: func(context.Context, uint64, string, string) (bool, error) { return true, nil },+ resource: &types.StoredResource{+ Handle: "ShArEdKbHaNdLe00000000",+ TenantID: 10005,+ PhysicalPath: "local://10005/images/quadrant.jpg",+ MimeType: "image/jpeg",+ },+ },messageKBShareAuthorizer{ShareGuard: &stubKBShareGuard{hasPermission: func(context.Context, string, uint64, types.TenantRole, types.OrgMemberRole,@@ -1250,3 +1373,12 @@ func TestServeFilesForcesActiveContentDownload(t *testing.T) {t.Fatalf("X-Content-Type-Options = %q, want nosniff", got)}}++func (s *stubResourceCatalog) GetMessageFileBindings(+ context.Context,+ uint64,+ string,+ string,+) (*types.MessageFileBindings, error) {+ return s.fileBindings, nil+}diff --git a/internal/router/routes_knowledge.go b/internal/router/routes_knowledge.goindex dc11aa4d9..e5a30516f 100644--- a/internal/router/routes_knowledge.go+++ b/internal/router/routes_knowledge.go@@ -62,8 +62,8 @@ func RegisterChunkRoutes(r *gin.RouterGroup, handler *handler.ChunkHandler, g *r// edit/delete any of its documents while a non-owner Contributor gets// 403. KB-scoped upload routes (`/knowledge-bases/:id/knowledge/...`)// reuse OwnedKBOrAdmin because the URL :id is the KB id directly.-// Cross-:id batch operations stay Contributor-gated — they don't have-// a single owning KB to check against.+// Body-scoped batch operations have a Contributor route gate and resolve+// their KB ownership plus Editor operation grant inside the handler.func RegisterKnowledgeRoutes(r *gin.RouterGroup, handler *handler.KnowledgeHandler, g *rbacGuards) {// 知识库下的知识路由组(URL :id is the KB id)。Scoped API key 需要// ingest 能力才能写内容,且仍受 KB 范围限制;清空 KB 只允许 full-access key。diff --git a/internal/router/task.go b/internal/router/task.goindex 7dcd6d3f3..a3ebad502 100644--- a/internal/router/task.go+++ b/internal/router/task.go@@ -338,7 +338,9 @@ func RunAsynqServer(params AsynqTaskParams) *asynq.ServeMux {// document-related asynq payload. Kept narrow so we don't accidentally// depend on the full payload schema and survive future field churn.type deadLetterKnowledgePayload struct {- KnowledgeID string `json:"knowledge_id,omitempty"`+ TenantID uint64 `json:"tenant_id"`+ KnowledgeBaseID string `json:"knowledge_base_id"`+ KnowledgeID string `json:"knowledge_id,omitempty"`// Attempt threads through DocumentProcess / ManualProcess /// KnowledgePostProcess payloads (added when span tracking shipped)// — extracted here so the dead-letter callback can also close the@@ -369,10 +371,6 @@ var taskTypesAffectingKnowledgeStatus = map[string]struct{}{types.TypeManualProcess: {},}-type deadLetterKnowledgeListDeletePayload struct {- KnowledgeIDs []string `json:"knowledge_ids,omitempty"`-}-// newDeadLetterKnowledgeFailer returns the callback wired into the asynq// dead-letter middleware. When a document-related task exhausts its retry// budget, this callback marks the corresponding Knowledge row as failed so@@ -391,7 +389,7 @@ func newDeadLetterKnowledgeFailer(ks interfaces.KnowledgeService, tracker servicreturn nil}return func(ctx context.Context, t *asynq.Task, taskErr error) {- if t == nil {+ if t == nil || taskErr == nil || errors.Is(taskErr, asynq.SkipRetry) {return}if t.Type() == types.TypeKnowledgeListDelete {@@ -402,7 +400,19 @@ func newDeadLetterKnowledgeFailer(ks interfaces.KnowledgeService, tracker servicreturn}var probe deadLetterKnowledgePayload- if err := json.Unmarshal(t.Payload(), &probe); err != nil || probe.KnowledgeID == "" {+ if err := json.Unmarshal(t.Payload(), &probe); err != nil || probe.KnowledgeID == "" ||+ probe.KnowledgeBaseID == "" ||+ probe.TenantID == 0 {+ return+ }+ row, err := repo.GetKnowledgeByID(ctx, probe.TenantID, probe.KnowledgeID)+ if err != nil || row == nil || row.ID != probe.KnowledgeID || row.TenantID != probe.TenantID ||+ row.KnowledgeBaseID != probe.KnowledgeBaseID {+ return+ }+ switch row.ParseStatus {+ case types.ParseStatusPending, types.ParseStatusProcessing, types.ParseStatusFinalizing:+ default:return}errMsg := "task " + t.Type() + " exhausted retries: " + taskErr.Error()@@ -410,14 +420,16 @@ func newDeadLetterKnowledgeFailer(ks interfaces.KnowledgeService, tracker servicif len(errMsg) > 8192 {errMsg = errMsg[:8192]}- // Single UPDATE so we never end up with parse_status=failed but- // stale error_message (or vice versa) when the second write- // fails.- if err := repo.UpdateKnowledgeColumns(ctx, probe.KnowledgeID, map[string]interface{}{- "parse_status": types.ParseStatusFailed,- "error_message": errMsg,- }); err != nil {- logger.Warnf(ctx, "dead-letter callback: failed to mark knowledge %s as failed: %v", probe.KnowledgeID, err)+ before, after := *row, *row+ after.ParseStatus = types.ParseStatusFailed+ after.ErrorMessage = errMsg+ if err := repo.UpdateKnowledgeForTransfer(ctx, &before, &after); err != nil {+ logger.Warnf(+ ctx,+ "dead-letter callback: knowledge %s changed or failed to update: %v",+ probe.KnowledgeID,+ err,+ )return}// Close the matching root span so the timeline stops showing@@ -437,10 +449,29 @@ func markKnowledgeListDeleteFailed(t *asynq.Task,taskErr error,) {- var payload deadLetterKnowledgeListDeletePayload- if err := json.Unmarshal(t.Payload(), &payload); err != nil || len(payload.KnowledgeIDs) == 0 {+ // A rejected scope must not gain a side effect through the failure path.+ if errors.Is(taskErr, asynq.SkipRetry) {+ return+ }+ var payload types.KnowledgeListDeletePayload+ if err := json.Unmarshal(t.Payload(), &payload); err != nil || payload.TenantID == 0 ||+ len(payload.KnowledgeIDs) == 0 {return}+ if payload.KnowledgeBaseID == "" {+ rows, err := repo.GetKnowledgeBatch(ctx, payload.TenantID, payload.KnowledgeIDs)+ if err != nil || len(rows) == 0 {+ return+ }+ for _, row := range rows {+ if row == nil || row.TenantID != payload.TenantID || row.KnowledgeBaseID == "" ||+ (payload.KnowledgeBaseID != "" && payload.KnowledgeBaseID != row.KnowledgeBaseID) {+ return+ }+ payload.KnowledgeBaseID = row.KnowledgeBaseID+ }+ }+errMsg := "delete task exhausted retries: " + taskErr.Error()if len(errMsg) > 8192 {errMsg = errMsg[:8192]@@ -449,10 +480,16 @@ func markKnowledgeListDeleteFailed(if knowledgeID == "" {continue}- updated, err := repo.UpdateActiveDeletingKnowledgeColumns(ctx, knowledgeID, map[string]interface{}{- "parse_status": types.ParseStatusFailed,- "error_message": errMsg,- })+ updated, err := repo.UpdateActiveDeletingKnowledgeColumns(+ ctx,+ payload.TenantID,+ payload.KnowledgeBaseID,+ knowledgeID,+ map[string]interface{}{+ "parse_status": types.ParseStatusFailed,+ "error_message": errMsg,+ },+ )if err != nil {logger.Warnf(ctx, "dead-letter callback: failed to mark delete failure for knowledge %s: %v", knowledgeID, err)continuediff --git a/internal/router/task_delete_scope_test.go b/internal/router/task_delete_scope_test.gonew file mode 100644index 000000000..b4649676c--- /dev/null+++ b/internal/router/task_delete_scope_test.go@@ -0,0 +1,55 @@+package router++import (+ "context"+ "encoding/json"+ "errors"+ "fmt"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/repository"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/hibiken/asynq"+ "github.com/stretchr/testify/require"+ "gorm.io/driver/sqlite"+ "gorm.io/gorm"+)++func TestDeleteFailureCallbackPreservesTaskScope(t *testing.T) {+ db, err := gorm.Open(sqlite.Open("file:"+t.Name()+"?mode=memory&cache=shared"), &gorm.Config{})+ require.NoError(t, err)+ require.NoError(t, db.AutoMigrate(&types.Knowledge{}))+ for _, row := range []*types.Knowledge{+ {ID: "doc", TenantID: 7, KnowledgeBaseID: "kb", ParseStatus: types.ParseStatusDeleting},+ {ID: "other-kb", TenantID: 7, KnowledgeBaseID: "other", ParseStatus: types.ParseStatusDeleting},+ {ID: "other-tenant", TenantID: 8, KnowledgeBaseID: "kb", ParseStatus: types.ParseStatusDeleting},+ } {+ require.NoError(t, db.Create(row).Error)+ }+ repo := repository.NewKnowledgeRepository(db)+ payload := types.KnowledgeListDeletePayload{+ TenantID: 7,+ KnowledgeBaseID: "kb",+ KnowledgeIDs: []string{"doc", "other-kb", "other-tenant"},+ }+ data, err := json.Marshal(payload)+ require.NoError(t, err)+ task := asynq.NewTask(types.TypeKnowledgeListDelete, data)+ markKnowledgeListDeleteFailed(context.Background(), repo, task, fmt.Errorf("rejected scope: %w", asynq.SkipRetry))+ var count int64+ require.NoError(+ t,+ db.Model(&types.Knowledge{}).Where("parse_status = ?", types.ParseStatusFailed).Count(&count).Error,+ )+ require.Zero(t, count)+ markKnowledgeListDeleteFailed(context.Background(), repo, task, errors.New("graph unavailable"))+ row, err := repo.GetKnowledgeByID(context.Background(), 7, "doc")+ require.NoError(t, err)+ require.Equal(t, types.ParseStatusFailed, row.ParseStatus)+ row, err = repo.GetKnowledgeByID(context.Background(), 7, "other-kb")+ require.NoError(t, err)+ require.Equal(t, types.ParseStatusDeleting, row.ParseStatus)+ row, err = repo.GetKnowledgeByID(context.Background(), 8, "other-tenant")+ require.NoError(t, err)+ require.Equal(t, types.ParseStatusDeleting, row.ParseStatus)+}diff --git a/internal/router/task_processing_scope_test.go b/internal/router/task_processing_scope_test.gonew file mode 100644index 000000000..d44c1b2e6--- /dev/null+++ b/internal/router/task_processing_scope_test.go@@ -0,0 +1,72 @@+package router++import (+ "context"+ "encoding/json"+ "errors"+ "path/filepath"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/repository"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/hibiken/asynq"+ "github.com/stretchr/testify/require"+ "gorm.io/driver/sqlite"+ "gorm.io/gorm"+)++type transferFailureKnowledge struct {+ interfaces.KnowledgeService+ repo interfaces.KnowledgeRepository+}++func (s transferFailureKnowledge) GetRepository() interfaces.KnowledgeRepository { return s.repo }++func TestProcessingFailureCallbackDoesNotFollowMovedDocuments(t *testing.T) {+ db, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "callback.db")), &gorm.Config{})+ require.NoError(t, err)+ sqlDB, err := db.DB()+ require.NoError(t, err)+ t.Cleanup(func() { require.NoError(t, sqlDB.Close()) })+ require.NoError(t, db.AutoMigrate(&types.Knowledge{}))+ repo := repository.NewKnowledgeRepository(db)+ callback := newDeadLetterKnowledgeFailer(transferFailureKnowledge{repo: repo}, nil)+ for _, tc := range []struct {+ id, kb, status string+ tenant uint64+ skip, changed bool+ }{+ {"active", "source", types.ParseStatusProcessing, 7, false, true},+ {"moved", "target", types.ParseStatusProcessing, 7, false, false},+ {"foreign", "source", types.ParseStatusProcessing, 8, false, false},+ {"done", "source", types.ParseStatusCompleted, 7, false, false},+ {"rejected", "source", types.ParseStatusProcessing, 7, true, false},+ } {+ t.Run(tc.id, func(t *testing.T) {+ require.NoError(+ t,+ db.Create(+ &types.Knowledge{ID: tc.id, TenantID: tc.tenant, KnowledgeBaseID: tc.kb, ParseStatus: tc.status},+ ).Error,+ )+ payload, err := json.Marshal(+ types.DocumentProcessPayload{TenantID: 7, KnowledgeBaseID: "source", KnowledgeID: tc.id},+ )+ require.NoError(t, err)+ failure := errors.New("timeout")+ if tc.skip {+ failure = asynq.SkipRetry+ }+ callback(context.Background(), asynq.NewTask(types.TypeDocumentProcess, payload), failure)+ row, err := repo.GetKnowledgeByID(context.Background(), tc.tenant, tc.id)+ require.NoError(t, err)+ if tc.changed {+ require.Equal(t, types.ParseStatusFailed, row.ParseStatus)+ } else {+ require.Equal(t, tc.status, row.ParseStatus)+ require.Empty(t, row.ErrorMessage)+ }+ })+ }+}diff --git a/internal/storageurl/storageurl.go b/internal/storageurl/storageurl.goindex 869268768..66d7001d6 100644--- a/internal/storageurl/storageurl.go+++ b/internal/storageurl/storageurl.go@@ -15,11 +15,11 @@ package storageurlimport ("context"- "regexp""strings""sync""github.com/Tencent/WeKnora/internal/logger"+ "github.com/Tencent/WeKnora/internal/types""github.com/Tencent/WeKnora/internal/types/interfaces")@@ -27,11 +27,7 @@ import (// legacy `provider://` paths, and canonical `storage://<backend-id>/provider://`// paths. The trailing character class stops at Markdown/HTML delimiters so a// reference inside `` or `src="…"` is matched without them.-var Pattern = regexp.MustCompile(- `\b(?:resource://[0-9A-Za-z_-]+|` +- `(?:storage://[0-9A-Za-z_-]+/)?` +- `(?:local|minio|s3|cos|tos|oss|obs|ks3)://[^\s)\]>"]+)`,-)+var Pattern = types.StorageReferencePattern// IsHTTPURL reports whether s is an http(s) URL — the only form an external// client can fetch; any provider scheme (oss://, local://, …) is not. Schemediff --git a/internal/types/caller.go b/internal/types/caller.gonew file mode 100644index 000000000..901ebe4b5--- /dev/null+++ b/internal/types/caller.go@@ -0,0 +1,43 @@+package types++import "context"++// Caller is the authenticated identity used for resource authorization. Its+// tenant and role do not change when queries execute in a resource's tenant.+// Machine capabilities remain in TenantAPIKeyScope; Principal is separate.+type Caller struct {+ TenantID uint64+ UserID string+ Role TenantRole+}++// Normalize defaults an invalid tenant role to Viewer.+func (caller Caller) Normalize() Caller {+ if !caller.Role.IsValid() {+ caller.Role = TenantRoleViewer+ }+ return caller+}++// WithCaller captures the authenticated identity independently of execution scope.+func WithCaller(ctx context.Context, caller Caller) context.Context {+ return context.WithValue(ctx, CallerContextKey, caller.Normalize())+}++// CallerFromContext supports legacy, unscoped service contexts. Always capture+// the caller before changing execution tenants, including a missing identity.+func CallerFromContext(ctx context.Context) Caller {+ if caller, ok := ctx.Value(CallerContextKey).(Caller); ok {+ return caller+ }+ tenantID, _ := TenantIDFromContext(ctx)+ userID, _ := UserIDFromContext(ctx)+ return Caller{TenantID: tenantID, UserID: userID, Role: TenantRoleFromContext(ctx)}+}++// WithExecutionTenant changes repository/model scope, never authorization.+// It does not grant access to any resources in the destination tenant.+func WithExecutionTenant(ctx context.Context, tenantID uint64) context.Context {+ ctx = WithCaller(ctx, CallerFromContext(ctx))+ return context.WithValue(ctx, TenantIDContextKey, tenantID)+}diff --git a/internal/types/const.go b/internal/types/const.goindex 322344092..3b74d6d70 100644--- a/internal/types/const.go+++ b/internal/types/const.go@@ -4,8 +4,16 @@ package typestype ContextKey stringconst (- // TenantIDContextKey is the context key for tenant ID+ // TenantIDContextKey scopes execution (repository/model queries).TenantIDContextKey ContextKey = "TenantID"+ // CallerContextKey captures the authenticated resource caller.+ CallerContextKey ContextKey = "ResourceCaller"+ // KBGrantsContextKey carries immutable operation grants.+ KBGrantsContextKey ContextKey = "ResourceKBGrants"+ // KBTransferContextKey carries one admitted resource pair.+ KBTransferContextKey ContextKey = "ResourceKBTransfer"+ // SharedAgentGrantContextKey carries an authorized agent read scope.+ SharedAgentGrantContextKey ContextKey = "ResourceSharedAgentGrant"// TenantInfoContextKey is the context key for tenant informationTenantInfoContextKey ContextKey = "TenantInfo"// RequestIDContextKey is the context key for request IDdiff --git a/internal/types/context_clone.go b/internal/types/context_clone.goindex ba49c6cf4..258d547b9 100644--- a/internal/types/context_clone.go+++ b/internal/types/context_clone.go@@ -25,12 +25,16 @@ var contextCloneAcrossDetach = map[ContextKey]bool{// principal in the same workspace, so all of this has to survive; a// detached goroutine that loses its tenant reads another tenant's rows or// none at all.- TenantIDContextKey: true,- TenantInfoContextKey: true,- UserContextKey: true,- UserIDContextKey: true,- PrincipalContextKey: true,- SystemAdminContextKey: true,+ TenantIDContextKey: true,+ CallerContextKey: true,+ KBGrantsContextKey: true,+ KBTransferContextKey: true,+ SharedAgentGrantContextKey: true,+ TenantInfoContextKey: true,+ UserContextKey: true,+ UserIDContextKey: true,+ PrincipalContextKey: true,+ SystemAdminContextKey: true,// TenantRoleContextKey: the caller's resolved role in the active tenant// (PR 2 #1303). Must survive for the same reason as TenantIDContextKey —// any handler that does `ctx := logger.CloneContext(c.Request.Context())`diff --git a/internal/types/context_helpers.go b/internal/types/context_helpers.goindex 01aaeac7f..628d084e5 100644--- a/internal/types/context_helpers.go+++ b/internal/types/context_helpers.go@@ -20,7 +20,8 @@ func DefaultLanguage() string {return "zh-CN"}-// TenantIDFromContext extracts the tenant ID from ctx.+// TenantIDFromContext extracts the execution tenant ID from ctx.+// Authorization should use CallerFromContext instead.// Returns (0, false) when the key is absent or the value is not uint64.func TenantIDFromContext(ctx context.Context) (uint64, bool) {v, ok := ctx.Value(TenantIDContextKey).(uint64)diff --git a/internal/types/file_reference.go b/internal/types/file_reference.gonew file mode 100644index 000000000..6275fd2de--- /dev/null+++ b/internal/types/file_reference.go@@ -0,0 +1,56 @@+package types++import (+ "encoding/json"+ "regexp"+ "strings"+)++// StorageReferencePattern is shared by response rewriting and persisted+// reference checks. Matching an entire token prevents path/handle prefix grants.+var StorageReferencePattern = regexp.MustCompile(+ `\b(?:resource://[0-9A-Za-z_-]+|(?:storage://[0-9A-Za-z_-]+/)?` ++ `(?:local|minio|s3|cos|tos|oss|obs|ks3)://[^\s)\]>"]+)`,+)++// ContainsStorageReference matches an exact token in text or nested JSON.+func ContainsStorageReference(text, reference string) bool {+ if reference == "" {+ return false+ }+ // Image metadata and tool outputs may contain nested JSON strings. Decode+ // before tokenizing so escaping neither hides a path nor grants its prefix.+ trimmed := strings.TrimSpace(text)+ if len(trimmed) > 0 && strings.ContainsRune("[{\"", rune(trimmed[0])) {+ var value interface{}+ if json.Unmarshal([]byte(trimmed), &value) == nil {+ return containsStorageReferenceValue(value, reference)+ }+ }+ for _, candidate := range StorageReferencePattern.FindAllString(text, -1) {+ if candidate == reference {+ return true+ }+ }+ return false+}++func containsStorageReferenceValue(value interface{}, reference string) bool {+ switch value := value.(type) {+ case string:+ return ContainsStorageReference(value, reference)+ case []interface{}:+ for _, item := range value {+ if containsStorageReferenceValue(item, reference) {+ return true+ }+ }+ case map[string]interface{}:+ for _, item := range value {+ if containsStorageReferenceValue(item, reference) {+ return true+ }+ }+ }+ return false+}diff --git a/internal/types/file_reference_test.go b/internal/types/file_reference_test.gonew file mode 100644index 000000000..265534cd6--- /dev/null+++ b/internal/types/file_reference_test.go@@ -0,0 +1,34 @@+package types++import "testing"++func TestContainsStorageReference(t *testing.T) {+ for _, tt := range []struct {+ name, text, reference string+ want bool+ }{+ {"markdown", "", "local://7/exports/chart.png", true},+ {"path prefix", "", "local://7/exports/chart.png", false},+ {+ "nested image metadata",+ `{"image_info":"[{\"url\":\"local://7/exports/chart.png\"}]"}`,+ "local://7/exports/chart.png",+ true,+ },++ {+ "escaped handle suffix",+ `{"url":"resource://AbCdEfGhIjKlMnOpQrStUv\u0058"}`,+ "resource://AbCdEfGhIjKlMnOpQrStUv",+ false,+ },++ {"empty reference", `{"url":"local://7/exports/chart.png"}`, "", false},+ } {+ t.Run(tt.name, func(t *testing.T) {+ if got := ContainsStorageReference(tt.text, tt.reference); got != tt.want {+ t.Fatalf("ContainsStorageReference = %v, want %v", got, tt.want)+ }+ })+ }+}diff --git a/internal/types/interfaces/chunk.go b/internal/types/interfaces/chunk.goindex 28cf8a4c6..c8f7db2bd 100644--- a/internal/types/interfaces/chunk.go+++ b/internal/types/interfaces/chunk.go@@ -14,6 +14,10 @@ type ChunkImageInfo struct {// ChunkRepository defines the interface for chunk repository operationstype ChunkRepository interface {+ // ListAllChunksByKnowledgeID includes every type and storage status for+ // scoped lifecycle operations; UI pagination hides unindexed chunks.+ ListAllChunksByKnowledgeID(ctx context.Context, tenantID uint64, knowledgeID string) ([]*types.Chunk, error)+// CreateChunks creates chunksCreateChunks(ctx context.Context, chunks []*types.Chunk) error// GetChunkByID gets a chunk by id@@ -131,6 +135,9 @@ type ChunkRepository interface {ListRecentDocumentChunksWithQuestions(ctx context.Context, tenantID uint64, kbIDs []string, knowledgeIDs []string, limit int) ([]*types.Chunk, error)}+// ChunkService mutations require explicit KB write grants and validate persisted+// document bindings. Trusted processing/rollback code uses ChunkRepository after+// its own task admission; the execution tenant alone is not a write grant.// ChunkService defines the interface for chunk service operationstype ChunkService interface {// CreateChunks creates chunksdiff --git a/internal/types/interfaces/knowledge.go b/internal/types/interfaces/knowledge.goindex b8179351c..7dcf240d6 100644--- a/internal/types/interfaces/knowledge.go+++ b/internal/types/interfaces/knowledge.go@@ -101,7 +101,8 @@ type KnowledgeService interface {RenameKnowledgeFolder(ctx context.Context, kbID string, from string, to string) (int64, error)// DeleteKnowledge deletes knowledge by ID.DeleteKnowledge(ctx context.Context, id string) error- // DeleteKnowledgeList deletes multiple knowledge entries by IDs.+ // DeleteKnowledgeList requires an explicit write grant for every affected KB.+ // It validates the complete selection before changing any deletion state.DeleteKnowledgeList(ctx context.Context, ids []string) error// GetKnowledgeFile retrieves the file associated with the knowledge.GetKnowledgeFile(ctx context.Context, id string) (io.ReadCloser, string, error)@@ -178,7 +179,7 @@ type KnowledgeService interface {ExportFAQEntriesJSON(ctx context.Context, kbID string) ([]byte, error)// UpdateKnowledgeTagBatch updates tag for document knowledge items in batch.// authorizedKBID restricts all updates to knowledge items belonging to this KB;- // pass empty string to skip (caller must ensure authorization by other means).+ // an empty value still requires an explicit write grant for every affected KB.UpdateKnowledgeTagBatch(ctx context.Context, authorizedKBID string, updates map[string][]string) error// SetKnowledgeTags replaces all tags for a single knowledge entry.SetKnowledgeTags(ctx context.Context, knowledgeID string, tagIDs []string) error@@ -241,6 +242,10 @@ type KnowledgeRepository interface {tenantID uint64, kbID string, page *types.Pagination, filter types.KnowledgeListFilter,) ([]*types.Knowledge, int64, error)UpdateKnowledge(ctx context.Context, knowledge *types.Knowledge) error+ // UpdateKnowledgeForTransfer conditionally persists a transfer checkpoint+ // and its storage delta in one transaction, without inserting missing rows.+ UpdateKnowledgeForTransfer(ctx context.Context, before, after *types.Knowledge) error+// UpdateKnowledgeBatch updates knowledge items in batchUpdateKnowledgeBatch(ctx context.Context, knowledgeList []*types.Knowledge) errorDeleteKnowledge(ctx context.Context, tenantID uint64, id string) error@@ -291,7 +296,12 @@ type KnowledgeRepository interface {UpdateKnowledgeColumns(ctx context.Context, id string, values map[string]interface{}) error// UpdateActiveDeletingKnowledgeColumns updates an active, non-deleted knowledge row// only when it is still in the transient deleting state.- UpdateActiveDeletingKnowledgeColumns(ctx context.Context, id string, values map[string]interface{}) (bool, error)+ UpdateActiveDeletingKnowledgeColumns(+ ctx context.Context,+ tenantID uint64,+ kbID, id string,+ values map[string]interface{},+ ) (bool, error)// FinalizeSubtask atomically decrements pending_subtasks_count for the// given knowledge and promotes parse_status from "finalizing" to// "completed" when the count reaches zero. Returns the post-decrementdiff --git a/internal/types/interfaces/resource.go b/internal/types/interfaces/resource.goindex 12dd33f64..c7ceb24f3 100644--- a/internal/types/interfaces/resource.go+++ b/internal/types/interfaces/resource.go@@ -26,6 +26,16 @@ type ResourceRepository interface {CreateBinding(ctx context.Context, binding *types.ResourceBinding) errorDeleteBinding(ctx context.Context, resourceID, ownerType, ownerID string) errorCountBindings(ctx context.Context, resourceID string) (int64, error)+ IsReferencedByKnowledgeBase(+ ctx context.Context,+ tenantID uint64,+ kbID, resourceID string,+ ) (bool, error)+ GetMessageFileBindings(+ ctx context.Context,+ tenantID uint64,+ resourceID, messageID string,+ ) (*types.MessageFileBindings, error)CreateGrant(ctx context.Context, grant *types.ResourceAccessGrant) errorGetValidGrant(ctx context.Context, tokenHash string, now time.Time) (*types.ResourceAccessGrant, error)DeleteExpiredGrants(ctx context.Context, before time.Time) error@@ -62,3 +72,19 @@ type ResourceCatalog interface {CreateAccessGrant(ctx context.Context, reference string, ttl time.Duration) (string, error)ResolveAccessGrant(ctx context.Context, token string) (*types.StoredResource, error)}++// KBResourceLookup verifies an explicit binding to a live knowledge document.+// Text references and common storage tenancy never establish ownership.+type KBResourceLookup interface {+ IsReferencedByKnowledgeBase(ctx context.Context, tenantID uint64, kbID, reference string) (bool, error)+}++// MessageFileBindingLookup resolves explicit KB and message-artifact bindings.+// Only the catalog can turn a raw locator into a registered resource identity.+type MessageFileBindingLookup interface {+ GetMessageFileBindings(+ ctx context.Context,+ tenantID uint64,+ reference, messageID string,+ ) (*types.MessageFileBindings, error)+}diff --git a/internal/types/interfaces/retriever.go b/internal/types/interfaces/retriever.goindex 581810557..f19d4d161 100644--- a/internal/types/interfaces/retriever.go+++ b/internal/types/interfaces/retriever.go@@ -154,3 +154,18 @@ type RetrieveEngineService interface {// RetrieveEngine retrieves the engineRetrieveEngine}++// KnowledgeIndexMover changes the KB binding of existing indices, preserving+// their chunk IDs and vectors. It must match both source KB and document,+// clear KB-scoped tags, and be safe to repeat after a partial failure.+// CopyIndices followed by DeleteByKnowledgeIDList cannot implement this: the+// unchanged knowledge ID also selects the destination rows for deletion.+type KnowledgeIndexMover interface {+ MoveKnowledgeIndices(+ ctx context.Context,+ sourceKB, targetKB, knowledgeID string,+ chunkIDs []string,+ dimension int,+ knowledgeType string,+ ) error+}diff --git a/internal/types/knowledge.go b/internal/types/knowledge.goindex aeac79bcf..6253423ad 100644--- a/internal/types/knowledge.go+++ b/internal/types/knowledge.go@@ -335,6 +335,9 @@ func (k *Knowledge) ManualMetadata() (*ManualKnowledgeMetadata, error) {return &metadata, nil}+// KnowledgeTransferMetadataKey is reserved for server-owned transfer recovery state.+const KnowledgeTransferMetadataKey = "_knowledge_transfer"+// SetManualMetadata sets manual knowledge metadata onto the knowledge instance.func (k *Knowledge) SetManualMetadata(meta *ManualKnowledgeMetadata) error {if meta == nil {@@ -345,6 +348,23 @@ func (k *Knowledge) SetManualMetadata(meta *ManualKnowledgeMetadata) error {if err != nil {return err}+ // Manual processing may finish before the move worker acknowledges its+ // task. Preserve the recovery marker when updating manual content/status.+ old, err := k.Metadata.Map()+ if err != nil {+ return err+ }+ if state, ok := old[KnowledgeTransferMetadataKey]; ok {+ fields, err := jsonValue.Map()+ if err != nil {+ return err+ }+ fields[KnowledgeTransferMetadataKey] = state+ jsonValue, err = json.Marshal(fields)+ if err != nil {+ return err+ }+ }k.Metadata = jsonValuereturn nil}diff --git a/internal/types/resource.go b/internal/types/resource.goindex 1acacd6bd..350dcab79 100644--- a/internal/types/resource.go+++ b/internal/types/resource.go@@ -82,6 +82,13 @@ func (r *StoredResource) BeforeCreate(_ *gorm.DB) error {return nil}+// MessageFileBindings contains authoritative file origins for an authorized message.+// MessageArtifact requires an explicit artifact binding to that exact message.+type MessageFileBindings struct {+ KnowledgeBaseIDs []string+ MessageArtifact bool+}+// ResourceBinding connects a resource to a domain object that owns or uses it.type ResourceBinding struct {ID string `json:"id" gorm:"type:varchar(36);primaryKey"`diff --git a/internal/types/shared_agent_access.go b/internal/types/shared_agent_access.gonew file mode 100644index 000000000..8af93e79f--- /dev/null+++ b/internal/types/shared_agent_access.go@@ -0,0 +1,60 @@+package types++// SharedAgentKBScope describes the KBs exposed by an already-authorized shared+// agent. It is not proof that a caller can use that agent. The zero value, an+// unknown selection mode, and an empty selection all deny access.+type SharedAgentKBScope struct {+ tenantID uint64+ all bool+ ids []string+ selected map[string]struct{}+}++// NewSharedAgentKBScope snapshots an authorized agent configuration.+func NewSharedAgentKBScope(agent *CustomAgent) SharedAgentKBScope {+ if agent == nil || agent.TenantID == 0 {+ return SharedAgentKBScope{}+ }+ scope := SharedAgentKBScope{tenantID: agent.TenantID}+ switch agent.Config.KBSelectionMode {+ case "all":+ scope.all = true+ case "selected":+ scope.selected = make(map[string]struct{}, len(agent.Config.KnowledgeBases))+ for _, id := range agent.Config.KnowledgeBases {+ if id == "" {+ continue+ }+ if _, exists := scope.selected[id]; exists {+ continue+ }+ scope.selected[id] = struct{}{}+ scope.ids = append(scope.ids, id)+ }+ }+ return scope+}++// IsAll reports whether every KB in the source tenant is selected.+func (s SharedAgentKBScope) IsAll() bool { return s.all }++// IsEmpty reports whether the scope authorizes no KBs.+func (s SharedAgentKBScope) IsEmpty() bool { return !s.all && len(s.ids) == 0 }++// IDs returns a copy of the explicit selection. Use IsAll to distinguish a+// whole-tenant scope from an empty selection; nil never means unrestricted.+func (s SharedAgentKBScope) IDs() []string { return append([]string{}, s.ids...) }++// Allows checks both the KB selection and the authoritative owner tenant.+func (s SharedAgentKBScope) Allows(kbID string, tenantID uint64) bool {+ if kbID == "" || s.tenantID == 0 || s.tenantID != tenantID {+ return false+ }+ _, selected := s.selected[kbID]+ return s.all || selected+}++// SharedAgentIncludesKB also binds an "all" selection to the agent's tenant.+func SharedAgentIncludesKB(agent *CustomAgent, kb *KnowledgeBase) bool {+ return kb != nil && NewSharedAgentKBScope(agent).Allows(kb.ID, kb.TenantID)+}diff --git a/internal/types/shared_agent_access_test.go b/internal/types/shared_agent_access_test.gonew file mode 100644index 000000000..dd3a11f74--- /dev/null+++ b/internal/types/shared_agent_access_test.go@@ -0,0 +1,54 @@+package types++import (+ "testing"++ "github.com/stretchr/testify/require"+)++func TestSharedAgentKBScope(t *testing.T) {+ for _, tt := range []struct {+ name, mode string+ ids []string+ all, empty, allows bool+ }{+ {name: "all", mode: "all", all: true, allows: true},+ {name: "selected", mode: "selected", ids: []string{"kb"}, allows: true},+ {name: "other selection", mode: "selected", ids: []string{"other"}},+ {name: "empty selection", mode: "selected", empty: true},+ {name: "blank selection", mode: "selected", ids: []string{""}, empty: true},+ {name: "none", mode: "none", ids: []string{"kb"}, empty: true},+ {name: "unknown mode", mode: "unknown", ids: []string{"kb"}, empty: true},+ {name: "missing mode", empty: true},+ } {+ t.Run(tt.name, func(t *testing.T) {+ agent := &CustomAgent{+ TenantID: 2,+ Config: CustomAgentConfig{KBSelectionMode: tt.mode, KnowledgeBases: tt.ids},+ }+ scope := NewSharedAgentKBScope(agent)+ require.Equal(t, tt.all, scope.IsAll())+ require.Equal(t, tt.empty, scope.IsEmpty())+ require.Equal(t, tt.allows, scope.Allows("kb", 2))+ require.False(t, scope.Allows("kb", 3), "even all is tenant-bound")+ require.False(t, scope.Allows("", 2))+ require.Equal(t, tt.allows, SharedAgentIncludesKB(agent, &KnowledgeBase{ID: "kb", TenantID: 2}))+ })+ }+ require.True(t, NewSharedAgentKBScope(nil).IsEmpty())+ require.False(t, SharedAgentIncludesKB(nil, &KnowledgeBase{ID: "kb", TenantID: 2}))+}++func TestSharedAgentKBScopeCopiesSelection(t *testing.T) {+ agent := &CustomAgent{+ TenantID: 2,+ Config: CustomAgentConfig{KBSelectionMode: "selected", KnowledgeBases: []string{"kb", "", "kb"}},+ }+ scope := NewSharedAgentKBScope(agent)+ require.Equal(t, []string{"kb"}, scope.IDs())+ agent.Config.KnowledgeBases[0] = "other"+ ids := scope.IDs()+ ids[0] = "other"+ require.True(t, scope.Allows("kb", 2))+ require.False(t, scope.Allows("other", 2))+}diff --git a/internal/types/task.go b/internal/types/task.goindex 6b8495ac0..fcbeb8b1f 100644--- a/internal/types/task.go+++ b/internal/types/task.go@@ -407,6 +407,10 @@ type KBClonePayload struct {SourceID string `json:"source_id"`TargetID string `json:"target_id"`Initiator TaskInitiator `json:"initiator,omitempty"`+ // New clone destinations are reserved by the server at admission and+ // created by the worker once. Retries retain both ID and creator.+ CreateTarget bool `json:"create_target,omitempty"`+ CreatorID string `json:"creator_id,omitempty"`}// IndexDeletePayload represents the index delete task payload@@ -440,18 +444,20 @@ type KBDeletePayload struct {// KnowledgeListDeletePayload represents the batch knowledge delete task payloadtype KnowledgeListDeletePayload struct {TracingContext- TenantID uint64 `json:"tenant_id"`- KnowledgeIDs []string `json:"knowledge_ids"`- Initiator TaskInitiator `json:"initiator,omitempty"`+ TenantID uint64 `json:"tenant_id"`+ KnowledgeIDs []string `json:"knowledge_ids"`+ Initiator TaskInitiator `json:"initiator,omitempty"`+ KnowledgeBaseID string `json:"knowledge_base_id,omitempty"`}// KnowledgeListReparsePayload represents the batch knowledge reparse task payloadtype KnowledgeListReparsePayload struct {TracingContext- TenantID uint64 `json:"tenant_id"`- KnowledgeIDs []string `json:"knowledge_ids"`- ProcessConfig *KnowledgeProcessOverrides `json:"process_config,omitempty"`- Initiator TaskInitiator `json:"initiator,omitempty"`+ KnowledgeBaseID string `json:"knowledge_base_id,omitempty"`+ TenantID uint64 `json:"tenant_id"`+ KnowledgeIDs []string `json:"knowledge_ids"`+ ProcessConfig *KnowledgeProcessOverrides `json:"process_config,omitempty"`+ Initiator TaskInitiator `json:"initiator,omitempty"`}// KnowledgeMovePayload represents the knowledge move task payload