Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
refactor(api): separate app MCP server service and persistence (#42850)
Byron.wang0c5f2507d0bb
diff --git a/api/.importlinter b/api/.importlinterindex e010fe8a0e9..c7a355e1c78 100644--- a/api/.importlinter+++ b/api/.importlinter@@ -786,6 +786,46 @@ forbidden_modules =taskswerkzeug+[importlinter:contract:app-mcp-server-service-boundary]+name = App MCP server application service is framework and persistence neutral+type = forbidden+source_modules =+ services.app.mcp_server_service+forbidden_modules =+ configs+ controllers+ extensions+ flask+ models+ repositories+ sqlalchemy+ werkzeug++[importlinter:contract:console-app-mcp-server-controller-boundary]+name = Console App MCP server controller reaches persistence only through the composition root+type = forbidden+source_modules =+ controllers.console.app.mcp_server+forbidden_modules =+ extensions.ext_database+ models.model+ repositories+ sqlalchemy+# The composition root (extensions.ext_application_services) wires repositories,+# so only direct imports are checked here.+allow_indirect_imports = True++[importlinter:contract:console-app-wraps-boundary]+name = Console app decorators load App rows without reaching into repositories+type = forbidden+source_modules =+ controllers.console.app.wraps+forbidden_modules =+ repositories+# models.model / models.workflow lazily import repositories.factory (legacy debt),+# so only direct imports are checked here.+allow_indirect_imports = True+[importlinter:contract:app-audio-boundary]name = App audio operations and values are framework and persistence neutraltype = forbiddendiff --git a/api/controllers/console/app/mcp_server.py b/api/controllers/console/app/mcp_server.pyindex d6615124cb3..390a580bbb8 100644--- a/api/controllers/console/app/mcp_server.py+++ b/api/controllers/console/app/mcp_server.py@@ -1,32 +1,31 @@import jsonfrom datetime import datetimefrom typing import Any+from uuid import UUIDfrom flask_restx import Resourcefrom pydantic import BaseModel, Field, field_validator-from sqlalchemy import select-from werkzeug.exceptions import NotFound+from werkzeug.exceptions import Conflict, NotFoundfrom controllers.common.rbac import PlainApp, RBACCheckfrom controllers.common.schema import register_schema_modelsfrom controllers.console import console_ns-from controllers.console.app.wraps import get_app_model-from controllers.console.wraps import (- RBACPermission,- account_initialization_required,- edit_permission_required,- model_validate,- rbac_permission_required,- setup_required,- with_current_tenant_id,-)-from extensions.ext_database import db+from controllers.console.app.error import AppNotFoundError+from controllers.console.flask_admission import console_account_admission+from controllers.console.wraps import RBACPermission, validate_request+from extensions.ext_application_services import application_servicesfrom fields.base import ResponseModelfrom libs.helper import dump_response, to_timestamp-from libs.login import login_required-from models.enums import AppMCPServerStatus-from models.model import App, AppMCPServer-from services.app_ref_service import AppRefService+from machinery.context import RequestContext+from models.account import TenantAccountRole+from services.app.mcp_server_service import (+ AppMCPServerAlreadyExistsError,+ AppMCPServerAppNotFoundError,+ AppMCPServerNotFoundError,+ AppMCPServerStatus,+)++_EDIT_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR})class MCPServerCreatePayload(BaseModel):@@ -38,13 +37,13 @@ class MCPServerCreatePayload(BaseModel):class MCPServerUpdatePayload(BaseModel):- id: str = Field(..., description="Server ID")+ id: UUID = Field(..., description="Server ID")description: str | None = Field(default=None, description="Server description")parameters: dict[str, Any] = Field(...,description="Server parameters configuration",)- status: str | None = Field(default=None, description="Server status")+ status: AppMCPServerStatus | None = Field(default=None, description="Server status")class AppMCPServerResponse(ResponseModel):@@ -84,13 +83,12 @@ class AppMCPServerController(Resource):@console_ns.response(200, "MCP server configuration retrieved successfully", console_ns.models[AppMCPServerResponse.__name__])- @login_required- @account_initialization_required- @setup_required- @rbac_permission_required(RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp()))- @get_app_model- def get(self, app_model: App):- server = db.session.scalar(select(AppMCPServer).where(AppMCPServer.app_id == app_model.id).limit(1))+ @console_account_admission(rbac_checks=[RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())])+ def get(self, request_context: RequestContext, app_id: UUID):+ try:+ server = application_services().app_mcp_servers.get(request_context, str(app_id))+ except AppMCPServerAppNotFoundError as error:+ raise AppNotFoundError() from errorif server is None:return {}return dump_response(AppMCPServerResponse, server)@@ -103,30 +101,18 @@ class AppMCPServerController(Resource):201, "MCP server configuration created successfully", console_ns.models[AppMCPServerResponse.__name__])@console_ns.response(403, "Insufficient permissions")- @account_initialization_required- @login_required- @setup_required- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.APP_EDIT, PlainApp()))- @with_current_tenant_id- @get_app_model- @model_validate(MCPServerCreatePayload)- def post(self, req_data: MCPServerCreatePayload, current_tenant_id: str, app_model: App):- description = req_data.description- if not description:- description = app_model.description or ""-- server = AppMCPServer(- name=app_model.name,- description=description,- parameters=json.dumps(req_data.parameters, ensure_ascii=False),- status=AppMCPServerStatus.ACTIVE,- app_id=app_model.id,- tenant_id=current_tenant_id,- server_code=AppMCPServer.generate_server_code(16, session=db.session()),- )- db.session.add(server)- db.session.commit()+ @console_ns.response(409, "MCP server already exists for this app")+ @console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.APP_EDIT, PlainApp())])+ def post(self, request_context: RequestContext, app_id: UUID):+ payload = validate_request(MCPServerCreatePayload)+ try:+ server = application_services().app_mcp_servers.create(+ request_context, str(app_id), description=payload.description, parameters=payload.parameters+ )+ except AppMCPServerAppNotFoundError as error:+ raise AppNotFoundError() from error+ except AppMCPServerAlreadyExistsError as error:+ raise Conflict(str(error)) from errorreturn dump_response(AppMCPServerResponse, server), 201@console_ns.doc("update_app_mcp_server")@@ -138,43 +124,22 @@ class AppMCPServerController(Resource):)@console_ns.response(403, "Insufficient permissions")@console_ns.response(404, "Server not found")- @login_required- @setup_required- @account_initialization_required- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.APP_EDIT, PlainApp()))- @get_app_model- @model_validate(MCPServerUpdatePayload)- def put(self, req_data: MCPServerUpdatePayload, app_model: App):- app_ref = AppRefService.create_app_ref(app_model)- server_ref = AppRefService.create_mcp_server_ref(app_ref, req_data.id)- server = db.session.scalar(- select(AppMCPServer)- .where(- AppMCPServer.id == server_ref.server_id,- AppMCPServer.tenant_id == server_ref.app.tenant_id,- AppMCPServer.app_id == server_ref.app.app_id,+ @console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.APP_EDIT, PlainApp())])+ def put(self, request_context: RequestContext, app_id: UUID):+ payload = validate_request(MCPServerUpdatePayload)+ try:+ server = application_services().app_mcp_servers.update(+ request_context,+ str(app_id),+ server_id=str(payload.id),+ description=payload.description,+ parameters=payload.parameters,+ status=payload.status,)- .limit(1)- )- if not server:- raise NotFound()-- description = req_data.description- if description is None or not description:- server.description = app_model.description or ""- else:- server.description = description-- server.name = app_model.name-- server.parameters = json.dumps(req_data.parameters, ensure_ascii=False)- if req_data.status:- try:- server.status = AppMCPServerStatus(req_data.status)- except ValueError:- raise ValueError("Invalid status")- db.session.commit()+ except AppMCPServerAppNotFoundError as error:+ raise AppNotFoundError() from error+ except AppMCPServerNotFoundError as error:+ raise NotFound from errorreturn dump_response(AppMCPServerResponse, server)@@ -186,21 +151,12 @@ class AppMCPServerRefreshController(Resource):@console_ns.response(200, "MCP server refreshed successfully", console_ns.models[AppMCPServerResponse.__name__])@console_ns.response(403, "Insufficient permissions")@console_ns.response(404, "Server not found")- @setup_required- @login_required- @account_initialization_required- @edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.APP_EDIT, PlainApp()))- @with_current_tenant_id- @get_app_model- def post(self, current_tenant_id: str, app_model: App):- server = db.session.scalar(- select(AppMCPServer)- .where(AppMCPServer.app_id == app_model.id, AppMCPServer.tenant_id == current_tenant_id)- .limit(1)- )- if not server:- raise NotFound()- server.server_code = AppMCPServer.generate_server_code(16, session=db.session())- db.session.commit()+ @console_account_admission(allowed_roles=_EDIT_ROLES, rbac_checks=[RBACCheck(RBACPermission.APP_EDIT, PlainApp())])+ def post(self, request_context: RequestContext, app_id: UUID):+ try:+ server = application_services().app_mcp_servers.refresh(request_context, str(app_id))+ except AppMCPServerAppNotFoundError as error:+ raise AppNotFoundError() from error+ except AppMCPServerNotFoundError as error:+ raise NotFound from errorreturn dump_response(AppMCPServerResponse, server)diff --git a/api/controllers/console/app/wraps.py b/api/controllers/console/app/wraps.pyindex badb69ce58a..ce67a35bce4 100644--- a/api/controllers/console/app/wraps.py+++ b/api/controllers/console/app/wraps.py@@ -18,6 +18,7 @@ from extensions.ext_database import dbfrom libs.login import current_account_with_tenantfrom models import App, AppModefrom models.agent import AgentScope+from models.enums import AppStatus__all__ = ["get_app_model",@@ -25,31 +26,28 @@ __all__ = []-def _is_hidden_backing_app(app_model: App, session: Session | scoped_session) -> bool:- binding = app_model.agent_app_binding_with_session(session=session, include_archived=True)- return binding is not None and binding.scope == AgentScope.WORKFLOW_ONLY---def _load_app_model(session: Session, app_id: str) -> App | None:- """Load the tenant-scoped app row with the request session owned by `with_session`."""+def _load_app_model(session: Session | scoped_session, app_id: str) -> App | None:+ """Load the tenant-scoped Console app row through the given session."""_, current_tenant_id = current_account_with_tenant()app_model = session.scalar(- select(App).where(App.id == app_id, App.tenant_id == current_tenant_id, App.status == "normal").limit(1)+ select(App)+ .where(+ App.id == app_id,+ App.tenant_id == current_tenant_id,+ App.status == AppStatus.NORMAL,+ )+ .limit(1))- if app_model is not None and _is_hidden_backing_app(app_model, session):- return None+ if app_model is not None:+ binding = app_model.agent_app_binding_with_session(session=session, include_archived=True)+ if binding is not None and binding.scope == AgentScope.WORKFLOW_ONLY:+ return Nonereturn app_modeldef _load_app_model_from_scoped_session(app_id: str) -> App | None:"""Load the app row for legacy handlers that have not adopted request session injection yet."""- _, current_tenant_id = current_account_with_tenant()- app_model = db.session.scalar(- select(App).where(App.id == app_id, App.tenant_id == current_tenant_id, App.status == "normal").limit(1)- )- if app_model is not None and _is_hidden_backing_app(app_model, db.session):- return None- return app_model+ return _load_app_model(db.session, app_id)def _get_injected_session(args: tuple[object, ...]) -> Session | None:diff --git a/api/controllers/mcp/mcp.py b/api/controllers/mcp/mcp.pyindex 818733695e7..65e240827eb 100644--- a/api/controllers/mcp/mcp.py+++ b/api/controllers/mcp/mcp.py@@ -13,8 +13,9 @@ from core.mcp.server.streamable_http import handle_mcp_request, negotiate_protocfrom extensions.ext_database import dbfrom graphon.variables.input_entities import VariableEntity, VariableEntityTypefrom libs import helper-from models.enums import AppMCPServerStatus, EndUserType+from models.enums import EndUserTypefrom models.model import App, AppMCPServer, AppMode, EndUser+from services.app.mcp_server_service import AppMCPServerStatusclass MCPRequestError(Exception):@@ -130,7 +131,7 @@ class MCPAppApi(Resource):def _validate_server_status(self, mcp_server: AppMCPServer):"""Validate MCP server status"""- if mcp_server.status != AppMCPServerStatus.ACTIVE:+ if mcp_server.status != AppMCPServerStatus.ACTIVE.value:raise MCPRequestError(mcp_types.INVALID_REQUEST, "Server is not active")def _process_mcp_message(diff --git a/api/extensions/ext_application_services.py b/api/extensions/ext_application_services.pyindex fdbae58ee70..36ce5b41153 100644--- a/api/extensions/ext_application_services.py+++ b/api/extensions/ext_application_services.py@@ -45,12 +45,13 @@ from repositories.account_oauth_repository import (RegisterServiceOAuthInvitationGateway,)from repositories.account_repository import SQLAlchemyAccountRepository+from repositories.app.mcp_server_repository import AppMCPServerRepository+from repositories.app.site_command_repository import AppSiteCommandRepository+from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepositoryfrom repositories.app_definition_query_repository import AppDefinitionQueryRepositoryfrom repositories.app_preview_query_repository import AppPreviewQueryRepositoryfrom repositories.app_scoped_end_user_repository import AppScopedEndUserRepo-from repositories.app_site_command_repository import AppSiteCommandRepositoryfrom repositories.app_statistic_query_repository import AppStatisticQueryRepository-from repositories.app_tracing_config_repository import SQLAlchemyAppTracingConfigRepositoryfrom repositories.data_source_api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepositoryfrom repositories.data_source_oauth_binding_repository import SQLAlchemyDataSourceOAuthBindingRepositoryfrom repositories.explore_banner_query_repository import ExploreBannerQueryRepository@@ -148,6 +149,7 @@ from services.account_password_service import AccountPasswordServicefrom services.account_profile_service import AccountProfileServicefrom services.app.advanced_prompt_template_service import AdvancedPromptTemplateServicefrom services.app.api_key_service import AppApiKeyService+from services.app.mcp_server_service import AppMCPServerServicefrom services.app_audio_adapters import AppAudioRuntimefrom services.app_audio_service import AppAudiofrom services.app_definition_query_service import AppDefinitionQueryService@@ -339,6 +341,7 @@ class ApplicationServices:account_activation: AccountActivationServiceapps: AppServicesapp_definitions: AppDefinitionQueryService+ app_mcp_servers: AppMCPServerServiceapp_preview_details: AppPreviewDetailsapp_previews: AppPreviewQueryServiceapp_sites: AppSiteService@@ -752,6 +755,9 @@ def build_application_services(agent_apps=build_agent_app_services(database_client=database_client),advanced_prompt_templates=AdvancedPromptTemplateService(),app_definitions=app_definitions,+ app_mcp_servers=AppMCPServerService(+ servers=AppMCPServerRepository(session_factory=database_client),+ ),app_preview_details=AppPreviewDetailsRuntime(details=app_preview_repository),app_previews=AppPreviewQueryService(apps=app_preview_repository,diff --git a/api/models/enums.py b/api/models/enums.pyindex b38e372ab8a..aa86a7d206c 100644--- a/api/models/enums.py+++ b/api/models/enums.py@@ -93,14 +93,6 @@ class AppStatus(StrEnum):NORMAL = "normal"-class AppMCPServerStatus(StrEnum):- """AppMCPServer Status Enum"""-- NORMAL = "normal"- ACTIVE = "active"- INACTIVE = "inactive"--class ConversationStatus(StrEnum):"""Conversation Status Enum"""diff --git a/api/models/model.py b/api/models/model.pyindex a6560db9e9f..c4482b15d0a 100644--- a/api/models/model.py+++ b/api/models/model.py@@ -34,7 +34,6 @@ from .base import Base, TypeBase, gen_uuidv4_stringfrom .engine import dbfrom .enums import (ApiTokenType,- AppMCPServerStatus,AppStatus,BannerStatus,ConversationFromSource,@@ -2128,9 +2127,8 @@ class AppMCPServer(TypeBase):name: Mapped[str] = mapped_column(String(255), nullable=False)description: Mapped[str] = mapped_column(String(255), nullable=False)server_code: Mapped[str] = mapped_column(String(255), nullable=False)- status: Mapped[AppMCPServerStatus] = mapped_column(- EnumText(AppMCPServerStatus, length=255), nullable=False, server_default=sa.text("'normal'")- )+ # The repository maps the stored value to the application-owned publication status.+ status: Mapped[str] = mapped_column(String(255), nullable=False, server_default=sa.text("'normal'"))parameters: Mapped[str] = mapped_column(LongText, nullable=False)created_at: Mapped[datetime] = mapped_column(diff --git a/api/openapi/markdown/console-openapi.md b/api/openapi/markdown/console-openapi.mdindex ebccc0fbda5..52bd50ebbd4 100644--- a/api/openapi/markdown/console-openapi.md+++ b/api/openapi/markdown/console-openapi.md@@ -2891,6 +2891,7 @@ Create MCP server configuration for an application| ---- | ----------- | ------ || 201 | MCP server configuration created successfully | **application/json**: [AppMCPServerResponse](#appmcpserverresponse)<br> || 403 | Insufficient permissions | |+| 409 | MCP server already exists for this app | |### [PUT] /apps/{app_id}/serverUpdate MCP server configuration for an application@@ -16413,11 +16414,11 @@ This class is used to store the schema information of an api based tool.#### AppMCPServerStatus-AppMCPServer Status Enum+Publication state of a Dify app exposed as an MCP server; only ACTIVE servers accept MCP calls.| Name | Type | Description | Required || ---- | ---- | ----------- | -------- |-| AppMCPServerStatus | string | AppMCPServer Status Enum | |+| AppMCPServerStatus | string | Publication state of a Dify app exposed as an MCP server; only ACTIVE servers accept MCP calls. | |#### AppMetadataConditionPayload@@ -20292,9 +20293,9 @@ Enum class for large language model mode.| Name | Type | Description | Required || ---- | ---- | ----------- | -------- || description | string | Server description | No |-| id | string | Server ID | Yes |+| id | string (uuid) | Server ID | Yes || parameters | object | Server parameters configuration | Yes |-| status | string | Server status | No |+| status | [AppMCPServerStatus](#appmcpserverstatus) | Server status | No |#### Marketplacediff --git a/api/repositories/app/__init__.py b/api/repositories/app/__init__.pyindex 97bad37e664..d2641008c68 100644--- a/api/repositories/app/__init__.py+++ b/api/repositories/app/__init__.py@@ -1 +1 @@-"""Persistence adapters for App services."""+"""Persistence adapters for App services. New or reworked app_* repositories move here; keep this file export-free."""diff --git a/api/repositories/app/console_visibility.py b/api/repositories/app/console_visibility.pynew file mode 100644index 00000000000..c4a79230f33--- /dev/null+++ b/api/repositories/app/console_visibility.py@@ -0,0 +1,19 @@+"""SQL visibility predicate shared by Console app persistence adapters."""++from sqlalchemy import ColumnElement, exists, or_++from models.agent import Agent, AgentScope+from models.model import App, AppMode+++def console_visible_condition() -> ColumnElement[bool]:+ """Exclude workflow-only Agents' runtime backing Apps, including archived Agents.++ Console must address these Apps through their owning workflow.+ """+ backs_workflow_only_agent = exists().where(+ Agent.tenant_id == App.tenant_id,+ Agent.backing_app_id == App.id,+ Agent.scope == AgentScope.WORKFLOW_ONLY,+ )+ return or_(App.mode != AppMode.AGENT, ~backs_workflow_only_agent)diff --git a/api/repositories/app/mcp_server_repository.py b/api/repositories/app/mcp_server_repository.pynew file mode 100644index 00000000000..5f60fa0cb02--- /dev/null+++ b/api/repositories/app/mcp_server_repository.py@@ -0,0 +1,127 @@+"""SQLAlchemy persistence adapter for Console app MCP servers."""++import json+from typing import override++from sqlalchemy import select+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import Session, sessionmaker++from models.enums import AppStatus+from models.model import App, AppMCPServer+from repositories.app.console_visibility import console_visible_condition+from services.app.mcp_server_service import (+ AppMCPServerAlreadyExistsError,+ AppMCPServerDraft,+ AppMCPServerNotFoundError,+ AppMCPServerRecord,+ AppMCPServerStatus,+ AppMCPServerStore,+ AppMCPServerUpdate,+ PublishedApp,+)++_SERVER_CODE_LENGTH = 16+++class AppMCPServerRepository(AppMCPServerStore):+ def __init__(self, *, session_factory: sessionmaker[Session]) -> None:+ self._session_factory = session_factory++ @override+ def find_app(self, *, workspace_id: str, app_id: str) -> PublishedApp | None:+ with self._session_factory() as session:+ row = session.execute(+ select(App.name, App.description)+ .where(+ App.id == app_id,+ App.tenant_id == workspace_id,+ App.status == AppStatus.NORMAL,+ console_visible_condition(),+ )+ .limit(1)+ ).one_or_none()+ return PublishedApp(name=row.name, description=row.description or "") if row is not None else None++ @override+ def find_server(self, *, workspace_id: str, app_id: str) -> AppMCPServerRecord | None:+ with self._session_factory() as session:+ server = session.scalar(+ select(AppMCPServer)+ .where(AppMCPServer.tenant_id == workspace_id, AppMCPServer.app_id == app_id)+ .limit(1)+ )+ return self._to_record(server) if server is not None else None++ @override+ def insert_server(self, *, workspace_id: str, app_id: str, draft: AppMCPServerDraft) -> AppMCPServerRecord:+ try:+ with self._session_factory.begin() as session:+ server = AppMCPServer(+ tenant_id=workspace_id,+ app_id=app_id,+ name=draft.name,+ description=draft.description,+ parameters=json.dumps(draft.parameters, ensure_ascii=False),+ status=draft.status.value,+ server_code=AppMCPServer.generate_server_code(_SERVER_CODE_LENGTH, session=session),+ )+ session.add(server)+ session.flush()+ return self._to_record(server)+ except IntegrityError as error:+ # A concurrent create can pass the caller's pre-check and win the (tenant_id, app_id) unique constraint.+ # Re-check in a fresh transaction so the committed winner is visible under any isolation level;+ # other violations (e.g. server_code) are not duplicates and must stay visible as failures.+ if self.find_server(workspace_id=workspace_id, app_id=app_id) is None:+ raise+ raise AppMCPServerAlreadyExistsError from error++ @override+ def update_server(+ self, *, workspace_id: str, app_id: str, server_id: str, update: AppMCPServerUpdate+ ) -> AppMCPServerRecord:+ with self._session_factory.begin() as session:+ server = self._require_server(session, workspace_id=workspace_id, app_id=app_id, server_id=server_id)+ server.name = update.name+ server.description = update.description+ server.parameters = json.dumps(update.parameters, ensure_ascii=False)+ if update.status is not None:+ server.status = update.status.value+ session.flush()+ return self._to_record(server)++ @override+ def rotate_server_code(self, *, workspace_id: str, app_id: str) -> AppMCPServerRecord:+ with self._session_factory.begin() as session:+ server = self._require_server(session, workspace_id=workspace_id, app_id=app_id, server_id=None)+ server.server_code = AppMCPServer.generate_server_code(_SERVER_CODE_LENGTH, session=session)+ session.flush()+ return self._to_record(server)++ @staticmethod+ def _require_server(session: Session, *, workspace_id: str, app_id: str, server_id: str | None) -> AppMCPServer:+ """Require the scoped ID, or the app's unique server when server_id is None for code rotation."""+ statement = select(AppMCPServer).where(+ AppMCPServer.tenant_id == workspace_id,+ AppMCPServer.app_id == app_id,+ )+ if server_id is not None:+ statement = statement.where(AppMCPServer.id == server_id)+ server = session.scalar(statement.limit(1))+ if server is None:+ raise AppMCPServerNotFoundError+ return server++ @staticmethod+ def _to_record(server: AppMCPServer) -> AppMCPServerRecord:+ return AppMCPServerRecord(+ id=server.id,+ name=server.name,+ server_code=server.server_code,+ description=server.description,+ status=AppMCPServerStatus(server.status),+ parameters=server.parameters,+ created_at=server.created_at,+ updated_at=server.updated_at,+ )diff --git a/api/repositories/app_site_command_repository.py b/api/repositories/app/site_command_repository.pysimilarity index 82%rename from api/repositories/app_site_command_repository.pyrename to api/repositories/app/site_command_repository.pyindex 47077950a58..527e47fd21f 100644--- a/api/repositories/app_site_command_repository.py+++ b/api/repositories/app/site_command_repository.py@@ -3,12 +3,13 @@from dataclasses import asdictfrom typing import override-from sqlalchemy import select+from sqlalchemy import ColumnElement, selectfrom sqlalchemy.orm import Session, sessionmakerfrom libs.datetime_utils import naive_utc_nowfrom models.enums import AppStatusfrom models.model import App, Site+from repositories.app.console_visibility import console_visible_conditionfrom services.app_site_service import (AppSiteAppNotFoundError,AppSiteChanges,@@ -18,6 +19,15 @@ from services.app_site_service import ()+def _console_app_conditions(workspace_id: str, app_id: str) -> tuple[ColumnElement[bool], ...]:+ return (+ App.id == app_id,+ App.tenant_id == workspace_id,+ App.status == AppStatus.NORMAL,+ console_visible_condition(),+ )++class AppSiteCommandRepository(AppSiteStore):def __init__(self, *, session_factory: sessionmaker[Session]) -> None:self._session_factory = session_factory@@ -61,27 +71,12 @@ class AppSiteCommandRepository(AppSiteStore):@staticmethoddef _get_site(session: Session, workspace_id: str, app_id: str) -> Site:site = session.scalar(- select(Site)- .join(App, App.id == Site.app_id)- .where(- App.id == app_id,- App.tenant_id == workspace_id,- App.status == AppStatus.NORMAL,- )- .limit(1)+ select(Site).join(App, App.id == Site.app_id).where(*_console_app_conditions(workspace_id, app_id)).limit(1))if site is not None:return site- app_exists = session.scalar(- select(App.id)- .where(- App.id == app_id,- App.tenant_id == workspace_id,- App.status == AppStatus.NORMAL,- )- .limit(1)- )+ app_exists = session.scalar(select(App.id).where(*_console_app_conditions(workspace_id, app_id)).limit(1))if app_exists is None:raise AppSiteAppNotFoundErrorraise AppSiteNotFoundErrordiff --git a/api/repositories/app_tracing_config_repository.py b/api/repositories/app/tracing_config_repository.pysimilarity index 97%rename from api/repositories/app_tracing_config_repository.pyrename to api/repositories/app/tracing_config_repository.pyindex 1d40ad947c3..467380abdd9 100644--- a/api/repositories/app_tracing_config_repository.py+++ b/api/repositories/app/tracing_config_repository.py@@ -7,6 +7,7 @@ from sqlalchemy.orm import Session, sessionmakerfrom models.enums import AppStatusfrom models.model import App, TraceAppConfig+from repositories.app.console_visibility import console_visible_conditionfrom services.app_tracing_config_service import (AppTracingConfigAppNotFoundError,AppTracingConfigRecord,@@ -97,6 +98,7 @@ class SQLAlchemyAppTracingConfigRepository(AppTracingConfigStore):App.id == app_id,App.tenant_id == workspace_id,App.status == AppStatus.NORMAL,+ console_visible_condition(),).limit(1))diff --git a/api/services/app/__init__.py b/api/services/app/__init__.pyindex 32cb237c245..d3774688f10 100644--- a/api/services/app/__init__.py+++ b/api/services/app/__init__.py@@ -1 +1,4 @@-"""Application services and adapters owned by the App domain."""+"""Application services and adapters owned by the App domain.++New or reworked app_* modules move here without the prefix; keep this file export-free.+"""diff --git a/api/services/app/mcp_server_service.py b/api/services/app/mcp_server_service.pynew file mode 100644index 00000000000..0e702b7f71c--- /dev/null+++ b/api/services/app/mcp_server_service.py@@ -0,0 +1,158 @@+"""Application boundary for publishing a Console app as an MCP server."""++from dataclasses import dataclass+from datetime import datetime+from enum import StrEnum+from typing import Any, Protocol++from machinery.context import RequestContext+++class AppMCPServerStatus(StrEnum):+ """Publication state of a Dify app exposed as an MCP server; only ACTIVE servers accept MCP calls."""++ # Column server default; like INACTIVE, it does not serve MCP calls.+ NORMAL = "normal"+ ACTIVE = "active"+ INACTIVE = "inactive"+++@dataclass(frozen=True, slots=True)+class AppMCPServerRecord:+ id: str+ name: str+ server_code: str+ description: str+ status: AppMCPServerStatus+ parameters: str+ created_at: datetime+ updated_at: datetime+++@dataclass(frozen=True, slots=True)+class PublishedApp:+ """The app fields an MCP server mirrors."""++ name: str+ description: str+++@dataclass(frozen=True, slots=True)+class AppMCPServerDraft:+ """Complete field values for creating a server; the store writes them verbatim."""++ name: str+ description: str+ parameters: dict[str, Any]+ status: AppMCPServerStatus+++@dataclass(frozen=True, slots=True)+class AppMCPServerUpdate:+ """Server edits; a None status leaves the persisted status untouched."""++ name: str+ description: str+ parameters: dict[str, Any]+ status: AppMCPServerStatus | None+++class AppMCPServerStore(Protocol):+ """Persistence for MCP servers, always scoped by workspace and app."""++ def find_app(self, *, workspace_id: str, app_id: str) -> PublishedApp | None:+ """Return the app only when Console may address it (normal status, not a hidden backing app)."""+ ...++ def find_server(self, *, workspace_id: str, app_id: str) -> AppMCPServerRecord | None: ...++ def insert_server(self, *, workspace_id: str, app_id: str, draft: AppMCPServerDraft) -> AppMCPServerRecord:+ """Insert with a fresh server code; raise `AppMCPServerAlreadyExistsError` if the app already has one."""+ ...++ def update_server(+ self, *, workspace_id: str, app_id: str, server_id: str, update: AppMCPServerUpdate+ ) -> AppMCPServerRecord:+ """Apply edits, skipping status when None.++ Raise `AppMCPServerNotFoundError` if the ID is absent from this scope.+ """+ ...++ def rotate_server_code(self, *, workspace_id: str, app_id: str) -> AppMCPServerRecord:+ """Find this app's server and rotate its code atomically; raise `AppMCPServerNotFoundError` if absent."""+ ...+++class AppMCPServerError(Exception):+ """Base class for framework-neutral app MCP server failures."""+++class AppMCPServerAppNotFoundError(AppMCPServerError):+ def __init__(self) -> None:+ super().__init__("App not found")+++class AppMCPServerNotFoundError(AppMCPServerError):+ def __init__(self) -> None:+ super().__init__("MCP server not found")+++class AppMCPServerAlreadyExistsError(AppMCPServerError):+ def __init__(self) -> None:+ super().__init__("MCP server already exists for this app")+++class AppMCPServerService:+ """Owns the publishing rules: a server mirrors its app's name, inherits the app description+ unless given one, starts ACTIVE, and keeps its status unless a new one is requested."""++ def __init__(self, *, servers: AppMCPServerStore) -> None:+ self._servers = servers++ def get(self, context: RequestContext, app_id: str) -> AppMCPServerRecord | None:+ self._require_app(context.active_workspace_id, app_id)+ return self._servers.find_server(workspace_id=context.active_workspace_id, app_id=app_id)++ def create(+ self, context: RequestContext, app_id: str, *, description: str | None, parameters: dict[str, Any]+ ) -> AppMCPServerRecord:+ workspace_id = context.active_workspace_id+ app = self._require_app(workspace_id, app_id)+ if self._servers.find_server(workspace_id=workspace_id, app_id=app_id) is not None:+ raise AppMCPServerAlreadyExistsError+ draft = AppMCPServerDraft(+ name=app.name,+ description=description or app.description,+ parameters=parameters,+ status=AppMCPServerStatus.ACTIVE,+ )+ return self._servers.insert_server(workspace_id=workspace_id, app_id=app_id, draft=draft)++ def update(+ self,+ context: RequestContext,+ app_id: str,+ *,+ server_id: str,+ description: str | None,+ parameters: dict[str, Any],+ status: AppMCPServerStatus | None,+ ) -> AppMCPServerRecord:+ workspace_id = context.active_workspace_id+ app = self._require_app(workspace_id, app_id)+ update = AppMCPServerUpdate(+ name=app.name, description=description or app.description, parameters=parameters, status=status+ )+ return self._servers.update_server(workspace_id=workspace_id, app_id=app_id, server_id=server_id, update=update)++ def refresh(self, context: RequestContext, app_id: str) -> AppMCPServerRecord:+ workspace_id = context.active_workspace_id+ self._require_app(workspace_id, app_id)+ return self._servers.rotate_server_code(workspace_id=workspace_id, app_id=app_id)++ def _require_app(self, workspace_id: str, app_id: str) -> PublishedApp:+ app = self._servers.find_app(workspace_id=workspace_id, app_id=app_id)+ if app is None:+ raise AppMCPServerAppNotFoundError+ return appdiff --git a/api/services/app_ref_service.py b/api/services/app_ref_service.pyindex 0fa9a7f9aee..1f947ba1279 100644--- a/api/services/app_ref_service.py+++ b/api/services/app_ref_service.py@@ -28,13 +28,6 @@ class AnnotationRef(NamedTuple):annotation_id: str-class AppMCPServerRef(NamedTuple):- """MCP server identifiers used to scope downstream resource lookups."""-- app: AppRef- server_id: str--class AppRefService:"""Factory helpers for app and child resource refs."""@@ -61,8 +54,3 @@ class AppRefService:def create_annotation_ref(app_ref: AppRef, annotation_id: str) -> AnnotationRef:"""Bind a candidate annotation ID; ownership is enforced when the ref is consumed."""return AnnotationRef(app=app_ref, annotation_id=annotation_id)-- @staticmethod- def create_mcp_server_ref(app_ref: AppRef, server_id: str) -> AppMCPServerRef:- """Bind a candidate MCP server ID; ownership is enforced when the ref is consumed."""- return AppMCPServerRef(app=app_ref, server_id=server_id)diff --git a/api/tests/unit_tests/controllers/console/app/test_app_apis.py b/api/tests/unit_tests/controllers/console/app/test_app_apis.pyindex fb728374c13..bb9ed018407 100644--- a/api/tests/unit_tests/controllers/console/app/test_app_apis.py+++ b/api/tests/unit_tests/controllers/console/app/test_app_apis.py@@ -826,7 +826,9 @@ class TestMCPServerEndpoints:assert payload.parameters["url"] == "http://localhost:3000"def test_mcp_server_update_payload(self):- payload = MCPServerUpdatePayload(id="server-1", parameters={"timeout": 30}, status="active")+ payload = MCPServerUpdatePayload(+ id="abcdefab-1234-4567-89ab-abcdefabcdef", parameters={"timeout": 30}, status="active"+ )assert payload.status == "active"diff --git a/api/tests/unit_tests/controllers/console/app/test_mcp_server_admission.py b/api/tests/unit_tests/controllers/console/app/test_mcp_server_admission.pynew file mode 100644index 00000000000..64183af3ed3--- /dev/null+++ b/api/tests/unit_tests/controllers/console/app/test_mcp_server_admission.py@@ -0,0 +1,128 @@+"""App MCP Server routes retain their role and RBAC policy under unified admission."""++from collections.abc import Callable, Sequence+from datetime import datetime+from inspect import unwrap+from types import SimpleNamespace+from uuid import UUID++import pytest+from flask import Flask+from werkzeug.exceptions import Forbidden++from controllers.common.rbac import PlainApp, RBACCheck+from controllers.console import flask_admission+from controllers.console.app import mcp_server+from controllers.console.app.mcp_server import AppMCPServerController, AppMCPServerRefreshController+from controllers.console.wraps import RBACPermission+from libs.login import AccountWithTenant+from machinery.context import RequestContext+from models.account import TenantAccountRole+from services.app.mcp_server_service import AppMCPServerRecord, AppMCPServerStatus+from tests.unit_tests.config_override import apply_config_overrides+from tests.unit_tests.model_factories import make_account++APP_ID = UUID("11111111-1111-1111-1111-111111111111")+RECORD = AppMCPServerRecord(+ id="server",+ name="name",+ server_code="code",+ description="description",+ status=AppMCPServerStatus.ACTIVE,+ parameters="{}",+ created_at=datetime(2024, 1, 1),+ updated_at=datetime(2024, 1, 1),+)+MUTATIONS = [+ AppMCPServerController.post,+ AppMCPServerController.put,+ AppMCPServerRefreshController.post,+]+++def admission(method: Callable[..., object]) -> Callable[..., object]:+ return unwrap(method, stop=lambda view: "inject_request_context" in view.__code__.co_qualname)++[email protected]("method", MUTATIONS)[email protected]("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])+def test_readonly_roles_cannot_mutate(+ app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object], role: TenantAccountRole+) -> None:+ account = make_account(role=role)+ apply_config_overrides(monkeypatch, RBAC_ENABLED=False)+ monkeypatch.setattr(flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace"))+ with app.test_request_context(), pytest.raises(Forbidden):+ admission(method)(None, app_id=APP_ID)+++ ("method", "permission"),+ [+ (AppMCPServerController.get, RBACPermission.APP_VIEW_LAYOUT),+ (AppMCPServerController.post, RBACPermission.APP_EDIT),+ (AppMCPServerController.put, RBACPermission.APP_EDIT),+ (AppMCPServerRefreshController.post, RBACPermission.APP_EDIT),+ ],+)+def test_rbac_checks_keep_app_scope(+ app: Flask, monkeypatch: pytest.MonkeyPatch, method: Callable[..., object], permission: RBACPermission+) -> None:+ account = make_account(role=TenantAccountRole.NORMAL)+ apply_config_overrides(monkeypatch, RBAC_ENABLED=True)+ monkeypatch.setattr(flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace"))+ called = []++ def denied(*, tenant_id: str, account_id: str, checks: Sequence[RBACCheck], path_args: dict[str, object]) -> None:+ assert (tenant_id, account_id) == ("workspace", account.id)+ assert path_args == {"app_id": APP_ID}+ assert len(checks) == 1+ assert checks[0].scene == permission+ assert isinstance(checks[0].locator, PlainApp)+ called.append(True)+ raise Forbidden++ monkeypatch.setattr(flask_admission, "enforce_rbac_checks", denied)+ with app.test_request_context(), pytest.raises(Forbidden):+ admission(method)(None, app_id=APP_ID)+ assert called == [True]++[email protected]("role", [TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR])+def test_edit_roles_reach_service_with_request_context(+ app: Flask, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole+) -> None:+ account = make_account(role=role)+ apply_config_overrides(monkeypatch, RBAC_ENABLED=False)+ monkeypatch.setattr(flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace"))+ monkeypatch.setattr(flask_admission, "enforce_rbac_checks", lambda **_kwargs: None)+ monkeypatch.setattr(flask_admission, "get_trace_id", lambda: None)+ contexts: list[RequestContext] = []++ def refresh(context: RequestContext, _app_id: str) -> AppMCPServerRecord:+ contexts.append(context)+ return RECORD++ monkeypatch.setattr(+ mcp_server, "application_services", lambda: SimpleNamespace(app_mcp_servers=SimpleNamespace(refresh=refresh))+ )+ with app.test_request_context(method="POST", headers={"X-Trace-Id": "trace"}):+ response = admission(AppMCPServerRefreshController.post)(None, app_id=APP_ID)+ assert isinstance(response, dict)+ assert response["id"] == RECORD.id+ assert [(c.account_id, c.active_workspace_id, c.trace_id) for c in contexts] == [(account.id, "workspace", "trace")]++[email protected]("role", [TenantAccountRole.NORMAL, TenantAccountRole.DATASET_OPERATOR])+def test_readonly_roles_can_read(app: Flask, monkeypatch: pytest.MonkeyPatch, role: TenantAccountRole) -> None:+ account = make_account(role=role)+ apply_config_overrides(monkeypatch, RBAC_ENABLED=False)+ monkeypatch.setattr(flask_admission, "current_account_with_tenant", lambda: AccountWithTenant(account, "workspace"))+ monkeypatch.setattr(flask_admission, "enforce_rbac_checks", lambda **_kwargs: None)+ monkeypatch.setattr(+ mcp_server,+ "application_services",+ lambda: SimpleNamespace(app_mcp_servers=SimpleNamespace(get=lambda _context, _app_id: None)),+ )+ with app.test_request_context():+ assert admission(AppMCPServerController.get)(None, app_id=APP_ID) == {}diff --git a/api/tests/unit_tests/controllers/console/app/test_mcp_server_response.py b/api/tests/unit_tests/controllers/console/app/test_mcp_server_response.pyindex edac7a463c0..f2e6e5c48e8 100644--- a/api/tests/unit_tests/controllers/console/app/test_mcp_server_response.py+++ b/api/tests/unit_tests/controllers/console/app/test_mcp_server_response.py@@ -1,59 +1,72 @@import datetime+from collections.abc import Callable+from dataclasses import dataclass, fieldfrom inspect import unwrap-from unittest.mock import patch+from types import SimpleNamespace+from uuid import UUIDimport pytestfrom flask import Flask-from sqlalchemy import select-from sqlalchemy.orm import Session, scoped_session, sessionmaker-from werkzeug.exceptions import NotFound+from werkzeug.exceptions import Conflict, NotFound, UnprocessableEntityfrom controllers.console import console_ns-from controllers.console.app.mcp_server import (- AppMCPServerController,- AppMCPServerRefreshController,- AppMCPServerResponse,- MCPServerCreatePayload,- MCPServerUpdatePayload,+from controllers.console.app import mcp_server as module+from controllers.console.app.error import AppNotFoundError+from controllers.console.app.mcp_server import AppMCPServerResponse+from machinery.context import RequestContext+from services.app.mcp_server_service import (+ AppMCPServerAlreadyExistsError,+ AppMCPServerAppNotFoundError,+ AppMCPServerNotFoundError,+ AppMCPServerRecord,+ AppMCPServerStatus,)-from controllers.console.wraps import RBACPermission, RBACResourceScope-from models import Account-from models.account import AccountStatus-from models.enums import AppMCPServerStatus-from models.model import App, AppMCPServer-from tests.unit_tests.config_override import config_overrides_context-from tests.unit_tests.model_factories import make_app---def _app(- *,- app_id: str = "app-1",- tenant_id: str = "tenant-1",- name: str = "Demo App",- description: str = "App description",-) -> App:- return make_app(app_id=app_id, tenant_id=tenant_id, name=name, description=description)---def _server(- *,- tenant_id: str = "tenant-1",- app_id: str = "app-1",- name: str = "Demo App",- description: str = "Description",- parameters: str = "{}",- status: AppMCPServerStatus = AppMCPServerStatus.ACTIVE,- server_code: str = "server-code",-) -> AppMCPServer:- return AppMCPServer(- tenant_id=tenant_id,- app_id=app_id,- name=name,- description=description,- parameters=parameters,- status=status,- server_code=server_code,- )++CONTEXT = RequestContext("request", None, "account", "workspace")+SERVER_ID = "abcdefab-1234-4567-89ab-abcdefabcdef"+APP_ID = UUID("11111111-1111-1111-1111-111111111111")+RECORD = AppMCPServerRecord(+ id="server",+ name="name",+ server_code="code",+ description="description",+ status=AppMCPServerStatus.ACTIVE,+ parameters='{"timeout": 30}',+ created_at=datetime.datetime(2024, 1, 1, tzinfo=datetime.UTC),+ updated_at=datetime.datetime(2024, 1, 2, tzinfo=datetime.UTC),+)+++@dataclass+class Servers:+ result: AppMCPServerRecord | None = RECORD+ error: Exception | None = None+ calls: list[tuple[str, str, dict[str, object]]] = field(default_factory=list)++ def get(self, context: RequestContext, app_id: str) -> AppMCPServerRecord | None:+ return self._call("get", app_id)++ def create(self, context: RequestContext, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:+ return self._call("create", app_id, **kwargs)++ def update(self, context: RequestContext, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:+ return self._call("update", app_id, **kwargs)++ def refresh(self, context: RequestContext, app_id: str) -> AppMCPServerRecord | None:+ return self._call("refresh", app_id)++ def _call(self, method: str, app_id: str, **kwargs: object) -> AppMCPServerRecord | None:+ self.calls.append((method, app_id, kwargs))+ if self.error is not None:+ raise self.error+ return self.result+++def servers(monkeypatch: pytest.MonkeyPatch) -> Servers:+ servers = Servers()+ monkeypatch.setattr(module, "application_services", lambda: SimpleNamespace(app_mcp_servers=servers))+ return serversclass TestAppMCPServerResponse:@@ -135,191 +148,87 @@ class TestAppMCPServerResponse:assert resp.updated_at is None-class TestAppMCPServerController:- def test_get_returns_empty_dict_when_server_missing(self, sqlite_session: Session) -> None:- api = AppMCPServerController()- method = unwrap(api.get)-- with patch("controllers.console.app.mcp_server.db.session", sqlite_session):- response = method(api, app_model=_app())-- assert response == {}-- def test_post_returns_201(self, sqlite_session: Session, sqlite_session_factory: sessionmaker[Session]) -> None:- api = AppMCPServerController()- method = unwrap(api.post)- payload = {"parameters": {"timeout": 30}}- req_data = MCPServerCreatePayload.model_validate(payload)- app = Flask(__name__)- app.config["TESTING"] = True-- with (- app.test_request_context("/", json=payload),- patch("controllers.console.app.mcp_server.db.session", scoped_session(sqlite_session_factory)),- patch("controllers.console.app.mcp_server.AppMCPServer.generate_server_code", return_value="server-code"),- ):- response, status_code = method(- api,- req_data,- "tenant-1",- app_model=_app(),- )-- server = sqlite_session.scalar(select(AppMCPServer))- assert server is not None- assert response["server_code"] == "server-code"- assert response["parameters"] == {"timeout": 30}- assert status_code == 201-- def test_put_updates_server_for_app(self, sqlite_session: Session) -> None:- api = AppMCPServerController()- method = unwrap(api.put)- payload = {"id": "server-1", "description": "Updated", "parameters": {"timeout": 30}, "status": "active"}- req_data = MCPServerUpdatePayload.model_validate(payload)- app = Flask(__name__)- app.config["TESTING"] = True- server = _server(name="Old", description="Old")- server.id = "server-1"- sqlite_session.add(server)- sqlite_session.commit()-- with (- app.test_request_context("/", json=payload),- patch("controllers.console.app.mcp_server.db.session", sqlite_session),- ):- response = method(- api,- req_data,- app_model=_app(),- )-- sqlite_session.expire_all()- updated_server = sqlite_session.get(AppMCPServer, "server-1")- assert updated_server is not None- assert response["id"] == "server-1"- assert updated_server.description == "Updated"-- @pytest.mark.parametrize(- ("foreign_tenant_id", "foreign_app_id"),- [- ("tenant-2", "app-1"),- ("tenant-1", "app-2"),- ],- )- def test_put_scopes_server_lookup_to_complete_app_ref(- self,- sqlite_session: Session,- foreign_tenant_id: str,- foreign_app_id: str,- ) -> None:- api = AppMCPServerController()- method = unwrap(api.put)- payload = {"id": "server-1", "description": "Updated", "parameters": {"timeout": 30}, "status": "active"}- req_data = MCPServerUpdatePayload.model_validate(payload)- app = Flask(__name__)- app.config["TESTING"] = True- foreign_server = _server(- tenant_id=foreign_tenant_id,- app_id=foreign_app_id,- name="Other",- server_code="other-code",+def test_get_serializes_record_and_missing_server(servers: Servers) -> None:+ method = unwrap(module.AppMCPServerController.get)+ response = method(None, CONTEXT, APP_ID)+ assert response["parameters"] == {"timeout": 30}+ assert response["created_at"] == 1704067200+ servers.result = None+ assert method(None, CONTEXT, APP_ID) == {}+++def test_post_parses_input_and_returns_201(app: Flask, servers: Servers) -> None:+ with app.test_request_context(method="POST", json={"parameters": {"timeout": 30}}):+ response, status = unwrap(module.AppMCPServerController.post)(None, CONTEXT, APP_ID)+ assert status == 201+ assert response["id"] == "server"+ assert servers.calls == [("create", str(APP_ID), {"description": None, "parameters": {"timeout": 30}})]++[email protected]("candidate", [SERVER_ID, SERVER_ID.upper(), UUID(SERVER_ID).hex, "{" + SERVER_ID + "}"])+def test_put_normalizes_server_id_and_passes_status(app: Flask, servers: Servers, candidate: str) -> None:+ body = {"id": candidate, "parameters": {}, "description": "updated", "status": "inactive"}+ with app.test_request_context(method="PUT", json=body):+ unwrap(module.AppMCPServerController.put)(None, CONTEXT, APP_ID)+ assert servers.calls == [+ (+ "update",+ str(APP_ID),+ {"server_id": SERVER_ID, "description": "updated", "parameters": {}, "status": "inactive"},)- foreign_server.id = "server-1"- sqlite_session.add(foreign_server)- sqlite_session.commit()-- with (- app.test_request_context("/", json=payload),- patch("controllers.console.app.mcp_server.db.session", sqlite_session),- pytest.raises(NotFound),- ):- method(- api,- req_data,- app_model=_app(),- )-- sqlite_session.expire_all()- unchanged_server = sqlite_session.get(AppMCPServer, "server-1")- assert unchanged_server is not None- assert unchanged_server.description == "Description"---class TestAppMCPServerRefreshController:- def test_post_refreshes_server_bound_to_app_and_tenant(- self, sqlite_session: Session, sqlite_session_factory: sessionmaker[Session]- ) -> None:- api = AppMCPServerRefreshController()- method = unwrap(api.post)- server = _server(server_code="old-code")- server.id = "server-1"- tenant_decoy = _server(tenant_id="tenant-2", server_code="tenant-decoy-code")- tenant_decoy.id = "server-2"- app_decoy = _server(app_id="app-2", server_code="app-decoy-code")- app_decoy.id = "server-3"- sqlite_session.add_all([server, tenant_decoy, app_decoy])- sqlite_session.commit()-- with (- patch("controllers.console.app.mcp_server.db.session", scoped_session(sqlite_session_factory)),- patch("controllers.console.app.mcp_server.AppMCPServer.generate_server_code", return_value="new-code"),- ):- response = method(api, "tenant-1", app_model=_app())-- sqlite_session.expire_all()- refreshed_server = sqlite_session.get(AppMCPServer, "server-1")- persisted_tenant_decoy = sqlite_session.get(AppMCPServer, "server-2")- persisted_app_decoy = sqlite_session.get(AppMCPServer, "server-3")- assert refreshed_server is not None- assert persisted_tenant_decoy is not None- assert persisted_app_decoy is not None- assert refreshed_server.server_code == "new-code"- assert persisted_tenant_decoy.server_code == "tenant-decoy-code"- assert persisted_app_decoy.server_code == "app-decoy-code"- assert response["id"] == "server-1"- assert response["server_code"] == "new-code"-- def test_route_is_app_scoped_post(self):- route_map = {- resource.__name__: urls- for resource, urls, _route_doc, _kwargs in console_ns.resources- if resource.__name__ == "AppMCPServerRefreshController"- }+ ]- assert route_map["AppMCPServerRefreshController"] == ("/apps/<uuid:app_id>/server/refresh",)- assert hasattr(AppMCPServerRefreshController, "post")- assert not hasattr(AppMCPServerRefreshController, "get")-- def test_post_requires_app_edit_permission(self):- method = AppMCPServerRefreshController.post- while "rbac_permission_required" not in method.__code__.co_qualname:- method = method.__wrapped__-- class PermissionCheckedError(Exception):- pass-- current_user = Account(name="Current user", email="[email protected]", status=AccountStatus.ACTIVE)- current_user.id = "account-1"- with (- config_overrides_context(RBAC_ENABLED=True),- patch(- "controllers.common.wraps.current_account_with_tenant",- return_value=(current_user, "tenant-1"),- ),- patch("controllers.common.rbac.locators.agent_binding", return_value=None),- patch("controllers.common.rbac.locators.PlainApp.owner_id", return_value=None),- patch(- "controllers.common.rbac.checks.RBACService.CheckAccess.check",- side_effect=PermissionCheckedError,- ) as check_access,- pytest.raises(PermissionCheckedError),- ):- method(AppMCPServerRefreshController(), app_id="app-1")-- check_access.assert_called_once_with(- "tenant-1",- "account-1",- scene=RBACPermission.APP_EDIT,- resource_type=RBACResourceScope.APP,- resource_id="app-1",- )++ "body",+ [+ pytest.param({"id": "not-a-uuid", "parameters": {}}, id="malformed-id"),+ pytest.param({"id": SERVER_ID, "parameters": {}, "status": "paused"}, id="unknown-status"),+ pytest.param({"id": SERVER_ID, "parameters": {}, "status": ""}, id="blank-status"),+ ],+)+def test_put_rejects_invalid_payload_before_calling_service(+ app: Flask, servers: Servers, body: dict[str, object]+) -> None:+ with app.test_request_context(method="PUT", json=body), pytest.raises(UnprocessableEntity):+ unwrap(module.AppMCPServerController.put)(None, CONTEXT, APP_ID)+ assert servers.calls == []+++ "method",+ [+ module.AppMCPServerController.get,+ module.AppMCPServerController.post,+ module.AppMCPServerController.put,+ module.AppMCPServerRefreshController.post,+ ],+)+def test_unavailable_app_becomes_app_404(app: Flask, servers: Servers, method: Callable[..., object]) -> None:+ servers.error = AppMCPServerAppNotFoundError()+ with (+ app.test_request_context(method="POST", json={"id": SERVER_ID, "parameters": {}}),+ pytest.raises(AppNotFoundError) as error,+ ):+ unwrap(method)(None, CONTEXT, APP_ID)+ assert error.value.description == AppNotFoundError.description++[email protected]("method", [module.AppMCPServerController.put, module.AppMCPServerRefreshController.post])+def test_missing_server_becomes_404(app: Flask, servers: Servers, method: Callable[..., object]) -> None:+ servers.error = AppMCPServerNotFoundError()+ with app.test_request_context(method="POST", json={"id": SERVER_ID, "parameters": {}}), pytest.raises(NotFound):+ unwrap(method)(None, CONTEXT, APP_ID)+++def test_duplicate_create_becomes_409(app: Flask, servers: Servers) -> None:+ servers.error = AppMCPServerAlreadyExistsError()+ with app.test_request_context(method="POST", json={"parameters": {}}), pytest.raises(Conflict):+ unwrap(module.AppMCPServerController.post)(None, CONTEXT, APP_ID)+++def test_routes_stay_app_scoped() -> None:+ route_map = {resource.__name__: urls for resource, urls, _, _ in console_ns.resources}+ assert route_map["AppMCPServerController"] == ("/apps/<uuid:app_id>/server",)+ assert route_map["AppMCPServerRefreshController"] == ("/apps/<uuid:app_id>/server/refresh",)+ assert not hasattr(module.AppMCPServerRefreshController, "get")diff --git a/api/tests/unit_tests/controllers/console/app/test_wraps.py b/api/tests/unit_tests/controllers/console/app/test_wraps.pyindex 46f9e137a7b..f090f14a51b 100644--- a/api/tests/unit_tests/controllers/console/app/test_wraps.py+++ b/api/tests/unit_tests/controllers/console/app/test_wraps.py@@ -11,6 +11,7 @@ from controllers.console.app import completion as completion_modulefrom controllers.console.app import workflow as workflow_modulefrom controllers.console.app import wraps as wraps_modulefrom controllers.console.app.error import AppNotFoundError+from models.agent import Agent, AgentScope, AgentSource, AgentStatusfrom models.model import App, AppMode@@ -85,6 +86,46 @@ def test_get_app_model_prefers_injected_session(assert Handler().get(sqlite_session, app_id=app_model.id) == app_model.id[email protected]("scope", [AgentScope.ROSTER, AgentScope.WORKFLOW_ONLY])[email protected]("status", [AgentStatus.ACTIVE, AgentStatus.ARCHIVED])[email protected]("inject_session", [False, True])+def test_get_app_model_hides_only_workflow_backing_apps(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ scope: AgentScope,+ status: AgentStatus,+ inject_session: bool,+) -> None:+ app_model = _persist_app(sqlite_session, mode=AppMode.AGENT)+ workflow_only = scope == AgentScope.WORKFLOW_ONLY+ sqlite_session.add(+ Agent(+ tenant_id=app_model.tenant_id,+ name="Bound agent",+ scope=scope,+ source=AgentSource.WORKFLOW if workflow_only else AgentSource.AGENT_APP,+ status=status,+ app_id=None if workflow_only else app_model.id,+ backing_app_id=app_model.id if workflow_only else None,+ )+ )+ sqlite_session.commit()+ monkeypatch.setattr(wraps_module, "current_account_with_tenant", lambda: (None, app_model.tenant_id))+ monkeypatch.setattr(wraps_module.db, "session", sqlite_session)++ class Handler:+ @wraps_module.get_app_model+ def get(self, *_args: object, app_model: App) -> str:+ return app_model.id++ args = (sqlite_session,) if inject_session else ()+ if workflow_only:+ with pytest.raises(AppNotFoundError):+ Handler().get(*args, app_id=app_model.id)+ else:+ assert Handler().get(*args, app_id=app_model.id) == app_model.id++@pytest.mark.parametrize("resource",[diff --git a/api/tests/unit_tests/controllers/console/test_wraps.py b/api/tests/unit_tests/controllers/console/test_wraps.pyindex 54002f37246..cb8f5a838a5 100644--- a/api/tests/unit_tests/controllers/console/test_wraps.py+++ b/api/tests/unit_tests/controllers/console/test_wraps.py@@ -6,6 +6,7 @@ from unittest.mock import MagicMock, patchimport pytestfrom flask import Flaskfrom flask_login import LoginManager, UserMixin+from flask_restx import Api, Resourcefrom pydantic import BaseModelfrom sqlalchemy import selectfrom sqlalchemy.orm import Session@@ -34,11 +35,13 @@ from controllers.console.wraps import (only_edition_self_hosted,rbac_permission_required,setup_required,+ validate_request,with_current_tenant_id,with_current_user,with_current_user_id,)from enums import DeploymentEdition+from libs.external_api import register_external_error_handlersfrom libs.login import AccountWithTenantfrom machinery.context import RequestContextfrom machinery.errors import ActiveWorkspaceRequiredError@@ -717,6 +720,35 @@ class TestModelValidationInjection:assert "count" in exc_info.value.description+class TestValidateRequest:+ class Payload(BaseModel):+ token: dict[str, str]++ @pytest.mark.parametrize("http_method", ["POST", "PUT"])+ def test_rejected_input_is_redacted_from_response_and_logs(+ self, caplog: pytest.LogCaptureFixture, http_method: str+ ) -> None:+ secret = "submitted-private-token-should-never-appear"+ app = Flask(__name__)+ api = Api(app)+ register_external_error_handlers(api)+ payload_model = self.Payload++ class Endpoint(Resource):+ def post(self) -> object:+ return validate_request(payload_model).model_dump()++ put = post++ api.add_resource(Endpoint, "/items")+ response = app.test_client().open("/items", method=http_method, json={"token": secret})++ assert response.status_code == 422+ assert "token" in response.get_data(as_text=True)+ assert secret not in response.get_data(as_text=True)+ assert secret not in caplog.text++class TestEditionChecks:"""Test edition-specific decorators"""diff --git a/api/tests/unit_tests/controllers/test_mcp_app_api.py b/api/tests/unit_tests/controllers/test_mcp_app_api.pyindex 647d704ddbf..62937cb26b2 100644--- a/api/tests/unit_tests/controllers/test_mcp_app_api.py+++ b/api/tests/unit_tests/controllers/test_mcp_app_api.py@@ -4,8 +4,8 @@ import pytestfrom sqlalchemy.orm import Sessionfrom controllers.mcp.mcp import MCPAppApi-from models.enums import AppMCPServerStatusfrom models.model import App, AppMCPServer, AppMode, IconType+from services.app.mcp_server_service import AppMCPServerStatusTENANT_ID = "11111111-1111-1111-1111-111111111111"APP_ID = "22222222-2222-2222-2222-222222222222"diff --git a/api/tests/unit_tests/extensions/test_ext_application_services.py b/api/tests/unit_tests/extensions/test_ext_application_services.pyindex 019e3e70df1..0c47f4db4ff 100644--- a/api/tests/unit_tests/extensions/test_ext_application_services.py+++ b/api/tests/unit_tests/extensions/test_ext_application_services.py@@ -49,10 +49,10 @@ from repositories.account_oauth_repository import (RegisterServiceOAuthInvitationGateway,)from repositories.account_repository import SQLAlchemyAccountRepository+from repositories.app.site_command_repository import AppSiteCommandRepository+from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepositoryfrom repositories.app_scoped_end_user_repository import AppScopedEndUserRepo-from repositories.app_site_command_repository import AppSiteCommandRepositoryfrom repositories.app_statistic_query_repository import AppStatisticQueryRepository-from repositories.app_tracing_config_repository import SQLAlchemyAppTracingConfigRepositoryfrom repositories.human_input_file_upload_repository import SQLAlchemyHumanInputFileUploadRepositoryfrom repositories.installed_app_repository import SQLAlchemyInstalledAppRepositoryfrom repositories.message_file_preview_repository import MessageFilePreviewQueryRepositorydiff --git a/api/tests/unit_tests/models/test_app_mcp_server_session_accessors.py b/api/tests/unit_tests/models/test_app_mcp_server_session_accessors.pyindex 376dea85b86..fab3482748e 100644--- a/api/tests/unit_tests/models/test_app_mcp_server_session_accessors.py+++ b/api/tests/unit_tests/models/test_app_mcp_server_session_accessors.py@@ -11,7 +11,6 @@ from uuid import uuid4from sqlalchemy.orm import Session-from models.enums import AppMCPServerStatusfrom models.model import AppMCPServer@@ -22,7 +21,7 @@ def _persist_server(session: Session, *, server_code: str) -> AppMCPServer:name="Test MCP Server",description="Test server",server_code=server_code,- status=AppMCPServerStatus.ACTIVE,+ status="active",parameters="{}",)session.add(server)diff --git a/api/tests/unit_tests/repositories/app/console_visibility.py b/api/tests/unit_tests/repositories/app/console_visibility.pynew file mode 100644index 00000000000..5523a0079f0--- /dev/null+++ b/api/tests/unit_tests/repositories/app/console_visibility.py@@ -0,0 +1,42 @@+"""Ways an existing App row becomes unaddressable from Console, shared by app repository tests."""++from collections.abc import Callable++import pytest+from sqlalchemy import text+from sqlalchemy.orm import Session++from models.agent import Agent, AgentScope, AgentSource, AgentStatus+from models.model import App, AppMode++MakeUnaddressable = Callable[[Session, str], None]+++def disable(session: Session, app_id: str) -> None:+ # AppStatus only models "normal"; legacy rows may carry other values.+ session.execute(text("UPDATE apps SET status = 'disabled' WHERE id = :id"), {"id": app_id})+++def hide_behind_workflow_agent(status: AgentStatus) -> MakeUnaddressable:+ def hide(session: Session, app_id: str) -> None:+ app = session.get_one(App, app_id)+ app.mode = AppMode.AGENT+ session.add(+ Agent(+ tenant_id=app.tenant_id,+ name="hidden",+ scope=AgentScope.WORKFLOW_ONLY,+ source=AgentSource.WORKFLOW,+ status=status,+ backing_app_id=app_id,+ )+ )++ return hide+++UNADDRESSABLE_IN_WORKSPACE = [+ pytest.param(disable, id="disabled-app"),+ pytest.param(hide_behind_workflow_agent(AgentStatus.ACTIVE), id="hidden-active-agent"),+ pytest.param(hide_behind_workflow_agent(AgentStatus.ARCHIVED), id="hidden-archived-agent"),+]diff --git a/api/tests/unit_tests/repositories/app/test_mcp_server_repository.py b/api/tests/unit_tests/repositories/app/test_mcp_server_repository.pynew file mode 100644index 00000000000..d68e244e284--- /dev/null+++ b/api/tests/unit_tests/repositories/app/test_mcp_server_repository.py@@ -0,0 +1,311 @@+"""Exercise App MCP server persistence with real short-lived Sessions."""++import json+from dataclasses import replace+from typing import Literal++import pytest+from sqlalchemy import Select, event+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import ORMExecuteState, Session, sessionmaker++from machinery.context import RequestContext+from models.model import App, AppMCPServer+from repositories.app.mcp_server_repository import AppMCPServerRepository+from services.app.mcp_server_service import (+ AppMCPServerAlreadyExistsError,+ AppMCPServerDraft,+ AppMCPServerNotFoundError,+ AppMCPServerRecord,+ AppMCPServerService,+ AppMCPServerStatus,+ AppMCPServerUpdate,+ PublishedApp,+)+from tests.unit_tests.model_factories import make_app+from tests.unit_tests.repositories.app.console_visibility import UNADDRESSABLE_IN_WORKSPACE, MakeUnaddressable++WORKSPACE_ID = "tenant-1"+DRAFT = AppMCPServerDraft(+ name="Server", description="Described", parameters={"label": "中文"}, status=AppMCPServerStatus.ACTIVE+)+++def configured_app(sqlite_session: Session) -> App:+ app = make_app(tenant_id=WORKSPACE_ID, name="App name", description="App description")+ sqlite_session.add(app)+ sqlite_session.commit()+ return app+++def other_app(sqlite_session: Session) -> App:+ app = make_app(app_id="app-2", tenant_id=WORKSPACE_ID)+ sqlite_session.add(app)+ sqlite_session.commit()+ return app+++def repository(sqlite_session_factory: sessionmaker[Session]) -> AppMCPServerRepository:+ return AppMCPServerRepository(session_factory=sqlite_session_factory)+++def test_lifecycle_writes_drafts_verbatim(configured_app: App, repository: AppMCPServerRepository) -> None:+ scope: dict[str, str] = {"workspace_id": WORKSPACE_ID, "app_id": configured_app.id}+ assert repository.find_server(**scope) is None++ created = repository.insert_server(**scope, draft=DRAFT)+ assert (created.name, created.description, created.status) == ("Server", "Described", AppMCPServerStatus.ACTIVE)+ assert json.loads(created.parameters) == {"label": "中文"}+ assert len(created.server_code) == 16+ assert repository.find_server(**scope) == created++ changed = AppMCPServerUpdate(name="Renamed", description="", parameters={}, status=AppMCPServerStatus.INACTIVE)+ updated = repository.update_server(**scope, server_id=created.id, update=changed)+ assert (updated.name, updated.description, updated.status) == ("Renamed", "", AppMCPServerStatus.INACTIVE)+ assert updated.server_code == created.server_code++ rotated = repository.rotate_server_code(**scope)+ assert rotated.id == created.id+ assert rotated.server_code != created.server_code+ assert repository.find_server(**scope) == rotated++[email protected]("status", list(AppMCPServerStatus))+def test_repository_maps_stored_status_to_application_enum(+ configured_app: App,+ repository: AppMCPServerRepository,+ sqlite_session_factory: sessionmaker[Session],+ status: AppMCPServerStatus,+) -> None:+ scope: dict[str, str] = {"workspace_id": WORKSPACE_ID, "app_id": configured_app.id}+ created = repository.insert_server(**scope, draft=replace(DRAFT, status=status))+ assert created.status is status++ with sqlite_session_factory() as session:+ assert session.get_one(AppMCPServer, created.id).status == status.value++ found = repository.find_server(**scope)+ assert found is not None+ assert found.status is status++[email protected]("operation", ["update", "refresh"])+def test_service_mutations_read_server_at_most_once(+ configured_app: App,+ repository: AppMCPServerRepository,+ sqlite_session_factory: sessionmaker[Session],+ operation: Literal["update", "refresh"],+) -> None:+ created = repository.insert_server(workspace_id=WORKSPACE_ID, app_id=configured_app.id, draft=DRAFT)+ service = AppMCPServerService(servers=repository)+ context = RequestContext("request", None, "account", WORKSPACE_ID)+ server_read_count = 0++ def capture_reads(state: ORMExecuteState) -> None:+ nonlocal server_read_count+ if state.is_select and isinstance(state.statement, Select):+ # Count full server reads, excluding code uniqueness checks and generated timestamp reloads.+ if not state.is_column_load and any(+ column["expr"] is AppMCPServer for column in state.statement.column_descriptions+ ):+ server_read_count += 1++ event.listen(sqlite_session_factory, "do_orm_execute", capture_reads)+ try:+ if operation == "update":+ result = service.update(+ context, configured_app.id, server_id=created.id, description="Edited", parameters={}, status=None+ )+ assert result.description == "Edited"+ else:+ result = service.refresh(context, configured_app.id)+ assert result.server_code != created.server_code+ finally:+ event.remove(sqlite_session_factory, "do_orm_execute", capture_reads)++ assert result.id == created.id+ assert result.status is created.status+ assert server_read_count <= 1+ with sqlite_session_factory() as session:+ persisted = session.get_one(AppMCPServer, created.id)+ assert persisted.description == result.description+ assert persisted.parameters == result.parameters+ assert persisted.server_code == result.server_code+ assert persisted.status == created.status.value+++def test_service_mutations_preserve_server_ownership(+ configured_app: App, other_app: App, repository: AppMCPServerRepository+) -> None:+ scope: dict[str, str] = {"workspace_id": WORKSPACE_ID, "app_id": configured_app.id}+ owned = repository.insert_server(**scope, draft=DRAFT)+ foreign = repository.insert_server(workspace_id=WORKSPACE_ID, app_id=other_app.id, draft=DRAFT)+ service = AppMCPServerService(servers=repository)+ context = RequestContext("request", None, "account", WORKSPACE_ID)++ with pytest.raises(AppMCPServerNotFoundError):+ service.update(+ context, configured_app.id, server_id=foreign.id, description="Wrong server", parameters={}, status=None+ )+ assert repository.find_server(**scope) == owned++ refreshed = service.refresh(context, configured_app.id)+ assert refreshed.id == owned.id+ assert refreshed.server_code != owned.server_code+ assert repository.find_server(workspace_id=WORKSPACE_ID, app_id=other_app.id) == foreign+++def test_service_mutations_report_missing_server(configured_app: App, repository: AppMCPServerRepository) -> None:+ service = AppMCPServerService(servers=repository)+ context = RequestContext("request", None, "account", WORKSPACE_ID)++ with pytest.raises(AppMCPServerNotFoundError):+ service.update(+ context, configured_app.id, server_id="missing", description="Edited", parameters={}, status=None+ )+ with pytest.raises(AppMCPServerNotFoundError):+ service.refresh(context, configured_app.id)+ assert repository.find_server(workspace_id=WORKSPACE_ID, app_id=configured_app.id) is None++[email protected]("status", [None, AppMCPServerStatus.ACTIVE, AppMCPServerStatus.INACTIVE])+def test_update_inactive_server_changes_status_only_when_requested(+ configured_app: App,+ repository: AppMCPServerRepository,+ sqlite_session_factory: sessionmaker[Session],+ status: AppMCPServerStatus | None,+) -> None:+ scope: dict[str, str] = {"workspace_id": WORKSPACE_ID, "app_id": configured_app.id}+ created = repository.insert_server(+ **scope,+ draft=AppMCPServerDraft(name="Server", description="", parameters={}, status=AppMCPServerStatus.INACTIVE),+ )+ update = AppMCPServerUpdate(name="Renamed", description="Edited", parameters={}, status=status)++ updated = repository.update_server(**scope, server_id=created.id, update=update)++ expected_status = AppMCPServerStatus.INACTIVE if status is None else status+ assert updated.status == expected_status+ with sqlite_session_factory() as session:+ persisted = session.get_one(AppMCPServer, created.id)+ assert (persisted.name, persisted.description, persisted.status) == ("Renamed", "Edited", expected_status)+++def test_concurrent_insert_loser_gets_domain_error(configured_app: App, repository: AppMCPServerRepository) -> None:+ # The service pre-check can miss a row another request commits meanwhile; the constraint is the last word.+ scope: dict[str, str] = {"workspace_id": WORKSPACE_ID, "app_id": configured_app.id}+ winner = repository.insert_server(**scope, draft=DRAFT)++ with pytest.raises(AppMCPServerAlreadyExistsError):+ repository.insert_server(**scope, draft=DRAFT)+ assert repository.find_server(**scope) == winner+++def test_description_edit_preserves_concurrent_deactivation(+ configured_app: App,+ repository: AppMCPServerRepository,+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ scope: dict[str, str] = {"workspace_id": WORKSPACE_ID, "app_id": configured_app.id}+ created = repository.insert_server(**scope, draft=DRAFT)+ update_server = repository.update_server++ def deactivate_then_update(+ *, workspace_id: str, app_id: str, server_id: str, update: AppMCPServerUpdate+ ) -> AppMCPServerRecord:+ # Another request deactivates the server after the edit is prepared, before its write transaction.+ with sqlite_session_factory.begin() as session:+ server = session.get_one(AppMCPServer, created.id)+ assert server.status == AppMCPServerStatus.ACTIVE+ server.status = AppMCPServerStatus.INACTIVE.value+ return update_server(workspace_id=workspace_id, app_id=app_id, server_id=server_id, update=update)++ monkeypatch.setattr(repository, "update_server", deactivate_then_update)+ service = AppMCPServerService(servers=repository)+ updated = service.update(+ RequestContext("request", None, "account", WORKSPACE_ID),+ configured_app.id,+ server_id=created.id,+ description="Edited description",+ parameters={"edited": True},+ status=None,+ )++ assert updated.status == AppMCPServerStatus.INACTIVE+ with sqlite_session_factory() as session:+ persisted = session.get_one(AppMCPServer, created.id)+ assert persisted.status == AppMCPServerStatus.INACTIVE+ assert persisted.description == "Edited description"+ assert json.loads(persisted.parameters) == {"edited": True}+++def test_server_code_collision_is_not_reported_as_duplicate(+ configured_app: App, other_app: App, repository: AppMCPServerRepository, monkeypatch: pytest.MonkeyPatch+) -> None:+ taken = repository.insert_server(workspace_id=WORKSPACE_ID, app_id=other_app.id, draft=DRAFT)+ monkeypatch.setattr(AppMCPServer, "generate_server_code", staticmethod(lambda _n, **_kwargs: taken.server_code))++ with pytest.raises(IntegrityError):+ repository.insert_server(workspace_id=WORKSPACE_ID, app_id=configured_app.id, draft=DRAFT)+ assert repository.find_server(workspace_id=WORKSPACE_ID, app_id=configured_app.id) is None++[email protected](("tenant_id", "app_id"), [("tenant-2", None), (WORKSPACE_ID, "app-2")])+def test_foreign_servers_are_invisible(+ configured_app: App,+ repository: AppMCPServerRepository,+ sqlite_session_factory: sessionmaker[Session],+ tenant_id: str,+ app_id: str | None,+) -> None:+ foreign = AppMCPServer(+ tenant_id=tenant_id,+ app_id=app_id or configured_app.id,+ name="foreign",+ description="private",+ server_code="foreign-code",+ status=AppMCPServerStatus.ACTIVE.value,+ parameters="{}",+ )+ with sqlite_session_factory.begin() as session:+ session.add(foreign)+ scope: dict[str, str] = {"workspace_id": WORKSPACE_ID, "app_id": configured_app.id}++ assert repository.find_server(**scope) is None+ with pytest.raises(AppMCPServerNotFoundError):+ repository.update_server(+ **scope,+ server_id=foreign.id,+ update=AppMCPServerUpdate(name="Server", description="Edited", parameters={}, status=None),+ )+ with pytest.raises(AppMCPServerNotFoundError):+ repository.rotate_server_code(**scope)+ with sqlite_session_factory() as session:+ persisted = session.get_one(AppMCPServer, foreign.id)+ assert (persisted.description, persisted.server_code) == ("private", "foreign-code")+++def test_find_app_returns_mirrored_fields(configured_app: App, repository: AppMCPServerRepository) -> None:+ found = repository.find_app(workspace_id=WORKSPACE_ID, app_id=configured_app.id)+ assert found == PublishedApp(name="App name", description="App description")+++def test_find_app_is_scoped_to_workspace(configured_app: App, repository: AppMCPServerRepository) -> None:+ assert repository.find_app(workspace_id="other-workspace", app_id=configured_app.id) is None++[email protected]("make_unaddressable", UNADDRESSABLE_IN_WORKSPACE)+def test_find_app_hides_unaddressable_apps(+ configured_app: App,+ repository: AppMCPServerRepository,+ sqlite_session_factory: sessionmaker[Session],+ make_unaddressable: MakeUnaddressable,+) -> None:+ with sqlite_session_factory.begin() as session:+ make_unaddressable(session, configured_app.id)++ assert repository.find_app(workspace_id=WORKSPACE_ID, app_id=configured_app.id) is Nonediff --git a/api/tests/unit_tests/repositories/test_app_site_command_repository.py b/api/tests/unit_tests/repositories/app/test_site_command_repository.pysimilarity index 82%rename from api/tests/unit_tests/repositories/test_app_site_command_repository.pyrename to api/tests/unit_tests/repositories/app/test_site_command_repository.pyindex 82ab78a915b..b3ac290c672 100644--- a/api/tests/unit_tests/repositories/test_app_site_command_repository.py+++ b/api/tests/unit_tests/repositories/app/test_site_command_repository.py@@ -4,8 +4,9 @@ from sqlalchemy.orm import Session, sessionmakerfrom models.enums import CustomizeTokenStrategyfrom models.model import App, AppMode, Site-from repositories.app_site_command_repository import AppSiteCommandRepository+from repositories.app.site_command_repository import AppSiteCommandRepositoryfrom services.app_site_service import AppSiteAppNotFoundError, AppSiteChanges, AppSiteNotFoundError+from tests.unit_tests.repositories.app.console_visibility import UNADDRESSABLE_IN_WORKSPACE, MakeUnaddressable_APP_ID = "11111111-1111-1111-1111-111111111111"_WORKSPACE_ID = "22222222-2222-2222-2222-222222222222"@@ -108,6 +109,28 @@ def test_update_scopes_app_to_workspace_and_distinguishes_missing_site()[email protected]("make_unaddressable", UNADDRESSABLE_IN_WORKSPACE)+def test_commands_reject_apps_console_cannot_address(+ make_unaddressable: MakeUnaddressable,+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ _persist_app(sqlite_session)+ with sqlite_session_factory.begin() as session:+ make_unaddressable(session, _APP_ID)+ repository = _repository(sqlite_session_factory)+ scope: dict[str, str] = {"workspace_id": _WORKSPACE_ID, "app_id": _APP_ID, "actor_id": _ACTOR_ID}++ with pytest.raises(AppSiteAppNotFoundError):+ repository.update_site(**scope, changes=AppSiteChanges(title="Leaked"))+ with pytest.raises(AppSiteAppNotFoundError):+ repository.reset_access_token(**scope)+ with sqlite_session_factory() as session:+ site = session.scalar(select(Site).where(Site.app_id == _APP_ID))+ assert site is not None+ assert (site.title, site.code) == ("Original", "old-code")++def test_update_rolls_back_when_a_site_field_rejects_the_value(sqlite_session: Session,sqlite_session_factory: sessionmaker[Session],diff --git a/api/tests/unit_tests/repositories/test_app_tracing_config_repository.py b/api/tests/unit_tests/repositories/app/test_tracing_config_repository.pysimilarity index 86%rename from api/tests/unit_tests/repositories/test_app_tracing_config_repository.pyrename to api/tests/unit_tests/repositories/app/test_tracing_config_repository.pyindex f58efbbbfc2..abb31de5b28 100644--- a/api/tests/unit_tests/repositories/test_app_tracing_config_repository.py+++ b/api/tests/unit_tests/repositories/app/test_tracing_config_repository.py@@ -1,12 +1,13 @@from collections.abc import Callableimport pytest-from sqlalchemy import select, text+from sqlalchemy import selectfrom sqlalchemy.orm import Session, sessionmakerfrom models.model import App, AppMode, TraceAppConfig-from repositories.app_tracing_config_repository import SQLAlchemyAppTracingConfigRepository+from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepositoryfrom services.app_tracing_config_service import AppTracingConfigAppNotFoundError, AppTracingConfigRecord+from tests.unit_tests.repositories.app.console_visibility import UNADDRESSABLE_IN_WORKSPACE, MakeUnaddressable_APP_ID = "11111111-1111-1111-1111-111111111111"_WORKSPACE_ID = "22222222-2222-2222-2222-222222222222"@@ -86,18 +87,21 @@ def test_config_lifecycle_is_persisted_by_owned_transactions(assert session.scalar(select(TraceAppConfig).where(TraceAppConfig.app_id == _APP_ID)) is None[email protected]("app_state", ["other-workspace", "non-normal"])-def test_all_operations_reject_apps_outside_the_active_workspace_scope(- app_state: str,+ ("workspace_id", "make_unaddressable"),+ [pytest.param(_OTHER_WORKSPACE_ID, None, id="other-workspace")]+ + [pytest.param(_WORKSPACE_ID, *case.values, id=case.id) for case in UNADDRESSABLE_IN_WORKSPACE],+)+def test_all_operations_reject_apps_console_cannot_address(+ workspace_id: str,+ make_unaddressable: MakeUnaddressable | None,sqlite_session: Session,sqlite_session_factory: sessionmaker[Session],) -> None:_persist_app(sqlite_session)- workspace_id = _OTHER_WORKSPACE_ID- if app_state == "non-normal":- sqlite_session.execute(text("UPDATE apps SET status = 'disabled' WHERE id = :app_id"), {"app_id": _APP_ID})- sqlite_session.commit()- workspace_id = _WORKSPACE_ID+ if make_unaddressable is not None:+ with sqlite_session_factory.begin() as session:+ make_unaddressable(session, _APP_ID)repository = _repository(sqlite_session_factory)operations: tuple[Callable[[], object], ...] = (diff --git a/api/tests/unit_tests/services/app/test_mcp_server_service.py b/api/tests/unit_tests/services/app/test_mcp_server_service.pynew file mode 100644index 00000000000..2fc71cedecd--- /dev/null+++ b/api/tests/unit_tests/services/app/test_mcp_server_service.py@@ -0,0 +1,171 @@+"""Publishing rules of AppMCPServerService, isolated from persistence by an in-memory store."""++import datetime+from dataclasses import replace++import pytest++from machinery.context import RequestContext+from services.app.mcp_server_service import (+ AppMCPServerAlreadyExistsError,+ AppMCPServerAppNotFoundError,+ AppMCPServerDraft,+ AppMCPServerNotFoundError,+ AppMCPServerRecord,+ AppMCPServerService,+ AppMCPServerStatus,+ AppMCPServerStore,+ AppMCPServerUpdate,+ PublishedApp,+)++CONTEXT = RequestContext("request", None, "account", "workspace")+APP_ID = "app-1"+NOW = datetime.datetime(2024, 1, 1, tzinfo=datetime.UTC)+++def _assert_scope(workspace_id: str, app_id: str) -> None:+ assert (workspace_id, app_id) == (CONTEXT.active_workspace_id, APP_ID)+++class InMemoryStore(AppMCPServerStore):+ def __init__(self, app: PublishedApp | None) -> None:+ self.app = app+ self.server: AppMCPServerRecord | None = None+ self.writes: list[AppMCPServerDraft | AppMCPServerUpdate] = []++ def find_app(self, *, workspace_id: str, app_id: str) -> PublishedApp | None:+ _assert_scope(workspace_id, app_id)+ return self.app++ def find_server(self, *, workspace_id: str, app_id: str) -> AppMCPServerRecord | None:+ _assert_scope(workspace_id, app_id)+ return self.server++ def insert_server(self, *, workspace_id: str, app_id: str, draft: AppMCPServerDraft) -> AppMCPServerRecord:+ _assert_scope(workspace_id, app_id)+ self.writes.append(draft)+ self.server = AppMCPServerRecord(+ id="server-1",+ server_code="code-1",+ name=draft.name,+ description=draft.description,+ status=draft.status,+ parameters="{}",+ created_at=NOW,+ updated_at=NOW,+ )+ return self.server++ def update_server(+ self, *, workspace_id: str, app_id: str, server_id: str, update: AppMCPServerUpdate+ ) -> AppMCPServerRecord:+ _assert_scope(workspace_id, app_id)+ if self.server is None or server_id != self.server.id:+ raise AppMCPServerNotFoundError+ self.writes.append(update)+ self.server = replace(+ self.server,+ name=update.name,+ description=update.description,+ status=self.server.status if update.status is None else update.status,+ )+ return self.server++ def rotate_server_code(self, *, workspace_id: str, app_id: str) -> AppMCPServerRecord:+ _assert_scope(workspace_id, app_id)+ if self.server is None:+ raise AppMCPServerNotFoundError+ self.server = replace(self.server, server_code=f"{self.server.server_code}-rotated")+ return self.server+++def store() -> InMemoryStore:+ return InMemoryStore(PublishedApp(name="App name", description="App description"))+++def service(store: InMemoryStore) -> AppMCPServerService:+ return AppMCPServerService(servers=store)+++ ("description", "expected"), [(None, "App description"), ("", "App description"), ("own", "own")]+)+def test_create_mirrors_app_and_starts_active(+ service: AppMCPServerService, store: InMemoryStore, description: str | None, expected: str+) -> None:+ service.create(CONTEXT, APP_ID, description=description, parameters={"k": "v"})++ expected_draft = AppMCPServerDraft(+ name="App name", description=expected, parameters={"k": "v"}, status=AppMCPServerStatus.ACTIVE+ )+ assert store.writes == [expected_draft]+++def test_create_rejects_second_server(service: AppMCPServerService, store: InMemoryStore) -> None:+ service.create(CONTEXT, APP_ID, description=None, parameters={})++ with pytest.raises(AppMCPServerAlreadyExistsError):+ service.create(CONTEXT, APP_ID, description=None, parameters={})+ assert len(store.writes) == 1+++def test_update_resyncs_name_and_keeps_status_unless_requested(+ service: AppMCPServerService, store: InMemoryStore+) -> None:+ created = service.create(CONTEXT, APP_ID, description=None, parameters={})+ store.app = PublishedApp(name="Renamed app", description="New app description")++ kept = service.update(CONTEXT, APP_ID, server_id=created.id, description=None, parameters={}, status=None)+ assert store.writes[-1].status is None+ assert (kept.name, kept.description, kept.status) == (+ "Renamed app",+ "New app description",+ AppMCPServerStatus.ACTIVE,+ )++ changed = service.update(+ CONTEXT, APP_ID, server_id=created.id, description="own", parameters={}, status=AppMCPServerStatus.INACTIVE+ )+ assert (changed.description, changed.status) == ("own", AppMCPServerStatus.INACTIVE)+++def test_update_rejects_server_id_not_owned_by_app(service: AppMCPServerService, store: InMemoryStore) -> None:+ service.create(CONTEXT, APP_ID, description=None, parameters={})++ with pytest.raises(AppMCPServerNotFoundError):+ service.update(CONTEXT, APP_ID, server_id="other-server", description=None, parameters={}, status=None)+ assert len(store.writes) == 1+++def test_refresh_rotates_the_apps_server(service: AppMCPServerService) -> None:+ created = service.create(CONTEXT, APP_ID, description=None, parameters={})++ refreshed = service.refresh(CONTEXT, APP_ID)+ assert (refreshed.id, refreshed.server_code) == (created.id, "code-1-rotated")+++def test_missing_server_is_not_found(service: AppMCPServerService) -> None:+ assert service.get(CONTEXT, APP_ID) is None+ with pytest.raises(AppMCPServerNotFoundError):+ service.refresh(CONTEXT, APP_ID)+ with pytest.raises(AppMCPServerNotFoundError):+ service.update(CONTEXT, APP_ID, server_id="server-1", description=None, parameters={}, status=None)+++def test_unaddressable_app_rejects_every_command(store: InMemoryStore) -> None:+ store.app = None+ service = AppMCPServerService(servers=store)++ commands = [+ lambda: service.get(CONTEXT, APP_ID),+ lambda: service.create(CONTEXT, APP_ID, description=None, parameters={}),+ lambda: service.update(CONTEXT, APP_ID, server_id="server-1", description=None, parameters={}, status=None),+ lambda: service.refresh(CONTEXT, APP_ID),+ ]+ for command in commands:+ with pytest.raises(AppMCPServerAppNotFoundError):+ command()+ assert store.writes == []diff --git a/packages/contracts/generated/api/console/apps/types.gen.ts b/packages/contracts/generated/api/console/apps/types.gen.tsindex 85850218a8b..860f92b33fc 100644--- a/packages/contracts/generated/api/console/apps/types.gen.ts+++ b/packages/contracts/generated/api/console/apps/types.gen.ts@@ -596,7 +596,7 @@ export type McpServerUpdatePayload = {parameters: {[key: string]: unknown}- status?: string | null+ status?: AppMcpServerStatus | null}export type AppSiteUpdatePayload = {@@ -5687,6 +5687,7 @@ export type PostAppsByAppIdServerData = {export type PostAppsByAppIdServerErrors = {403: unknown+ 409: unknown}export type PostAppsByAppIdServerResponses = {diff --git a/packages/contracts/generated/api/console/apps/zod.gen.ts b/packages/contracts/generated/api/console/apps/zod.gen.tsindex 591d86b525e..6d9f241a1b6 100644--- a/packages/contracts/generated/api/console/apps/zod.gen.ts+++ b/packages/contracts/generated/api/console/apps/zod.gen.ts@@ -343,16 +343,6 @@ export const zMcpServerCreatePayload = z.object({parameters: z.record(z.string(), z.unknown()),})-/**- * MCPServerUpdatePayload- */-export const zMcpServerUpdatePayload = z.object({- description: z.string().nullish(),- id: z.string(),- parameters: z.record(z.string(), z.unknown()),- status: z.string().nullish(),-})-/*** AppSiteUpdatePayload*/@@ -1156,7 +1146,7 @@ export const zMessageFile = z.object({/*** AppMCPServerStatus*- * AppMCPServer Status Enum+ * Publication state of a Dify app exposed as an MCP server; only ACTIVE servers accept MCP calls.*/export const zAppMcpServerStatus = z.enum(['active', 'inactive', 'normal'])@@ -1174,6 +1164,16 @@ export const zAppMcpServerResponse = z.object({updated_at: z.int().nullish(),})+/**+ * MCPServerUpdatePayload+ */+export const zMcpServerUpdatePayload = z.object({+ description: z.string().nullish(),+ id: z.uuid(),+ parameters: z.record(z.string(), z.unknown()),+ status: zAppMcpServerStatus.nullish(),+})+/*** AverageResponseTimeStatisticItem*/