Skip to content

armgit / dify

Public Imported from GitHub
0

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.

refactor(api): separate app MCP server service and persistence (#42850)

Byron.wang0c5f2507d0bb
diff --git a/api/.importlinter b/api/.importlinter
index e010fe8a0e9..c7a355e1c78 100644
--- a/api/.importlinter
+++ b/api/.importlinter
@@ -786,6 +786,46 @@ forbidden_modules =
tasks
werkzeug
+[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 neutral
type = forbidden
diff --git a/api/controllers/console/app/mcp_server.py b/api/controllers/console/app/mcp_server.py
index d6615124cb3..390a580bbb8 100644
--- a/api/controllers/console/app/mcp_server.py
+++ b/api/controllers/console/app/mcp_server.py
@@ -1,32 +1,31 @@
import json
from datetime import datetime
from typing import Any
+from uuid import UUID
from flask_restx import Resource
from pydantic import BaseModel, Field, field_validator
-from sqlalchemy import select
-from werkzeug.exceptions import NotFound
+from werkzeug.exceptions import Conflict, NotFound
from controllers.common.rbac import PlainApp, RBACCheck
from controllers.common.schema import register_schema_models
from 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_services
from fields.base import ResponseModel
from 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 error
if 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 error
return 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 error
return 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 error
return dump_response(AppMCPServerResponse, server)
diff --git a/api/controllers/console/app/wraps.py b/api/controllers/console/app/wraps.py
index 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 db
from libs.login import current_account_with_tenant
from models import App, AppMode
from 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 None
return app_model
def _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.py
index 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_protoc
from extensions.ext_database import db
from graphon.variables.input_entities import VariableEntity, VariableEntityType
from libs import helper
-from models.enums import AppMCPServerStatus, EndUserType
+from models.enums import EndUserType
from models.model import App, AppMCPServer, AppMode, EndUser
+from services.app.mcp_server_service import AppMCPServerStatus
class 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.py
index 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 SQLAlchemyAppTracingConfigRepository
from repositories.app_definition_query_repository import AppDefinitionQueryRepository
from repositories.app_preview_query_repository import AppPreviewQueryRepository
from repositories.app_scoped_end_user_repository import AppScopedEndUserRepo
-from repositories.app_site_command_repository import AppSiteCommandRepository
from repositories.app_statistic_query_repository import AppStatisticQueryRepository
-from repositories.app_tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from repositories.data_source_api_key_auth_repository import SQLAlchemyDataSourceApiKeyAuthBindingRepository
from repositories.data_source_oauth_binding_repository import SQLAlchemyDataSourceOAuthBindingRepository
from repositories.explore_banner_query_repository import ExploreBannerQueryRepository
@@ -148,6 +149,7 @@ from services.account_password_service import AccountPasswordService
from services.account_profile_service import AccountProfileService
from services.app.advanced_prompt_template_service import AdvancedPromptTemplateService
from services.app.api_key_service import AppApiKeyService
+from services.app.mcp_server_service import AppMCPServerService
from services.app_audio_adapters import AppAudioRuntime
from services.app_audio_service import AppAudio
from services.app_definition_query_service import AppDefinitionQueryService
@@ -339,6 +341,7 @@ class ApplicationServices:
account_activation: AccountActivationService
apps: AppServices
app_definitions: AppDefinitionQueryService
+ app_mcp_servers: AppMCPServerService
app_preview_details: AppPreviewDetails
app_previews: AppPreviewQueryService
app_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.py
index 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.py
index a6560db9e9f..c4482b15d0a 100644
--- a/api/models/model.py
+++ b/api/models/model.py
@@ -34,7 +34,6 @@ from .base import Base, TypeBase, gen_uuidv4_string
from .engine import db
from .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.md
index 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}/server
Update 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 |
#### Marketplace
diff --git a/api/repositories/app/__init__.py b/api/repositories/app/__init__.py
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
similarity index 82%
rename from api/repositories/app_site_command_repository.py
rename to api/repositories/app/site_command_repository.py
index 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 asdict
from typing import override
-from sqlalchemy import select
+from sqlalchemy import ColumnElement, select
from sqlalchemy.orm import Session, sessionmaker
from libs.datetime_utils import naive_utc_now
from models.enums import AppStatus
from models.model import App, Site
+from repositories.app.console_visibility import console_visible_condition
from 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):
@staticmethod
def _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 AppSiteAppNotFoundError
raise AppSiteNotFoundError
diff --git a/api/repositories/app_tracing_config_repository.py b/api/repositories/app/tracing_config_repository.py
similarity index 97%
rename from api/repositories/app_tracing_config_repository.py
rename to api/repositories/app/tracing_config_repository.py
index 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, sessionmaker
from models.enums import AppStatus
from models.model import App, TraceAppConfig
+from repositories.app.console_visibility import console_visible_condition
from 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__.py
index 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.py
new file mode 100644
index 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 app
diff --git a/api/services/app_ref_service.py b/api/services/app_ref_service.py
index 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.py
index 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.py
new file mode 100644
index 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.py
index 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, field
from inspect import unwrap
-from unittest.mock import patch
+from types import SimpleNamespace
+from uuid import UUID
import pytest
from 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, UnprocessableEntity
from 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 servers
class 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.py
index 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_module
from controllers.console.app import workflow as workflow_module
from controllers.console.app import wraps as wraps_module
from controllers.console.app.error import AppNotFoundError
+from models.agent import Agent, AgentScope, AgentSource, AgentStatus
from 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.py
index 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, patch
import pytest
from flask import Flask
from flask_login import LoginManager, UserMixin
+from flask_restx import Api, Resource
from pydantic import BaseModel
from sqlalchemy import select
from 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_handlers
from libs.login import AccountWithTenant
from machinery.context import RequestContext
from 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.py
index 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 pytest
from sqlalchemy.orm import Session
from controllers.mcp.mcp import MCPAppApi
-from models.enums import AppMCPServerStatus
from models.model import App, AppMCPServer, AppMode, IconType
+from services.app.mcp_server_service import AppMCPServerStatus
TENANT_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.py
index 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 SQLAlchemyAppTracingConfigRepository
from repositories.app_scoped_end_user_repository import AppScopedEndUserRepo
-from repositories.app_site_command_repository import AppSiteCommandRepository
from repositories.app_statistic_query_repository import AppStatisticQueryRepository
-from repositories.app_tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from repositories.human_input_file_upload_repository import SQLAlchemyHumanInputFileUploadRepository
from repositories.installed_app_repository import SQLAlchemyInstalledAppRepository
from repositories.message_file_preview_repository import MessageFilePreviewQueryRepository
diff --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.py
index 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 uuid4
from sqlalchemy.orm import Session
-from models.enums import AppMCPServerStatus
from 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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 None
diff --git a/api/tests/unit_tests/repositories/test_app_site_command_repository.py b/api/tests/unit_tests/repositories/app/test_site_command_repository.py
similarity index 82%
rename from api/tests/unit_tests/repositories/test_app_site_command_repository.py
rename to api/tests/unit_tests/repositories/app/test_site_command_repository.py
index 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, sessionmaker
from models.enums import CustomizeTokenStrategy
from models.model import App, AppMode, Site
-from repositories.app_site_command_repository import AppSiteCommandRepository
+from repositories.app.site_command_repository import AppSiteCommandRepository
from 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.py
similarity index 86%
rename from api/tests/unit_tests/repositories/test_app_tracing_config_repository.py
rename to api/tests/unit_tests/repositories/app/test_tracing_config_repository.py
index 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 Callable
import pytest
-from sqlalchemy import select, text
+from sqlalchemy import select
from sqlalchemy.orm import Session, sessionmaker
from models.model import App, AppMode, TraceAppConfig
-from repositories.app_tracing_config_repository import SQLAlchemyAppTracingConfigRepository
+from repositories.app.tracing_config_repository import SQLAlchemyAppTracingConfigRepository
from 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.py
new file mode 100644
index 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.ts
index 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.ts
index 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
*/