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
feat(agent): import roster packages through App routes (#42189)
林玮 (Jade Lin)3d7f6f449683
diff --git a/api/controllers/console/app/app.py b/api/controllers/console/app/app.pyindex ad6961ef074..28baa5b01a5 100644--- a/api/controllers/console/app/app.py+++ b/api/controllers/console/app/app.py@@ -4,6 +4,7 @@ from collections.abc import Sequencefrom datetime import datetimefrom typing import Any, Literal+from flask import send_filefrom flask_restx import Resourcefrom pydantic import AliasChoices, BaseModel, Field, ValidationInfo, computed_field, field_validator, model_validatorfrom sqlalchemy import select@@ -47,10 +48,12 @@ from extensions.ext_application_services import application_servicesfrom extensions.ext_database import dbfrom fields.base import ResponseModelfrom graphon.enums import WorkflowExecutionStatus+from libs.flask_restx_compat import BINARY_RESPONSE_MEDIA_TYPES_VENDOR_KEYfrom libs.helper import build_icon_url, dump_response, to_timestampfrom libs.login import login_requiredfrom models import Account, App, DatasetPermissionEnum, Workflow-from models.model import IconType+from models.model import AppMode, IconType+from services.agent.roster_package_exporter import RosterAgentPackageExporterfrom services.app_dsl_service import AppDslServicefrom services.app_service import (AppListParams,@@ -180,6 +183,9 @@ class CopyAppPayload(BaseModel):class AppExportQuery(BaseModel):+ format: Literal["yaml", "ifpkg"] | None = Field(+ default=None, description="Export format; defaults to ifpkg for Agent Apps and yaml for other Apps"+ )include_secret: bool = Field(default=False, description="Include secrets in export")workflow_id: str | None = Field(default=None, description="Specific workflow ID to export")@@ -1027,6 +1033,10 @@ class AppExportApi(Resource):@console_ns.doc(description="Export application configuration as DSL")@console_ns.doc(params={"app_id": "Application ID to export"})@console_ns.doc(params=query_params_from_model(AppExportQuery))+ @console_ns.doc(+ produces=["application/json", "application/zip"],+ vendor={BINARY_RESPONSE_MEDIA_TYPES_VENDOR_KEY: ["application/zip"]},+ )@console_ns.response(200, "App exported successfully", console_ns.models[AppExportResponse.__name__])@console_ns.response(403, "Insufficient permissions")@setup_required@@ -1042,6 +1052,23 @@ class AppExportApi(Resource):def get(self, req_data: AppExportQuery, app_model: App):"""Export app"""+ if req_data.format == "ifpkg" or (req_data.format is None and app_model.mode == AppMode.AGENT):+ if app_model.mode != AppMode.AGENT:+ raise BadRequest("The ifpkg format is only available for Agent Apps")+ agent_id = app_model.bound_agent_id_with_session(session=db.session())+ if agent_id is None:+ raise NotFound("Agent not found")+ exported = RosterAgentPackageExporter().export(tenant_id=app_model.tenant_id, agent_id=agent_id)+ try:+ archive_response = send_file(+ exported.archive, mimetype="application/zip", as_attachment=True, download_name=exported.filename+ )+ except Exception:+ exported.close()+ raise+ archive_response.call_on_close(exported.close)+ return archive_response+response = AppExportResponse(data=AppDslService.export_dsl(app_model=app_model,diff --git a/api/controllers/console/app/app_import.py b/api/controllers/console/app/app_import.pyindex 18de98f8d9a..4872947b4dd 100644--- a/api/controllers/console/app/app_import.py+++ b/api/controllers/console/app/app_import.py@@ -1,3 +1,7 @@+from typing import BinaryIO, Literal, cast+from uuid import uuid4++from flask import requestfrom flask_restx import Resourcefrom pydantic import BaseModel, Fieldfrom sqlalchemy.orm import Session@@ -5,23 +9,27 @@ from werkzeug.exceptions import Forbiddenfrom configs import dify_configfrom controllers.common.rbac import PlainApp, RBACCheck, Workspace-from controllers.common.schema import register_enum_models, register_schema_models+from controllers.common.schema import register_enum_models, register_response_schema_models, register_schema_modelsfrom controllers.console.app.wraps import get_app_modelfrom controllers.console.wraps import (RBACPermission,account_initialization_required,cloud_edition_billing_resource_check,edit_permission_required,- model_validate,rbac_permission_required,setup_required,+ validate_request,with_current_user,)+from core.plugin.entities.plugin import PluginDependencyfrom extensions.ext_database import dbfrom extensions.ext_redis import redis_client+from fields.base import ResponseModelfrom libs.login import current_account_with_tenant, login_requiredfrom models.account import Account-from models.model import App+from models.model import App, AppMode+from services.agent.errors import InvalidRosterAgentPackageError+from services.agent.roster_package_importer import RosterAgentPackageImporterfrom services.app_dsl_service import (IMPORT_INFO_REDIS_KEY_PREFIX,AppDslService,@@ -49,8 +57,16 @@ class AppImportPayload(BaseModel):app_id: str | None = Field(None)+class RosterAgentPackageConflictResponse(ResponseModel):+ code: str+ message: str+ status: Literal[409] = 409+ leaked_dependencies: list[PluginDependency] = Field(default_factory=list)++register_enum_models(console_ns, ImportStatus)register_schema_models(console_ns, AppImportPayload, Import, CheckDependenciesResult)+register_response_schema_models(console_ns, RosterAgentPackageConflictResponse)def _current_user_and_tenant_id(current_user: Account | None) -> tuple[Account, str | None]:@@ -73,19 +89,74 @@ def _current_user_and_tenant_id(current_user: Account | None) -> tuple[Account,@console_ns.route("/apps/imports")class AppImportApi(Resource):- @console_ns.expect(console_ns.models[AppImportPayload.__name__])+ @console_ns.doc(+ params={+ "payload": {+ "required": True,+ "content": {+ "application/json": {"schema": {"$ref": "#/definitions/AppImportPayload"}},+ "multipart/form-data": {+ "schema": {+ "type": "object",+ "properties": {+ "file": {+ "type": "string",+ "format": "binary",+ "description": "Roster Agent .ifpkg archive",+ }+ },+ "required": ["file"],+ }+ },+ },+ }+ },+ )@console_ns.response(200, "Import completed", console_ns.models[Import.__name__])@console_ns.response(202, "Import pending confirmation", console_ns.models[Import.__name__])@console_ns.response(400, "Import failed", console_ns.models[Import.__name__])+ @console_ns.response(403, "Insufficient import or plugin installation permissions")+ @console_ns.response(+ 409, "Agent name conflict or missing plugins", console_ns.models[RosterAgentPackageConflictResponse.__name__]+ )+ @console_ns.response(413, "Roster Agent package exceeds the size limit")@setup_required@login_required@account_initialization_required- @cloud_edition_billing_resource_check("apps")@edit_permission_required- @rbac_permission_required(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace()))@with_current_user- @model_validate(AppImportPayload)- def post(self, req_data: AppImportPayload, current_user: Account | None = None):+ def post(self, current_user: Account):+ if request.mimetype == "multipart/form-data":+ return self._import_package(current_user)+ return self._import_dsl(validate_request(AppImportPayload), current_user)++ @rbac_permission_required(RBACCheck(RBACPermission.AGENT_CREATE, Workspace()))+ @rbac_permission_required(RBACCheck(RBACPermission.AGENT_IMPORT_EXPORT_DSL, Workspace()))+ def _import_package(self, current_user: Account):+ uploaded = request.files.get("file")+ if uploaded is None or not uploaded.filename:+ raise InvalidRosterAgentPackageError("Roster Agent package file is required")+ if not uploaded.filename.lower().endswith(".ifpkg"):+ raise InvalidRosterAgentPackageError("Roster Agent package file must use the .ifpkg extension")+ if request.form.get("app_id"):+ raise InvalidRosterAgentPackageError("Roster Agent package import does not support overwriting an App")+ account, tenant_id = _current_user_and_tenant_id(current_user)+ if tenant_id is None:+ raise Forbidden("Current workspace is required")+ result = RosterAgentPackageImporter().import_package(+ source=cast(BinaryIO, uploaded.stream), tenant_id=tenant_id, account=account+ )+ return Import(+ id=str(uuid4()),+ status=ImportStatus.COMPLETED_WITH_WARNINGS if result.warnings else ImportStatus.COMPLETED,+ app_id=result.app_id,+ app_mode=AppMode.AGENT,+ warnings=result.warnings,+ ).model_dump(mode="json"), 200++ @cloud_edition_billing_resource_check("apps")+ @rbac_permission_required(RBACCheck(RBACPermission.APP_IMPORT_EXPORT_DSL, Workspace()))+ def _import_dsl(self, req_data: AppImportPayload, current_user: Account | None = None):current_user = current_user if current_user is not None else _current_user_and_tenant_id(None)[0]# AppDslService performs internal commits for some creation paths, so use a plaindiff --git a/api/events/event_handlers/create_installed_app_when_app_created.py b/api/events/event_handlers/create_installed_app_when_app_created.pyindex 2e49c81e415..672ce6b7956 100644--- a/api/events/event_handlers/create_installed_app_when_app_created.py+++ b/api/events/event_handlers/create_installed_app_when_app_created.py@@ -1,24 +1,13 @@-from sqlalchemy import selectfrom sqlalchemy.orm import Sessionfrom events.app_event import app_was_created-from models.model import InstalledApp+from services.app_creation_records import create_installed_app_record@app_was_created.connect-def handle(sender, *, session: Session, **_kwargs) -> None:+def handle(sender, *, session: Session, **kwargs) -> None:"""Create an installed app when an app is created."""- app = sender- installed_app_id = session.scalar(- select(InstalledApp.id).where(InstalledApp.tenant_id == app.tenant_id, InstalledApp.app_id == app.id).limit(1)- )- if installed_app_id:+ if kwargs.get("created_records_initialized"):return-- installed_app = InstalledApp(- tenant_id=app.tenant_id,- app_id=app.id,- app_owner_tenant_id=app.tenant_id,- )- session.add(installed_app)- session.flush()+ app = sender+ create_installed_app_record(app=app, session=session)diff --git a/api/events/event_handlers/create_site_record_when_app_created.py b/api/events/event_handlers/create_site_record_when_app_created.pyindex 69149543fd7..9b9b0450adf 100644--- a/api/events/event_handlers/create_site_record_when_app_created.py+++ b/api/events/event_handlers/create_site_record_when_app_created.py@@ -1,27 +1,15 @@from sqlalchemy.orm import Sessionfrom events.app_event import app_was_created-from models.enums import CustomizeTokenStrategy-from models.model import Site+from services.app_creation_records import create_site_record@app_was_created.connectdef handle(sender, *, session: Session, **kwargs) -> None:"""Create site record when an app is created."""+ if kwargs.get("created_records_initialized"):+ returnapp = senderaccount = kwargs.get("account")if account is not None:- site = Site(- app_id=app.id,- title=app.name,- icon_type=app.icon_type,- icon=app.icon,- icon_background=app.icon_background,- default_language=account.interface_language,- customize_token_strategy=CustomizeTokenStrategy.NOT_ALLOW,- code=Site.generate_code(16, session=session),- created_by=app.created_by,- updated_by=app.updated_by,- )- session.add(site)- session.flush()+ create_site_record(app=app, account=account, session=session)diff --git a/api/openapi/markdown/console-openapi.md b/api/openapi/markdown/console-openapi.mdindex 4fcfd3383e4..3cda6c6e435 100644--- a/api/openapi/markdown/console-openapi.md+++ b/api/openapi/markdown/console-openapi.md@@ -1502,7 +1502,7 @@ Create a new application| Required | Schema || -------- | ------ |-| Yes | **application/json**: [AppImportPayload](#appimportpayload)<br> |+| Yes | **application/json**: [AppImportPayload](#appimportpayload)<br>**multipart/form-data**: { **"file"**: binary }<br> | **application/json**: [AppImportPayload](#appimportpayload)<br>**multipart/form-data**: { **"file"**: binary }<br> |#### Responses@@ -1511,6 +1511,9 @@ Create a new application| 200 | Import completed | **application/json**: [Import](#import)<br> || 202 | Import pending confirmation | **application/json**: [Import](#import)<br> || 400 | Import failed | **application/json**: [Import](#import)<br> |+| 403 | Insufficient import or plugin installation permissions | |+| 409 | Agent name conflict or missing plugins | **application/json**: [RosterAgentPackageConflictResponse](#rosteragentpackageconflictresponse)<br> |+| 413 | Roster Agent package exceeds the size limit | |### [GET] /apps/imports/{app_id}/check-dependencies#### Parameters@@ -2670,6 +2673,7 @@ Export application configuration as DSL| Name | Located in | Description | Required | Schema || ---- | ---------- | ----------- | -------- | ------ || app_id | path | Application ID to export | Yes | string (uuid) |+| format | query | Export format; defaults to ifpkg for Agent Apps and yaml for other Apps | No | string, <br>**Available values:** "ifpkg", "yaml" || include_secret | query | Include secrets in export | No | boolean || workflow_id | query | Specific workflow ID to export | No | string |@@ -2677,8 +2681,8 @@ Export application configuration as DSL| Code | Description | Schema || ---- | ----------- | ------ |-| 200 | App exported successfully | **application/json**: [AppExportResponse](#appexportresponse)<br> |-| 403 | Insufficient permissions | |+| 200 | App exported successfully | **application/json**: [AppExportResponse](#appexportresponse)<br>**application/zip**: binary<br> |+| 403 | Insufficient permissions | **application/zip**: binary<br> |### [POST] /apps/{app_id}/feedbacksCreate or update message feedback (like/dislike)@@ -15774,6 +15778,7 @@ This class is used to store the schema information of an api based tool.| Name | Type | Description | Required || ---- | ---- | ----------- | -------- |+| format | string, <br>**Available values:** "ifpkg", "yaml" | Export format; defaults to ifpkg for Agent Apps and yaml for other Apps | No || include_secret | boolean | Include secrets in export | No || workflow_id | string | Specific workflow ID to export | No |@@ -21724,6 +21729,15 @@ Resource types understood by access policies.| ---- | ---- | ----------- | -------- || data | [ [AccessPolicyRoleBinding](#accesspolicyrolebinding) ] | | No |+#### RosterAgentPackageConflictResponse++| Name | Type | Description | Required |+| ---- | ---- | ----------- | -------- |+| code | string | | Yes |+| leaked_dependencies | [ [PluginDependency](#plugindependency) ] | | No |+| message | string | | Yes |+| status | integer, <br>**Default:** 409 | | No |+#### RosterListQuery| Name | Type | Description | Required |diff --git a/api/services/agent/composer_validator.py b/api/services/agent/composer_validator.pyindex ea1ae673b81..5ce4c44db3f 100644--- a/api/services/agent/composer_validator.py+++ b/api/services/agent/composer_validator.py@@ -234,6 +234,14 @@ class ComposerConfigValidator:cls._reject_plaintext_secrets(dumped, path="agent_soul")cls._validate_shell_config(dumped)+ @classmethod+ def validate_importable_agent_soul(cls, agent_soul: AgentSoulConfig) -> None:+ """Validate persisted draft safety without requiring all assets to be publishable."""++ dumped = agent_soul.model_dump(mode="json")+ cls._reject_plaintext_secrets(dumped, path="agent_soul")+ cls._validate_shell_config(dumped)+@staticmethoddef _reject_missing_config_assets(agent_soul: AgentSoulConfig) -> None:missing = [f"skill:{item.name}" for item in agent_soul.config_skills if item.is_missing]diff --git a/api/services/agent/dsl_service.py b/api/services/agent/dsl_service.pyindex 4d56783296c..a03f25ef14d 100644--- a/api/services/agent/dsl_service.py+++ b/api/services/agent/dsl_service.py@@ -198,7 +198,7 @@ class AgentDslService:) -> AgentPackageImportResult:"""Create the imported backing Agent and its editable unpublished draft."""- soul, warnings = self._resolve_package_soul(+ soul, warnings = self.resolve_package_soul(tenant_id=app.tenant_id,package=package,package_path="agent",@@ -483,7 +483,7 @@ class AgentDslService:package: AgentPackage,package_path: str,) -> AgentPackageImportResult:- soul, warnings = self._resolve_package_soul(+ soul, warnings = self.resolve_package_soul(tenant_id=workflow.tenant_id,package=package,package_path=package_path,@@ -561,7 +561,7 @@ class AgentDslService:self.session.flush()return agent, snapshot- def _resolve_package_soul(+ def resolve_package_soul(self,*,tenant_id: str,diff --git a/api/services/agent/errors.py b/api/services/agent/errors.pyindex cda2656c197..9534930b223 100644--- a/api/services/agent/errors.py+++ b/api/services/agent/errors.py@@ -71,6 +71,24 @@ class RosterAgentPackageExportFailedError(BaseHTTPException):code = 500+class RosterAgentPackageImportFailedError(BaseHTTPException):+ error_code = "roster_agent_package_import_failed"+ description = "The Roster Agent package could not be imported."+ code = 500+++class RosterAgentPackageDependenciesMissingError(BaseHTTPException):+ error_code = "roster_agent_package_dependencies_missing"+ description = "Install the missing plugins before importing the Roster Agent package."+ code = 409+++class RosterAgentPackageResourceUnavailableError(BaseHTTPException):+ error_code = "roster_agent_package_resource_unavailable"+ description = "The Roster Agent package resources could not be stored."+ code = 503++class AgentSoulLockedError(BadRequest):description = "Agent Soul is locked for this workflow node."diff --git a/api/services/agent/roster_package_dependencies.py b/api/services/agent/roster_package_dependencies.pynew file mode 100644index 00000000000..a571d224e4b--- /dev/null+++ b/api/services/agent/roster_package_dependencies.py@@ -0,0 +1,40 @@+"""Preflight plugin availability and installation permission for package imports."""++from werkzeug.exceptions import Forbidden++from configs import dify_config+from core.db.session_factory import session_factory+from core.plugin.entities.plugin import PluginDependency+from core.rbac import RBACPermission+from models import Account+from models.account import TenantPluginInstallPermission+from services.agent.errors import RosterAgentPackageDependenciesMissingError+from services.enterprise.rbac_service import RBACService+from services.plugin.dependencies_analysis import DependenciesAnalysisService+from services.plugin.plugin_permission_service import PluginPermissionService+++def check_package_dependencies(*, tenant_id: str, account: Account, dependencies: list[PluginDependency]) -> None:+ if not dependencies:+ return+ missing = DependenciesAnalysisService.get_leaked_dependencies(tenant_id=tenant_id, dependencies=dependencies)+ if not missing:+ return+ if dify_config.RBAC_ENABLED:+ allowed = RBACService.CheckAccess.check(+ tenant_id, account.id, scene=RBACPermission.PLUGIN_INSTALL, resource_type=None, resource_id=None+ )+ if not allowed:+ raise Forbidden("Plugin installation permission is required to import this Agent package")+ else:+ with session_factory.create_session() as session:+ permission = PluginPermissionService.get_permission(tenant_id, session=session)+ install_permission = permission.install_permission if permission is not None else None+ if install_permission == TenantPluginInstallPermission.NOBODY or (+ install_permission == TenantPluginInstallPermission.ADMINS and not account.is_admin_or_owner+ ):+ raise Forbidden("Plugin installation permission is required to import this Agent package")+ error = RosterAgentPackageDependenciesMissingError()+ assert error.data is not None+ error.data["leaked_dependencies"] = [item.model_dump(mode="json") for item in missing]+ raise errordiff --git a/api/services/agent/roster_package_importer.py b/api/services/agent/roster_package_importer.pynew file mode 100644index 00000000000..bdc9bfe7b5b--- /dev/null+++ b/api/services/agent/roster_package_importer.py@@ -0,0 +1,434 @@+"""Materialize validated Roster Agent packages into a new Agent App."""++from __future__ import annotations++import hashlib+import logging+import os+from dataclasses import dataclass+from typing import BinaryIO, Protocol+from uuid import uuid4++from sqlalchemy import select, update+from sqlalchemy.exc import IntegrityError++from configs import dify_config+from constants.model_template import default_app_templates+from core.db.session_factory import session_factory+from extensions.ext_storage import storage+from extensions.storage.storage_type import StorageType+from libs.datetime_utils import naive_utc_now+from models import Account+from models.agent import (+ Agent,+ AgentConfigDraft,+ AgentConfigDraftType,+ AgentConfigRevisionOperation,+ AgentConfigSnapshot,+ AgentScope,+ AgentSource,+ AgentStatus,+)+from models.agent_config_entities import AgentSoulConfig+from models.enums import CreatorUserRole+from models.model import App, AppMode, AppModelConfig, UploadFile+from models.tools import ToolFile+from services.agent.composer_validator import ComposerConfigValidator+from services.agent.dsl_entities import AgentPackage, AgentPackageMetadata, make_portable_agent_soul+from services.agent.dsl_service import AgentDslService+from services.agent.errors import (+ AgentNameConflictError,+ InvalidComposerConfigError,+ InvalidRosterAgentPackageError,+ PlaintextSecretNotAllowedError,+ RosterAgentPackageImportFailedError,+ RosterAgentPackageResourceUnavailableError,+ RosterAgentPackageTooLargeError,+)+from services.agent.roster_package_dependencies import check_package_dependencies+from services.agent.roster_package_entities import PreparedRosterAgentPackage+from services.agent.roster_package_reader import RosterAgentPackageReader+from services.agent.roster_service import AgentRosterService+from services.agent.skill_package_service import SkillPackageError, SkillPackageService+from services.app_creation_records import create_installed_app_record, create_site_record+from services.app_service import AppService+from services.entities.dsl_entities import DslImportWarning+from services.file_service import FileService+from services.icon_configuration import DEFAULT_ICON, DEFAULT_ICON_BACKGROUND, DEFAULT_ICON_TYPE++logger = logging.getLogger(__name__)+++class _Storage(Protocol):+ def save(self, filename: str, data: bytes) -> None: ...+++@dataclass(frozen=True)+class RosterAgentPackageImportResult:+ app_id: str+ agent_id: str+ warnings: list[DslImportWarning]+++class RosterAgentPackageImporter:+ """Commit uploaded file records before creating the Agent in a separate transaction."""++ def __init__(+ self,+ *,+ storage_backend: _Storage = storage,+ ) -> None:+ self._reader = RosterAgentPackageReader()+ self._skill_packages = SkillPackageService()+ self._storage = storage_backend++ def import_package(+ self,+ *,+ source: BinaryIO,+ tenant_id: str,+ account: Account,+ ) -> RosterAgentPackageImportResult:+ with self._reader.read(source) as package:+ if len(package.apps) != 1:+ raise InvalidRosterAgentPackageError("Import requires exactly one Agent App")+ app_dsl = next(iter(package.apps.values()))+ agent_package = app_dsl.package+ agent_package.soul = make_portable_agent_soul(agent_package.soul)+ self._validate_supported_resources(package, soul=agent_package.soul)+ try:+ ComposerConfigValidator.validate_importable_agent_soul(agent_package.soul)+ except (InvalidComposerConfigError, PlaintextSecretNotAllowedError) as exc:+ raise InvalidRosterAgentPackageError("Roster Agent package Soul is invalid") from exc++ check_package_dependencies(tenant_id=tenant_id, account=account, dependencies=app_dsl.dependencies)+ try:+ self._ensure_name_available(tenant_id=tenant_id, name=agent_package.metadata.name)+ soul, skill_warnings = self._upload_resources(+ package=package,+ agent_package=agent_package,+ tenant_id=tenant_id,+ account_id=account.id,+ )+ with session_factory.create_session() as session:+ resolved_soul, warnings = AgentDslService(session).resolve_package_soul(+ tenant_id=tenant_id,+ package=AgentPackage(metadata=agent_package.metadata, soul=soul),+ package_path="agent",+ )+ warnings = [*skill_warnings, *warnings]+ app_id, agent_id = self._persist_import(+ tenant_id=tenant_id,+ account=account,+ metadata=agent_package.metadata,+ soul=resolved_soul,+ )+ except Exception as exc:+ if isinstance(exc, IntegrityError) and "roster_unique_name" in str(exc):+ raise AgentNameConflictError() from exc+ if isinstance(+ exc,+ (+ AgentNameConflictError,+ InvalidRosterAgentPackageError,+ RosterAgentPackageTooLargeError,+ RosterAgentPackageResourceUnavailableError,+ ),+ ):+ raise+ raise RosterAgentPackageImportFailedError() from exc++ try:+ self._finalize_app(app_id=app_id, agent_id=agent_id, tenant_id=tenant_id, account=account)+ except Exception:+ logger.warning(+ "Imported Agent App post-commit initialization failed: tenant_id=%s app_id=%s",+ tenant_id,+ app_id,+ exc_info=True,+ )+ return RosterAgentPackageImportResult(app_id=app_id, agent_id=agent_id, warnings=warnings)++ @classmethod+ def _validate_supported_resources(cls, package: PreparedRosterAgentPackage, *, soul: AgentSoulConfig) -> None:+ skill_names = [item.name for item in soul.config_skills]+ skill_names.extend(item.name for item in package.manifest.skills if item.scope == "workspace")+ if len(skill_names) != len(set(skill_names)):+ raise InvalidRosterAgentPackageError("Roster Agent package contains duplicate effective Skill names")+ file_names = [item.name for item in soul.config_files]+ if len(file_names) != len(set(file_names)):+ raise InvalidRosterAgentPackageError("Roster Agent package contains duplicate config file names")+ file_refs = {item.file_id: item for item in soul.config_files if not item.is_missing}+ for resource in package.manifest.files:+ filename = file_refs[resource.id].name+ extension = cls._extension(filename)+ limit = FileService.file_size_limit(extension=extension)+ if resource.size > limit:+ raise InvalidRosterAgentPackageError(+ f"Roster Agent package file {filename!r} exceeds its file size limit"+ )+ if extension and extension in dify_config.UPLOAD_FILE_EXTENSION_BLACKLIST:+ raise InvalidRosterAgentPackageError(+ f"Roster Agent package file extension '.{extension}' is not allowed"+ )++ @staticmethod+ def _ensure_name_available(*, tenant_id: str, name: str) -> None:+ with session_factory.create_session() as session:+ exists = session.scalar(+ select(Agent.id)+ .where(+ Agent.tenant_id == tenant_id,+ Agent.scope == AgentScope.ROSTER,+ Agent.status == AgentStatus.ACTIVE,+ Agent.name == name,+ )+ .limit(1)+ )+ if exists is not None:+ raise AgentNameConflictError()++ def _upload_resources(+ self,+ *,+ package: PreparedRosterAgentPackage,+ agent_package: AgentPackage,+ tenant_id: str,+ account_id: str,+ ) -> tuple[AgentSoulConfig, list[DslImportWarning]]:+ """Upload outside database transactions, then commit all file records together."""+ files: list[ToolFile | UploadFile] = []+ warnings: list[DslImportWarning] = []+ soul_data = agent_package.soul.model_dump(mode="json")+ skill_refs_by_package_id = {+ item["file_id"]: item for item in soul_data["config_skills"] if not item["is_missing"]+ }+ file_refs_by_package_id = {+ item["file_id"]: item for item in soul_data["config_files"] if not item["is_missing"]+ }++ skill_descriptions = {item.name: item.description for item in agent_package.workspace_skills}+ skill_descriptions.update({item.name: item.description for item in agent_package.soul.config_skills})+ for skill_resource in package.manifest.skills:+ target_ref = skill_refs_by_package_id.get(skill_resource.id)+ if target_ref is None:+ target_ref = {}+ soul_data["config_skills"].append(target_ref)+ target_ref.update(+ {+ "name": skill_resource.name,+ "description": skill_descriptions.get(skill_resource.name, ""),+ "file_kind": "tool_file",+ "file_id": "",+ "is_missing": True,+ "size": skill_resource.size,+ "hash": skill_resource.sha256,+ "mime_type": "application/zip",+ }+ )+ reason = package.invalid_skills.get(skill_resource.id)+ normalized = None+ try:+ if reason is None:+ payload = self._reader.read_member_bytes(+ package,+ skill_resource.path,+ max_bytes=dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024,+ )+ normalized = self._skill_packages.validate_and_normalize(+ content=payload, filename=skill_resource.path+ )+ except SkillPackageError as exc:+ reason = exc.code+ except InvalidRosterAgentPackageError:+ reason = "archive_integrity_failed"+ if normalized is None:+ warnings.append(+ DslImportWarning(+ code="agent_skill_missing",+ path=f"skills.{skill_resource.id}",+ message=f"Skill {skill_resource.name!r} is damaged and must be uploaded again.",+ details={"name": skill_resource.name, "reason": reason, "path": skill_resource.path},+ )+ )+ continue+ storage_key = f"tools/{tenant_id}/{uuid4().hex}.zip"+ tool_file = ToolFile(+ user_id=account_id,+ tenant_id=tenant_id,+ conversation_id=None,+ file_key=storage_key,+ mimetype="application/zip",+ name=f"{skill_resource.name}.zip",+ size=len(normalized.archive_bytes),+ original_url=None,+ )+ self._save_resource(storage_key=storage_key, payload=normalized.archive_bytes, files=files, row=tool_file)+ target_ref.update(+ {+ "description": normalized.manifest.description,+ "file_id": tool_file.id,+ "is_missing": False,+ "size": tool_file.size,+ "hash": normalized.manifest.hash,+ }+ )++ for file_resource in package.manifest.files:+ package_ref = file_refs_by_package_id[file_resource.id]+ file_kind = package_ref["file_kind"]+ mime_type = package_ref["mime_type"] or "application/octet-stream"+ extension = self._extension(package_ref["name"])+ payload = self._reader.read_member_bytes(package, file_resource.path, max_bytes=file_resource.size)+ if file_kind == "tool_file":+ storage_key = f"tools/{tenant_id}/{uuid4().hex}.{extension or 'bin'}"+ row: ToolFile | UploadFile = ToolFile(+ user_id=account_id,+ tenant_id=tenant_id,+ conversation_id=None,+ file_key=storage_key,+ mimetype=mime_type,+ name=package_ref["name"],+ size=len(payload),+ original_url=None,+ )+ hash_value = None+ else:+ storage_key = f"upload_files/{tenant_id}/{uuid4()}.{extension or 'bin'}"+ now = naive_utc_now()+ row = UploadFile(+ tenant_id=tenant_id,+ storage_type=StorageType(dify_config.STORAGE_TYPE),+ key=storage_key,+ name=package_ref["name"],+ size=len(payload),+ extension=extension,+ mime_type=mime_type,+ created_by_role=CreatorUserRole.ACCOUNT,+ created_by=account_id,+ created_at=now,+ used=False,+ hash=hashlib.sha3_256(payload).hexdigest(),+ )+ hash_value = row.hash+ self._save_resource(storage_key=storage_key, payload=payload, files=files, row=row)+ package_ref.update(+ {+ "file_id": row.id,+ "is_missing": False,+ "size": row.size,+ "hash": hash_value,+ "mime_type": mime_type,+ }+ )++ soul = AgentSoulConfig.model_validate(soul_data)+ with session_factory.create_session() as session, session.begin():+ session.add_all(files)+ return soul, warnings++ def _save_resource(+ self,+ *,+ storage_key: str,+ payload: bytes,+ files: list[ToolFile | UploadFile],+ row: ToolFile | UploadFile,+ ) -> None:+ try:+ self._storage.save(storage_key, payload)+ except Exception as exc:+ raise RosterAgentPackageResourceUnavailableError() from exc+ files.append(row)++ @staticmethod+ def _persist_import(+ *,+ tenant_id: str,+ account: Account,+ metadata: AgentPackageMetadata,+ soul: AgentSoulConfig,+ ) -> tuple[str, str]:+ with session_factory.create_session() as session, session.begin():+ app = App(**default_app_templates[AppMode.AGENT]["app"])+ app.id = str(uuid4())+ app.tenant_id = tenant_id+ app.name = metadata.name+ app.description = metadata.description+ app.icon_type = DEFAULT_ICON_TYPE+ app.icon = DEFAULT_ICON+ app.icon_background = DEFAULT_ICON_BACKGROUND+ app.api_rph = 0+ app.api_rpm = 0+ app.max_active_requests = None+ app.created_by = account.id+ app.maintainer = account.id+ app.updated_by = account.id+ session.add(app)++ app_model_config = AppModelConfig(app_id=app.id, created_by=account.id, updated_by=account.id)+ session.add(app_model_config)+ app.app_model_config_id = app_model_config.id++ agent = AgentRosterService(session).create_backing_agent_for_app(+ tenant_id=tenant_id,+ account_id=account.id,+ app_id=app.id,+ name=metadata.name,+ description=metadata.description,+ role=metadata.role,+ source=AgentSource.IMPORTED,+ initial_soul=soul,+ revision_operation=AgentConfigRevisionOperation.IMPORT_PACKAGE,+ )+ snapshot = session.get(AgentConfigSnapshot, agent.active_config_snapshot_id)+ if snapshot is None:+ raise RuntimeError("Imported Agent snapshot was not created")+ session.add(+ AgentConfigDraft(+ tenant_id=tenant_id,+ agent_id=agent.id,+ draft_type=AgentConfigDraftType.DRAFT,+ account_id=None,+ draft_owner_key="",+ base_snapshot_id=snapshot.id,+ home_snapshot_id=snapshot.home_snapshot_id,+ config_snapshot=soul,+ created_by=account.id,+ updated_by=account.id,+ )+ )+ agent.active_config_is_published = False+ upload_file_ids = [+ item.file_id for item in soul.config_files if item.file_kind == "upload_file" and not item.is_missing+ ]+ if upload_file_ids:+ session.execute(+ update(UploadFile)+ .where(UploadFile.tenant_id == tenant_id, UploadFile.id.in_(upload_file_ids))+ .values(used=True, used_by=account.id, used_at=naive_utc_now())+ )+ create_site_record(app=app, account=account, session=session)+ create_installed_app_record(app=app, session=session)+ return app.id, agent.id++ @staticmethod+ def _finalize_app(*, app_id: str, agent_id: str, tenant_id: str, account: Account) -> None:+ with session_factory.create_session() as session:+ app = session.scalar(select(App).where(App.id == app_id, App.tenant_id == tenant_id).limit(1))+ if app is None:+ raise RuntimeError("Imported Agent App is unavailable after commit")+ AppService().finalize_created_app(+ app=app,+ backing_agent_id=agent_id,+ account=account,+ session=session,+ created_records_initialized=True,+ )++ @staticmethod+ def _extension(filename: str) -> str:+ return os.path.splitext(filename)[1].lstrip(".").lower()+++__all__ = ["RosterAgentPackageImportResult", "RosterAgentPackageImporter"]diff --git a/api/services/app_creation_records.py b/api/services/app_creation_records.pynew file mode 100644index 00000000000..f79d42d3d6f--- /dev/null+++ b/api/services/app_creation_records.py@@ -0,0 +1,45 @@+"""Database records required for a newly created App."""++from sqlalchemy import select+from sqlalchemy.orm import Session++from models import Account+from models.enums import CustomizeTokenStrategy+from models.model import App, InstalledApp, Site+++def create_site_record(*, app: App, account: Account, session: Session) -> None:+ site = Site(+ app_id=app.id,+ title=app.name,+ icon_type=app.icon_type,+ icon=app.icon,+ icon_background=app.icon_background,+ default_language=account.interface_language or "en-US",+ customize_token_strategy=CustomizeTokenStrategy.NOT_ALLOW,+ code=Site.generate_code(16, session=session),+ created_by=app.created_by,+ updated_by=app.updated_by,+ )+ session.add(site)+ session.flush()+++def create_installed_app_record(*, app: App, session: Session) -> None:+ installed_app_id = session.scalar(+ select(InstalledApp.id).where(InstalledApp.tenant_id == app.tenant_id, InstalledApp.app_id == app.id).limit(1)+ )+ if installed_app_id:+ return++ session.add(+ InstalledApp(+ tenant_id=app.tenant_id,+ app_id=app.id,+ app_owner_tenant_id=app.tenant_id,+ )+ )+ session.flush()+++__all__ = ["create_installed_app_record", "create_site_record"]diff --git a/api/services/app_service.py b/api/services/app_service.pyindex 4fa63c76f76..859f87c09a7 100644--- a/api/services/app_service.py+++ b/api/services/app_service.py@@ -728,15 +728,40 @@ class AppService:# Preserve the original commit-before-signal ordering for telemetry.session.commit()- app_was_created.send(app, account=account, session=session)+ self.finalize_created_app(+ app=app,+ backing_agent_id=backing_agent.id if backing_agent else None,+ account=account,+ session=session,+ )+ return app++ def finalize_created_app(+ self,+ *,+ app: App,+ backing_agent_id: str | None,+ account: Account,+ session: Session,+ created_records_initialized: bool = False,+ ) -> None:+ """Run post-commit App creation hooks and external access initialization."""++ app_was_created.send(+ app,+ account=account,+ session=session,+ created_records_initialized=created_records_initialized,+ )session.commit()+ app_mode = app.modeinitialize_access = _CREATED_APP_ACCESS_INITIALIZERS.get(app_mode, _initialize_created_app_access)initialize_access(_CreatedApp(- tenant_id=tenant_id,+ tenant_id=app.tenant_id,creator_account_id=account.id,app_id=app.id,- backing_agent_id=backing_agent.id if backing_agent else None,+ backing_agent_id=backing_agent_id,))@@ -747,8 +772,6 @@ class AppService:if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD:BillingService.clean_billing_info_cache(app.tenant_id)- return app-def get_app(self, app: App, *, session: Session) -> App:"""Get Appdiff --git a/api/tests/unit_tests/commands/test_generate_swagger_specs.py b/api/tests/unit_tests/commands/test_generate_swagger_specs.pyindex 855397b7c45..04c94a468f5 100644--- a/api/tests/unit_tests/commands/test_generate_swagger_specs.py+++ b/api/tests/unit_tests/commands/test_generate_swagger_specs.py@@ -687,6 +687,24 @@ def test_generate_specs_include_console_contract_shapes_for_schema_migration(tmpassert file_upload_schema["properties"]["file"]["type"] == "string"assert file_upload_schema["properties"]["source"]["enum"] == ["datasets"]+ package_import = paths["/apps/imports"]["post"]+ assert _request_schema(package_import, "multipart/form-data")["required"] == ["file"]+ assert _request_schema(package_import, "application/json")["$ref"] == "#/components/schemas/AppImportPayload"+ assert "mode" in schemas["AppImportPayload"]["required"]+ conflict = package_import["responses"]["409"]["content"]["application/json"]["schema"]+ assert conflict["$ref"] == "#/components/schemas/RosterAgentPackageConflictResponse"+ assert "leaked_dependencies" in schemas["RosterAgentPackageConflictResponse"]["properties"]+ assert "403" in package_import["responses"]+ export = paths["/apps/{app_id}/export"]["get"]+ assert export["responses"]["200"]["content"]["application/zip"]["schema"] == {"type": "string", "format": "binary"}+ assert export["responses"]["200"]["content"]["application/json"]["schema"]["$ref"] == (+ "#/components/schemas/AppExportResponse"+ )+ export_format = next(param for param in export["parameters"] if param["name"] == "format")+ assert set(export_format["schema"]["enum"]) == {"yaml", "ifpkg"}+ assert export_format["schema"].get("default") is None+ assert "defaults to ifpkg for Agent Apps and yaml for other Apps" in export_format["description"]+api_key_auth_binding_schema = _request_schema(paths["/api-key-auth/data-source/binding"]["post"])assert api_key_auth_binding_schema["$ref"] == "#/components/schemas/ApiKeyAuthBindingPayload"assert schemas["ApiKeyAuthBindingPayload"]["properties"]["credentials"]["$ref"] == (diff --git a/api/tests/unit_tests/controllers/console/app/test_app_import_api.py b/api/tests/unit_tests/controllers/console/app/test_app_import_api.pyindex 96739b27060..c09d24cffcc 100644--- a/api/tests/unit_tests/controllers/console/app/test_app_import_api.py+++ b/api/tests/unit_tests/controllers/console/app/test_app_import_api.py@@ -146,7 +146,7 @@ class TestAppImportApi:sqlite_app_engine: Engine,transaction_events: TransactionEvents,) -> None:- method = unwrap(api.post)+ method = unwrap(api._import_dsl)_install_features(monkeypatch, enabled=False)app_id = _install_persisting_service_result(@@ -172,7 +172,7 @@ class TestAppImportApi:sqlite_app_engine: Engine,transaction_events: TransactionEvents,) -> None:- method = unwrap(api.post)+ method = unwrap(api._import_dsl)_install_features(monkeypatch, enabled=False)app_id = _install_persisting_service_result(@@ -198,7 +198,7 @@ class TestAppImportApi:sqlite_app_engine: Engine,transaction_events: TransactionEvents,) -> None:- method = unwrap(api.post)+ method = unwrap(api._import_dsl)_install_features(monkeypatch, enabled=True)app_id = _install_persisting_service_result(@@ -227,7 +227,7 @@ class TestAppImportApi:sqlite_app_engine: Engine,transaction_events: TransactionEvents,) -> None:- method = _unwrap(api.post)+ method = _unwrap(api._import_dsl)_install_features(monkeypatch, enabled=False)monkeypatch.setattr(@@ -263,7 +263,7 @@ class TestAppImportApi:sqlite_app_engine: Engine,transaction_events: TransactionEvents,) -> None:- method = _unwrap(api.post)+ method = _unwrap(api._import_dsl)_install_features(monkeypatch, enabled=False)monkeypatch.setattr(diff --git a/api/tests/unit_tests/controllers/console/app/test_roster_package_routes.py b/api/tests/unit_tests/controllers/console/app/test_roster_package_routes.pynew file mode 100644index 00000000000..bb8b9c8ab06--- /dev/null+++ b/api/tests/unit_tests/controllers/console/app/test_roster_package_routes.py@@ -0,0 +1,157 @@+import io+from collections.abc import Callable+from inspect import unwrap+from types import SimpleNamespace+from unittest.mock import Mock++import pytest+from flask import Flask+from werkzeug.exceptions import BadRequest, Forbidden++from controllers.console.app import app as app_module+from controllers.console.app import app_import as import_module+from core.rbac import RBACPermission+from models.account import Account, Tenant+from models.model import App, AppMode+from services.agent.errors import InvalidRosterAgentPackageError+from services.agent.roster_package_importer import RosterAgentPackageImportResult+from services.entities.dsl_entities import DslImportWarning+++def _account() -> Account:+ account = Account(name="Importer", email="[email protected]")+ account._current_tenant = Tenant(name="Workspace")+ account._current_tenant.id = "tenant-1"+ return account+++def test_existing_import_route_dispatches_json_without_changing_payload(+ app: Flask, monkeypatch: pytest.MonkeyPatch+) -> None:+ api = import_module.AppImportApi()+ import_dsl = Mock(return_value=({"status": "completed"}, 200))+ monkeypatch.setattr(api, "_import_dsl", import_dsl)+ account = _account()+ with app.test_request_context(+ "/console/api/apps/imports", method="POST", json={"mode": "yaml-content", "yaml_content": "app: {}"}+ ):+ result = unwrap(api.post)(api, account)+ assert result == ({"status": "completed"}, 200)+ assert import_dsl.call_args.args == (+ import_module.AppImportPayload(mode="yaml-content", yaml_content="app: {}"),+ account,+ )++[email protected]("has_warning", [False, True])+def test_existing_import_route_accepts_package_and_preserves_import_response(+ app: Flask, monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None], has_warning: bool+) -> None:+ config_overrides(RBAC_ENABLED=False)+ account = _account()+ warnings = (+ [DslImportWarning(code="agent_skill_missing", path="skills.s_000001", message="Missing Skill")]+ if has_warning+ else []+ )+ import_package = Mock(+ return_value=RosterAgentPackageImportResult(app_id="app-1", agent_id="agent-1", warnings=warnings)+ )+ monkeypatch.setattr(+ import_module, "RosterAgentPackageImporter", lambda: SimpleNamespace(import_package=import_package)+ )+ api = import_module.AppImportApi()+ with app.test_request_context(+ "/console/api/apps/imports", method="POST", data={"file": (io.BytesIO(b"package"), "agent.ifpkg")}+ ):+ data, status = unwrap(api.post)(api, account)+ assert import_package.call_args.kwargs["source"].read() == b"package"+ assert status == 200+ assert data["app_id"] == "app-1"+ assert data["app_mode"] == "agent"+ assert data["status"] == ("completed-with-warnings" if has_warning else "completed")+ assert data["warnings"] == [warning.model_dump(mode="json") for warning in warnings]+ assert data["id"]+ assert import_package.call_args.kwargs["tenant_id"] == "tenant-1"++[email protected]("denied", [RBACPermission.AGENT_CREATE, RBACPermission.AGENT_IMPORT_EXPORT_DSL])+def test_package_import_checks_agent_permissions_before_reading_payload(+ app: Flask, monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None], denied: RBACPermission+) -> None:+ config_overrides(RBAC_ENABLED=True)+ account = _account()+ monkeypatch.setattr("controllers.common.wraps.current_account_with_tenant", lambda: (account, "tenant-1"))+ scenes = []++ def check(*_args, **kwargs: object) -> bool:+ scenes.append(kwargs["scene"])+ return kwargs["scene"] != denied++ monkeypatch.setattr("controllers.common.rbac.checks.RBACService.CheckAccess.check", check)+ importer = Mock()+ monkeypatch.setattr(import_module, "RosterAgentPackageImporter", importer)+ api = import_module.AppImportApi()+ with app.test_request_context(+ "/console/api/apps/imports", method="POST", data={"file": (io.BytesIO(b"package"), "agent.ifpkg")}+ ):+ with pytest.raises(Forbidden):+ unwrap(api.post)(api, account)+ assert denied in scenes+ assert RBACPermission.APP_IMPORT_EXPORT_DSL not in scenes+ importer.assert_not_called()+++def test_package_import_rejects_overwrite(app: Flask, config_overrides: Callable[..., None]) -> None:+ config_overrides(RBAC_ENABLED=False)+ api = import_module.AppImportApi()+ with app.test_request_context(+ "/console/api/apps/imports",+ method="POST",+ data={"app_id": "existing", "file": (io.BytesIO(b"package"), "agent.ifpkg")},+ ):+ with pytest.raises(InvalidRosterAgentPackageError, match="overwriting"):+ unwrap(api.post)(api, _account())++[email protected]("query", [{}, {"format": "ifpkg"}])+def test_existing_export_route_returns_ifpkg_for_agent(+ app: Flask, monkeypatch: pytest.MonkeyPatch, query: dict[str, str]+) -> None:+ model = App(id="app-1", tenant_id="tenant-1", mode=AppMode.AGENT)+ monkeypatch.setattr(App, "bound_agent_id_with_session", lambda _self, **_kwargs: "agent-1")+ monkeypatch.setattr(app_module, "db", SimpleNamespace(session=lambda: object()))+ archive = io.BytesIO(b"package")+ close = Mock()+ export = Mock(return_value=SimpleNamespace(archive=archive, filename="agent.ifpkg", close=close))+ monkeypatch.setattr(app_module, "RosterAgentPackageExporter", lambda: SimpleNamespace(export=export))+ with app.test_request_context("/console/api/apps/app-1/export", query_string=query):+ response = unwrap(app_module.AppExportApi.get)(+ app_module.AppExportApi(), app_module.AppExportQuery.model_validate(query), model+ )+ response.direct_passthrough = False+ assert response.get_data() == b"package"+ assert response.mimetype == "application/zip"+ assert "agent.ifpkg" in response.headers["Content-Disposition"]+ response.close()+ export.assert_called_once_with(tenant_id="tenant-1", agent_id="agent-1")+ close.assert_called_once_with()+++def test_ifpkg_export_rejects_non_agent_apps() -> None:+ model = App(id="app-1", tenant_id="tenant-1", mode=AppMode.WORKFLOW)+ with pytest.raises(BadRequest):+ unwrap(app_module.AppExportApi.get)(app_module.AppExportApi(), app_module.AppExportQuery(format="ifpkg"), model)+++ ("mode", "query"),+ [(AppMode.AGENT, {"format": "yaml"}), (AppMode.WORKFLOW, {}), (AppMode.WORKFLOW, {"format": "yaml"})],+)+def test_yaml_export_remains_available(monkeypatch: pytest.MonkeyPatch, mode: AppMode, query: dict[str, str]) -> None:+ model = App(id="app-1", tenant_id="tenant-1", mode=mode)+ monkeypatch.setattr(app_module, "db", SimpleNamespace(session=lambda: object()))+ monkeypatch.setattr(app_module.AppDslService, "export_dsl", lambda **_kwargs: "app: {}")+ assert unwrap(app_module.AppExportApi.get)(+ app_module.AppExportApi(), app_module.AppExportQuery.model_validate(query), model+ ) == {"data": "app: {}"}diff --git a/api/tests/unit_tests/events/test_app_event_signals.py b/api/tests/unit_tests/events/test_app_event_signals.pyindex cde404407a2..f0ce7014b50 100644--- a/api/tests/unit_tests/events/test_app_event_signals.py+++ b/api/tests/unit_tests/events/test_app_event_signals.py@@ -11,7 +11,7 @@ from events.app_event import app_was_deleted, app_was_updatedfrom models.account import Accountfrom models.agent import Agent, AgentWorkspacefrom models.dataset import AppDatasetJoin-from models.model import App, AppMode, AppModelConfig, IconType, InstalledApp+from models.model import App, AppMode, AppModelConfig, IconType, InstalledApp, Sitefrom services.app_service import AppService@@ -270,6 +270,13 @@ class TestAppModelConfigWasUpdatedSignal:@pytest.mark.parametrize("sqlite_session", [(App, Account, InstalledApp)], indirect=True)class TestCreateInstalledAppWhenAppCreated:+ def test_skips_when_records_were_initialized_transactionally(self, app_model: App, sqlite_session: Session) -> None:+ from events.event_handlers.create_installed_app_when_app_created import handle++ handle(app_model, session=sqlite_session, created_records_initialized=True)++ assert sqlite_session.scalar(select(InstalledApp.id).where(InstalledApp.app_id == app_model.id)) is None+def test_skips_existing_installation(self, app_model: App, sqlite_session: Session) -> None:from events.event_handlers.create_installed_app_when_app_created import handle@@ -324,3 +331,19 @@ class TestCreateInstalledAppWhenAppCreated:assert installed_app.app_id == app_model.idassert installed_app.tenant_id == app_model.tenant_idassert commits == []++[email protected]("sqlite_session", [(App, Account, Site)], indirect=True)+def test_create_site_handler_skips_transactionally_initialized_records(+ app_model: App, account: Account, sqlite_session: Session+) -> None:+ from events.event_handlers.create_site_record_when_app_created import handle++ handle(+ app_model,+ account=account,+ session=sqlite_session,+ created_records_initialized=True,+ )++ assert sqlite_session.scalar(select(Site.id).where(Site.app_id == app_model.id)) is Nonediff --git a/api/tests/unit_tests/services/agent/test_agent_dsl_service.py b/api/tests/unit_tests/services/agent/test_agent_dsl_service.pyindex 76f0f93e497..085221a2f9a 100644--- a/api/tests/unit_tests/services/agent/test_agent_dsl_service.py+++ b/api/tests/unit_tests/services/agent/test_agent_dsl_service.py@@ -288,7 +288,7 @@ def test_import_warnings_cover_runtime_setup_removed_from_package()monkeypatch.setattr("services.agent.dsl_service.get_tenant_knowledge_dataset_rows", Mock(return_value={}))- _, warnings = AgentDslService(unbound_session)._resolve_package_soul(+ _, warnings = AgentDslService(unbound_session).resolve_package_soul(tenant_id="tenant-1",package=make_portable_agent_package(_agent(), soul),package_path="agent_packages.agent_1",@@ -414,7 +414,7 @@ def test_import_agent_app_package_creates_config_and_unpublished_draft(service = AgentDslService(sqlite_session)soul = AgentSoulConfig(config_note="portable")warning = DslImportWarning(code="setup", path="agent.soul", message="setup required")- service._resolve_package_soul = Mock(return_value=(soul, [warning]))+ service.resolve_package_soul = Mock(return_value=(soul, [warning]))service._unique_roster_name = Mock(return_value="Portable Agent import")agent = _agent()agent.active_config_snapshot_id = "snapshot-1"@@ -778,7 +778,7 @@ def test_create_imported_inline_agent_uses_import_provenance(unbound_session: Seservice = AgentDslService(unbound_session)soul = AgentSoulConfig(config_note="inline")warning = DslImportWarning(code="setup", path="agent", message="setup")- service._resolve_package_soul = Mock(return_value=(soul, [warning]))+ service.resolve_package_soul = Mock(return_value=(soul, [warning]))service._create_workflow_only_agent = Mock(return_value=(_agent(), _snapshot(soul=soul)))workflow = _workflow()@@ -865,7 +865,7 @@ def test_resolve_package_soul_preserves_existing_and_marks_missing_knowledge(get_dataset_rows = Mock(return_value={"existing": existing_dataset})monkeypatch.setattr("services.agent.dsl_service.get_tenant_knowledge_dataset_rows", get_dataset_rows)- resolved, warnings = AgentDslService(sqlite_session)._resolve_package_soul(+ resolved, warnings = AgentDslService(sqlite_session).resolve_package_soul(tenant_id="tenant-1",package=make_portable_agent_package(_agent(), soul),package_path="agent_packages.agent_1",diff --git a/api/tests/unit_tests/services/agent/test_roster_package_importer.py b/api/tests/unit_tests/services/agent/test_roster_package_importer.pynew file mode 100644index 00000000000..2e8ee8f4324--- /dev/null+++ b/api/tests/unit_tests/services/agent/test_roster_package_importer.py@@ -0,0 +1,817 @@+from __future__ import annotations++import hashlib+import io+import json+import zipfile+from collections.abc import Callable, Generator++import pytest+import yaml+from sqlalchemy import event, func, select+from sqlalchemy.exc import IntegrityError+from sqlalchemy.orm import Session, sessionmaker+from werkzeug.exceptions import Forbidden++from core.db.session_factory import session_factory+from core.plugin.entities.plugin import PluginDependency, PluginDependencyType+from models import Account+from models.account import TenantPluginDebugPermission, TenantPluginInstallPermission, TenantPluginPermission+from models.agent import (+ Agent,+ AgentConfigDraft,+ AgentConfigRevision,+ AgentConfigRevisionOperation,+ AgentConfigSnapshot,+ AgentDebugConversation,+ AgentKind,+ AgentScope,+ AgentSource,+ AgentStatus,+)+from models.agent_config_entities import AgentSoulConfig+from models.base import Base, TypeBase+from models.model import App, AppModelConfig, InstalledApp, Site, UploadFile+from models.tools import ToolFile+from services.agent.dsl_entities import (+ AgentPackage,+ AgentPackageMetadata,+ AgentPackageWorkspaceSkill,+ make_agent_app_dsl,+)+from services.agent.errors import (+ AgentNameConflictError,+ InvalidRosterAgentPackageError,+ RosterAgentPackageDependenciesMissingError,+ RosterAgentPackageImportFailedError,+ RosterAgentPackageResourceUnavailableError,+ RosterAgentPackageTooLargeError,+)+from services.agent.roster_package_entities import (+ ROSTER_AGENT_PACKAGE_FORMAT,+ ROSTER_AGENT_PACKAGE_FORMAT_VERSION,+ RosterAgentPackageApp,+ RosterAgentPackageFile,+ RosterAgentPackageManifest,+ RosterAgentPackageSkill,+)+from services.agent.roster_package_importer import RosterAgentPackageImporter+from services.app_service import AppService+from services.file_service import FileService+from services.plugin.dependencies_analysis import DependenciesAnalysisService+++class _MemoryStorage:+ def __init__(self, *, fail_save_at: int | None = None) -> None:+ self.files: dict[str, bytes] = {}+ self.deleted: list[str] = []+ self.save_count = 0+ self.fail_save_at = fail_save_at++ def save(self, filename: str, data: bytes) -> None:+ self.save_count += 1+ if self.fail_save_at == self.save_count:+ raise OSError("storage unavailable")+ self.files[filename] = data++ def delete(self, filename: str) -> None:+ self.deleted.append(filename)+ self.files.pop(filename, None)++ def load_stream(self, filename: str) -> Generator[bytes, None, None]:+ yield self.files[filename]++[email protected](autouse=True)+def _installed_plugins(monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setattr(DependenciesAnalysisService, "get_leaked_dependencies", lambda **_kwargs: [])+++def _account() -> Account:+ account = Account(+ name="Agent Importer",+ email="[email protected]",+ interface_language="en-US",+ )+ account.id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"+ return account+++def _zip(members: dict[str, bytes]) -> bytes:+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_STORED) as archive:+ for path, payload in members.items():+ archive.writestr(path, payload)+ return output.getvalue()+++def _skill_archive(name: str) -> bytes:+ return _zip(+ {+ "SKILL.md": f"---\nname: {name}\ndescription: {name} description.\n---\n\n# Skill\n".encode(),+ "scripts/run.py": b"print('ok')\n",+ }+ )+++def _package(+ *,+ name: str = "Imported Agent",+ binary_dependency: bool = False,+ missing_knowledge: bool = False,+) -> bytes:+ config_skill = _skill_archive("config-skill")+ workspace_skill = _skill_archive("workspace-skill")+ guide = b"guide-content"+ notes = b"notes-content"+ soul_data: dict[str, object] = {+ "prompt": {"system_prompt": "Imported prompt"},+ "config_skills": [{"name": "config-skill", "file_id": "s_000001"}],+ "config_files": [+ {"name": "guide.pdf", "file_kind": "upload_file", "file_id": "f_000001"},+ {"name": "notes.txt", "file_kind": "tool_file", "file_id": "f_000002"},+ ],+ }+ if missing_knowledge:+ soul_data["knowledge"] = {+ "sets": [+ {+ "id": "set-1",+ "name": "Documents",+ "datasets": [{"id": "missing-dataset-id", "name": "Missing Docs"}],+ "query": {"mode": "user_query", "value": "query"},+ "retrieval": {+ "mode": "single",+ "model": {"provider": "provider/embedding", "name": "embed", "mode": "embedding"},+ },+ }+ ]+ }+ soul = AgentSoulConfig.model_validate(soul_data)+ files = [+ RosterAgentPackageFile(+ id="f_000001",+ path="f_000001.pdf",+ size=len(guide),+ sha256=hashlib.sha256(guide).hexdigest(),+ ),+ RosterAgentPackageFile(+ id="f_000002",+ path="f_000002.txt",+ size=len(notes),+ sha256=hashlib.sha256(notes).hexdigest(),+ ),+ ]+ members = {+ "s_000001.zip": config_skill,+ "s_000002.zip": workspace_skill,+ "f_000001.pdf": guide,+ "f_000002.txt": notes,+ }+ dependency = PluginDependency(+ type=PluginDependencyType.Marketplace,+ value=PluginDependency.Marketplace(marketplace_plugin_unique_identifier="langgenius/example:1.0.0@digest"),+ )+ app = make_agent_app_dsl(+ App(name=name, mode="agent"),+ package_ref="agent_1",+ packages={+ "agent_1": AgentPackage(+ metadata=AgentPackageMetadata(name=name, description="Imported description", role="researcher"),+ soul=soul,+ workspace_skills=[+ AgentPackageWorkspaceSkill(+ name="workspace-skill",+ display_name="Workspace Skill",+ description="workspace-skill description.",+ priority=0,+ )+ ],+ )+ },+ dependencies=[dependency],+ )+ app_bytes = yaml.safe_dump(app.model_dump(mode="json")).encode()+ manifest = RosterAgentPackageManifest(+ format=ROSTER_AGENT_PACKAGE_FORMAT,+ format_version=ROSTER_AGENT_PACKAGE_FORMAT_VERSION,+ apps=[+ RosterAgentPackageApp(path="app.yaml", size=len(app_bytes), sha256=hashlib.sha256(app_bytes).hexdigest())+ ],+ skills=[+ RosterAgentPackageSkill(+ id="s_000001",+ scope="agent_config",+ name="config-skill",+ path="s_000001.zip",+ size=len(config_skill),+ sha256=hashlib.sha256(config_skill).hexdigest(),+ ),+ RosterAgentPackageSkill(+ id="s_000002",+ scope="workspace",+ name="workspace-skill",+ path="s_000002.zip",+ size=len(workspace_skill),+ sha256=hashlib.sha256(workspace_skill).hexdigest(),+ ),+ ],+ files=files,+ )+ manifest_data = manifest.model_dump(mode="json", exclude_none=True)+ if binary_dependency:+ manifest_data["files"][0]["role"] = "binary_dependency"+ return _zip({"manifest.yaml": yaml.safe_dump(manifest_data).encode(), "app.yaml": app_bytes, **members})+++def _count(session: Session, model: type[Base | TypeBase]) -> int:+ return session.scalar(select(func.count()).select_from(model)) or 0++[email protected]("skill_index", [0, 1], ids=["uploaded", "workspace"])+ "damage", ["invalid_zip", "missing_skill_md", "member_crc", "checksum", "size", "name_mismatch"]+)+def test_damaged_skill_becomes_missing_with_warning(+ monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session], skill_index: int, damage: str+) -> None:+ with zipfile.ZipFile(io.BytesIO(_package())) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ manifest = yaml.safe_load(members["manifest.yaml"])+ skill = manifest["skills"][skill_index]+ path = skill["path"]+ if damage == "invalid_zip":+ members[path] = b"not a zip archive"+ elif damage == "missing_skill_md":+ members[path] = _zip({"README.md": b"no entrypoint"})+ elif damage == "member_crc":+ members[path] = members[path].replace(b"print('ok')", b"print('NO')", 1)+ elif damage == "name_mismatch":+ members[path] = _skill_archive("different-name")+ skill["size"] = len(members[path]) + (1 if damage == "size" else 0)+ skill["sha256"] = "0" * 64 if damage == "checksum" else hashlib.sha256(members[path]).hexdigest()+ members["manifest.yaml"] = yaml.safe_dump(manifest).encode()+ storage = _MemoryStorage()+ monkeypatch.setattr(AppService, "finalize_created_app", lambda *_args, **_kwargs: None)+ result = RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_zip(members)), tenant_id="tenant-1", account=_account()+ )+ assert len(result.warnings) == 1+ warning = result.warnings[0]+ assert warning.code == "agent_skill_missing"+ assert warning.details["name"] == skill["name"]+ assert warning.details["path"] == path+ assert warning.details["reason"]+ assert storage.save_count == 3+ with sqlite_session_factory() as session:+ draft = session.scalar(select(AgentConfigDraft).where(AgentConfigDraft.agent_id == result.agent_id))+ assert draft is not None+ soul = AgentSoulConfig.model_validate(draft.config_snapshot_dict)+ damaged = soul.config_skills[skill_index]+ assert damaged.name == skill["name"]+ assert damaged.is_missing is True+ assert damaged.file_id == ""+ assert soul.config_skills[1 - skill_index].is_missing is False+ assert all(not ref.is_missing for ref in soul.config_files)+ assert _count(session, ToolFile) == 2+++def test_damaged_ordinary_file_still_rejects_package() -> None:+ with zipfile.ZipFile(io.BytesIO(_package())) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ members["f_000001.pdf"] = b"damaged"+ storage = _MemoryStorage()+ with pytest.raises(InvalidRosterAgentPackageError):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_zip(members)), tenant_id="tenant-1", account=_account()+ )+ assert storage.save_count == 0+++def test_import_rejects_multiple_apps_before_writes() -> None:+ with zipfile.ZipFile(io.BytesIO(_package())) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ manifest = yaml.safe_load(members["manifest.yaml"])+ members["second.yaml"] = members["app.yaml"]+ manifest["apps"].append({**manifest["apps"][0], "path": "second.yaml"})+ members["manifest.yaml"] = yaml.safe_dump(manifest).encode()+ storage = _MemoryStorage()+ with pytest.raises(InvalidRosterAgentPackageError, match="exactly one Agent App"):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_zip(members)), tenant_id="tenant-1", account=_account()+ )+ assert storage.save_count == 0+++def test_import_uses_indexed_app_path(+ monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]+) -> None:+ with zipfile.ZipFile(io.BytesIO(_package())) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ manifest = yaml.safe_load(members["manifest.yaml"])+ members["custom.yml"] = members.pop("app.yaml")+ manifest["apps"][0]["path"] = "custom.yml"+ members["manifest.yaml"] = yaml.safe_dump(manifest).encode()+ monkeypatch.setattr(AppService, "finalize_created_app", lambda *_args, **_kwargs: None)+ result = RosterAgentPackageImporter(storage_backend=_MemoryStorage()).import_package(+ source=io.BytesIO(_zip(members)), tenant_id="tenant-1", account=_account()+ )+ with sqlite_session_factory() as session:+ app = session.get(App, result.app_id)+ assert app is not None+ assert app.name == "Imported Agent"++[email protected]("use_zip64", [False, True])+def test_invalid_utf8_skill_filename_is_recovered(+ monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session], use_zip64: bool+) -> None:+ with zipfile.ZipFile(io.BytesIO(_package())) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ with monkeypatch.context() as scoped:+ if use_zip64:+ scoped.setattr(zipfile, "ZIP64_LIMIT", 0)+ skill = _zip(+ {+ "SKILL.md": b"---\nname: config-skill\ndescription: Recoverable skill.\n---\n",+ "scripts/\u00e9.py": b"print('ok')\n",+ }+ ).replace(b"\xc3\xa9.py", b"\xffa.py")+ members["s_000001.zip"] = skill+ manifest = yaml.safe_load(members["manifest.yaml"])+ manifest["skills"][0]["size"] = len(skill)+ manifest["skills"][0]["sha256"] = hashlib.sha256(skill).hexdigest()+ members["manifest.yaml"] = yaml.safe_dump(manifest).encode()+ storage = _MemoryStorage()+ monkeypatch.setattr(AppService, "finalize_created_app", lambda *_args, **_kwargs: None)+ result = RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_zip(members)), tenant_id="tenant-1", account=_account()+ )+ assert result.warnings == []+ with sqlite_session_factory() as session:+ draft = session.scalar(select(AgentConfigDraft).where(AgentConfigDraft.agent_id == result.agent_id))+ assert draft is not None+ soul = AgentSoulConfig.model_validate(draft.config_snapshot_dict)+ assert soul.config_skills[0].is_missing is False+ tool_file = session.get(ToolFile, soul.config_skills[0].file_id)+ assert tool_file is not None+ with zipfile.ZipFile(io.BytesIO(storage.files[tool_file.file_key])) as archive:+ assert archive.read("scripts/\ufffda.py") == b"print('ok')\n"++[email protected]("names", [["INVALID-NAME"], ["TOKEN", "TOKEN"]])+def test_import_rejects_invalid_shell_environment_before_writes(+ monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session], names: list[str]+) -> None:+ with zipfile.ZipFile(io.BytesIO(_package())) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ app = yaml.safe_load(members["app.yaml"])+ app["agent_packages"]["agent_1"]["soul"]["env"]["variables"] = [{"name": name, "value": "value"} for name in names]+ members["app.yaml"] = yaml.safe_dump(app).encode()+ manifest = yaml.safe_load(members["manifest.yaml"])+ manifest["apps"][0].update(size=len(members["app.yaml"]), sha256=hashlib.sha256(members["app.yaml"]).hexdigest())+ members["manifest.yaml"] = yaml.safe_dump(manifest).encode()+ monkeypatch.setattr(AppService, "finalize_created_app", lambda *_args, **_kwargs: None)+ storage = _MemoryStorage()+ with pytest.raises(InvalidRosterAgentPackageError, match="Soul is invalid"):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_zip(members)), tenant_id="tenant-1", account=_account()+ )+ assert storage.save_count == 0+ with sqlite_session_factory() as session:+ assert _count(session, App) == 0+++def test_import_clears_source_credentials(+ monkeypatch: pytest.MonkeyPatch, sqlite_session_factory: sessionmaker[Session]+) -> None:+ with zipfile.ZipFile(io.BytesIO(_package())) as archive:+ members = {name: archive.read(name) for name in archive.namelist()}+ app = yaml.safe_load(members["app.yaml"])+ soul = app["agent_packages"]["agent_1"]["soul"]+ soul["tools"]["dify_tools"] = [+ {+ "provider_id": "langgenius/example/example",+ "provider_type": "plugin",+ "credential_type": "api-key",+ "credential_ref": {"type": "tool", "id": "source-credential"},+ "runtime_parameters": {"api_key": "source-secret", "query": "keep"},+ }+ ]+ soul["model"] = {+ "plugin_id": "langgenius/example",+ "model_provider": "langgenius/example/example",+ "model": "example",+ "credential_ref": {"type": "provider", "id": "source-model"},+ }+ soul["env"]["secret_refs"] = [{"name": "TOKEN", "value": "source-secret", "id": "source-id"}]+ members["app.yaml"] = yaml.safe_dump(app).encode()+ manifest = yaml.safe_load(members["manifest.yaml"])+ manifest["apps"][0].update(size=len(members["app.yaml"]), sha256=hashlib.sha256(members["app.yaml"]).hexdigest())+ members["manifest.yaml"] = yaml.safe_dump(manifest).encode()+ monkeypatch.setattr(AppService, "finalize_created_app", lambda *_a, **_k: None)+ result = RosterAgentPackageImporter(storage_backend=_MemoryStorage()).import_package(+ source=io.BytesIO(_zip(members)), tenant_id="tenant-1", account=_account()+ )+ with sqlite_session_factory() as session:+ draft = session.scalar(select(AgentConfigDraft).where(AgentConfigDraft.agent_id == result.agent_id))+ assert draft is not None+ data = draft.config_snapshot_dict+ tool = data["tools"]["dify_tools"][0]+ assert tool["credential_type"] == "unauthorized"+ assert tool["credential_ref"] is None+ assert tool["runtime_parameters"] == {"api_key": None, "query": "keep"}+ assert data["model"]["credential_ref"] is None+ assert "source-secret" not in json.dumps(data)+ assert "source-id" not in json.dumps(data)++[email protected]("allowed", [False, True])+def test_missing_plugins_are_checked_before_writes(+ monkeypatch: pytest.MonkeyPatch, config_overrides: Callable[..., None], allowed: bool+) -> None:+ config_overrides(RBAC_ENABLED=True)+ monkeypatch.setattr(DependenciesAnalysisService, "get_leaked_dependencies", lambda **kwargs: kwargs["dependencies"])+ monkeypatch.setattr(+ "services.agent.roster_package_dependencies.RBACService.CheckAccess.check", lambda *_args, **_kwargs: allowed+ )+ storage = _MemoryStorage()+ with pytest.raises(RosterAgentPackageDependenciesMissingError if allowed else Forbidden) as failure:+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()), tenant_id="tenant-1", account=_account()+ )+ assert storage.save_count == 0+ if allowed:+ assert isinstance(failure.value, RosterAgentPackageDependenciesMissingError)+ assert failure.value.data is not None+ assert len(failure.value.data["leaked_dependencies"]) == 1+++def test_empty_dependencies_do_not_require_plugin_service(monkeypatch: pytest.MonkeyPatch) -> None:+ from services.agent.roster_package_dependencies import check_package_dependencies++ def unavailable(**_kwargs) -> None:+ raise OSError("plugin service unavailable")++ monkeypatch.setattr(DependenciesAnalysisService, "get_leaked_dependencies", unavailable)+ check_package_dependencies(tenant_id="tenant-1", account=_account(), dependencies=[])++[email protected]("policy", [TenantPluginInstallPermission.NOBODY, TenantPluginInstallPermission.ADMINS])+def test_missing_plugins_respect_workspace_install_policy(+ monkeypatch: pytest.MonkeyPatch,+ config_overrides: Callable[..., None],+ sqlite_session_factory: sessionmaker[Session],+ policy: TenantPluginInstallPermission,+) -> None:+ config_overrides(RBAC_ENABLED=False)+ with sqlite_session_factory() as session, session.begin():+ session.add(+ TenantPluginPermission(+ tenant_id="tenant-1", install_permission=policy, debug_permission=TenantPluginDebugPermission.NOBODY+ )+ )+ monkeypatch.setattr(DependenciesAnalysisService, "get_leaked_dependencies", lambda **kwargs: kwargs["dependencies"])+ storage = _MemoryStorage()+ with pytest.raises(Forbidden):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()), tenant_id="tenant-1", account=_account()+ )+ assert storage.save_count == 0+++def test_import_materializes_agent_resources_and_unpublished_draft(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ storage = _MemoryStorage()+ monkeypatch.setattr("services.app_service.initialize_agent_rbac_access", lambda **_kwargs: None)+ monkeypatch.setattr("services.app_service.SystemFeatureService.is_webapp_auth_enabled", lambda: False)++ result = RosterAgentPackageImporter(+ storage_backend=storage,+ ).import_package(+ source=io.BytesIO(_package()),+ tenant_id="tenant-1",+ account=_account(),+ )++ assert result.warnings == []+ assert len(storage.files) == 4+ with sqlite_session_factory() as session:+ app = session.get(App, result.app_id)+ agent = session.get(Agent, result.agent_id)+ assert app is not None+ assert app.name == "Imported Agent"+ assert app.mode == "agent"+ assert app.enable_site is False+ assert app.enable_api is False+ model_config = session.get(AppModelConfig, app.app_model_config_id)+ assert model_config is not None+ assert model_config.app_id == app.id+ assert agent is not None+ assert agent.source == AgentSource.IMPORTED+ assert agent.scope == AgentScope.ROSTER+ assert agent.active_config_is_published is False+ draft = session.scalar(select(AgentConfigDraft).where(AgentConfigDraft.agent_id == agent.id))+ assert draft is not None+ soul = AgentSoulConfig.model_validate(draft.config_snapshot_dict)+ assert [item.name for item in soul.config_skills] == ["config-skill", "workspace-skill"]+ assert all(item.file_id and not item.is_missing for item in soul.config_skills)+ assert [(item.name, item.file_kind) for item in soul.config_files] == [+ ("guide.pdf", "upload_file"),+ ("notes.txt", "tool_file"),+ ]+ assert all(item.file_id and not item.is_missing for item in soul.config_files)+ revision = session.scalar(select(AgentConfigRevision).where(AgentConfigRevision.agent_id == agent.id))+ assert revision is not None+ assert revision.operation == AgentConfigRevisionOperation.IMPORT_PACKAGE+ assert _count(session, ToolFile) == 3+ assert _count(session, UploadFile) == 1+ assert _count(session, Site) == 1+ assert _count(session, InstalledApp) == 1+ assert _count(session, AgentDebugConversation) == 1+++def test_import_rejects_binary_dependencies_before_side_effects(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ storage = _MemoryStorage()+ importer = RosterAgentPackageImporter(storage_backend=storage)++ with pytest.raises(InvalidRosterAgentPackageError, match="manifest is invalid"):+ importer.import_package(+ source=io.BytesIO(_package(binary_dependency=True)),+ tenant_id="tenant-1",+ account=_account(),+ )++ assert storage.files == {}+ with sqlite_session_factory() as session:+ assert _count(session, App) == 0+++def test_import_marks_unavailable_knowledge_for_rebinding(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ storage = _MemoryStorage()+ monkeypatch.setattr(AppService, "finalize_created_app", lambda *_args, **_kwargs: None)++ result = RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package(missing_knowledge=True)),+ tenant_id="tenant-1",+ account=_account(),+ )++ assert [warning.code for warning in result.warnings] == ["agent_knowledge_unresolved"]+ with sqlite_session_factory() as session:+ draft = session.scalar(select(AgentConfigDraft).where(AgentConfigDraft.agent_id == result.agent_id))+ assert draft is not None+ soul = AgentSoulConfig.model_validate(draft.config_snapshot_dict)+ dataset_id = soul.knowledge.sets[0].datasets[0].id+ assert dataset_id is not None+ assert dataset_id.startswith("missing-dataset-")+ assert dataset_id != "missing-dataset-id"+++def test_import_validates_all_file_limits_before_staging(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ storage = _MemoryStorage()+ monkeypatch.setattr(FileService, "file_size_limit", lambda **_kwargs: 1)++ with pytest.raises(InvalidRosterAgentPackageError, match="file size limit"):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()),+ tenant_id="tenant-1",+ account=_account(),+ )++ assert storage.files == {}+++def test_import_rejects_duplicate_agent_name_before_staging(+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ with sqlite_session_factory() as session, session.begin():+ session.add(+ Agent(+ tenant_id="tenant-1",+ name="Imported Agent",+ description="",+ role="",+ agent_kind=AgentKind.DIFY_AGENT,+ scope=AgentScope.ROSTER,+ source=AgentSource.AGENT_APP,+ status=AgentStatus.ACTIVE,+ created_by=_account().id,+ updated_by=_account().id,+ )+ )+ storage = _MemoryStorage()++ with pytest.raises(AgentNameConflictError):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()),+ tenant_id="tenant-1",+ account=_account(),+ )++ assert storage.files == {}++[email protected]("fail_after_write", [False, True])+def test_import_does_not_create_records_when_storage_fails(+ sqlite_session_factory: sessionmaker[Session],+ monkeypatch: pytest.MonkeyPatch,+ fail_after_write: bool,+) -> None:+ storage = _MemoryStorage(fail_save_at=None if fail_after_write else 2)+ if fail_after_write:+ save = storage.save++ def save_then_fail(filename: str, data: bytes) -> None:+ save(filename, data)+ if storage.save_count == 2:+ raise OSError("storage write completed but acknowledgement failed")++ monkeypatch.setattr(storage, "save", save_then_fail)++ with pytest.raises(RosterAgentPackageResourceUnavailableError):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()),+ tenant_id="tenant-1",+ account=_account(),+ )++ assert len(storage.files) == (2 if fail_after_write else 1)+ assert storage.deleted == []+ with sqlite_session_factory() as session:+ assert _count(session, App) == 0+ assert _count(session, ToolFile) == 0+++ ("failure", "expected"),+ [+ (AgentNameConflictError(), AgentNameConflictError),+ (InvalidRosterAgentPackageError(), InvalidRosterAgentPackageError),+ (RosterAgentPackageTooLargeError(), RosterAgentPackageTooLargeError),+ (RosterAgentPackageResourceUnavailableError(), RosterAgentPackageResourceUnavailableError),+ (IntegrityError("insert", {}, RuntimeError("roster_unique_name")), AgentNameConflictError),+ (IntegrityError("insert", {}, RuntimeError("other constraint")), RosterAgentPackageImportFailedError),+ (RuntimeError("unexpected failure"), RosterAgentPackageImportFailedError),+ ],+)+def test_import_preserves_error_mapping(+ monkeypatch: pytest.MonkeyPatch, failure: Exception, expected: type[Exception]+) -> None:+ importer = RosterAgentPackageImporter(storage_backend=_MemoryStorage())++ def fail(**_kwargs) -> None:+ raise failure++ monkeypatch.setattr(importer, "_ensure_name_available", fail)+ with pytest.raises(expected) as caught:+ importer.import_package(source=io.BytesIO(_package()), tenant_id="tenant-1", account=_account())+ if isinstance(failure, expected):+ assert caught.value is failure+ else:+ assert caught.value.__cause__ is failure+++def test_import_preserves_file_records_when_agent_creation_fails(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ storage = _MemoryStorage()+ monkeypatch.setattr(+ RosterAgentPackageImporter,+ "_persist_import",+ lambda **_kwargs: (_ for _ in ()).throw(RuntimeError("database unavailable")),+ )++ with pytest.raises(RosterAgentPackageImportFailedError):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()),+ tenant_id="tenant-1",+ account=_account(),+ )++ assert len(storage.files) == 4+ assert storage.deleted == []+ with sqlite_session_factory() as session:+ assert _count(session, App) == 0+ assert _count(session, ToolFile) == 3+ assert _count(session, UploadFile) == 1+ uploaded = session.scalar(select(UploadFile))+ assert uploaded is not None+ assert uploaded.used is False++[email protected]("failed_phase", ["files", "agent"])+def test_import_rolls_back_only_the_failed_transaction(+ sqlite_session_factory: sessionmaker[Session], failed_phase: str+) -> None:+ storage = _MemoryStorage()++ def fail_after_flush(session: Session, _flush_context) -> None:+ target = ToolFile if failed_phase == "files" else Site+ if any(isinstance(row, target) for row in session.new):+ raise RuntimeError("database write failed after flush")++ event.listen(sqlite_session_factory.class_, "after_flush", fail_after_flush)+ try:+ with pytest.raises(RosterAgentPackageImportFailedError):+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()), tenant_id="tenant-1", account=_account()+ )+ finally:+ event.remove(sqlite_session_factory.class_, "after_flush", fail_after_flush)++ assert len(storage.files) == 4+ assert storage.deleted == []+ with sqlite_session_factory() as session:+ for model in (+ App,+ AppModelConfig,+ Agent,+ AgentConfigSnapshot,+ AgentConfigRevision,+ AgentConfigDraft,+ AgentDebugConversation,+ Site,+ InstalledApp,+ ):+ assert _count(session, model) == 0+ assert _count(session, ToolFile) == (0 if failed_phase == "files" else 3)+ assert _count(session, UploadFile) == (0 if failed_phase == "files" else 1)+ if failed_phase == "agent":+ uploaded = session.scalar(select(UploadFile))+ assert uploaded is not None+ assert uploaded.used is False++[email protected]("sqlite_session_factory")+def test_uploads_do_not_hold_database_transactions(monkeypatch: pytest.MonkeyPatch) -> None:+ sessions: list[Session] = []+ create_session = session_factory.create_session++ def track_session() -> Session:+ session = create_session()+ sessions.append(session)+ return session++ storage = _MemoryStorage()+ save = storage.save++ def save_outside_transaction(filename: str, data: bytes) -> None:+ assert not any(session.in_transaction() for session in sessions)+ save(filename, data)++ monkeypatch.setattr(session_factory, "create_session", track_session)+ monkeypatch.setattr(storage, "save", save_outside_transaction)+ monkeypatch.setattr(AppService, "finalize_created_app", lambda *_args, **_kwargs: None)+ RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()), tenant_id="tenant-1", account=_account()+ )+ assert storage.save_count == 4+++def test_import_succeeds_when_post_commit_initialization_fails(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session_factory: sessionmaker[Session],+ caplog: pytest.LogCaptureFixture,+) -> None:+ storage = _MemoryStorage()+ monkeypatch.setattr(+ AppService,+ "finalize_created_app",+ lambda *_args, **_kwargs: (_ for _ in ()).throw(RuntimeError("finalization failed")),+ )+ result = RosterAgentPackageImporter(storage_backend=storage).import_package(+ source=io.BytesIO(_package()), tenant_id="tenant-1", account=_account()+ )+ assert len(storage.files) == 4+ assert storage.deleted == []+ assert result.warnings == []+ assert "post-commit initialization failed" in caplog.text+ with sqlite_session_factory() as session:+ assert session.get(App, result.app_id) is not None+ assert session.get(Agent, result.agent_id) is not None+ for model in (+ AppModelConfig,+ AgentConfigSnapshot,+ AgentConfigRevision,+ AgentConfigDraft,+ AgentDebugConversation,+ Site,+ InstalledApp,+ UploadFile,+ ):+ assert _count(session, model) == 1+ assert _count(session, ToolFile) == 3+ uploaded = session.scalar(select(UploadFile))+ assert uploaded is not None+ assert uploaded.used is Truediff --git a/api/tests/unit_tests/services/agent/test_roster_package_service.py b/api/tests/unit_tests/services/agent/test_roster_package_service.pyindex 19c0f2ccec4..eb07f2b8874 100644--- a/api/tests/unit_tests/services/agent/test_roster_package_service.py+++ b/api/tests/unit_tests/services/agent/test_roster_package_service.py@@ -32,6 +32,8 @@ from services.agent.dsl_entities import AgentAppDsl, AgentPackage, AgentPackageMfrom services.agent.errors import (InvalidRosterAgentPackageError,RosterAgentPackageExportFailedError,+ RosterAgentPackageImportFailedError,+ RosterAgentPackageResourceUnavailableError,RosterAgentPackageTooLargeError,)from services.agent.roster_package_entities import (@@ -322,10 +324,22 @@ def test_package_files_reuse_existing_dsl_file_kinds(file_kind: str) -> None:(InvalidRosterAgentPackageError(), "invalid_roster_agent_package", 400),(RosterAgentPackageTooLargeError(), "roster_agent_package_too_large", 413),(RosterAgentPackageExportFailedError(), "roster_agent_package_export_failed", 500),+ (RosterAgentPackageImportFailedError(), "roster_agent_package_import_failed", 500),+ (+ RosterAgentPackageResourceUnavailableError(),+ "roster_agent_package_resource_unavailable",+ 503,+ ),],)def test_roster_package_errors_use_standard_http_payload(- error: InvalidRosterAgentPackageError | RosterAgentPackageTooLargeError | RosterAgentPackageExportFailedError,+ error: (+ InvalidRosterAgentPackageError+ | RosterAgentPackageTooLargeError+ | RosterAgentPackageExportFailedError+ | RosterAgentPackageImportFailedError+ | RosterAgentPackageResourceUnavailableError+ ),error_code: str,status: int,) -> None:diff --git a/packages/contracts/binary-zod.test.ts b/packages/contracts/binary-zod.test.tsindex dab37626fae..2aee0ffcdec 100644--- a/packages/contracts/binary-zod.test.ts+++ b/packages/contracts/binary-zod.test.ts@@ -1,8 +1,28 @@import { describe, expect, it } from 'vite-plus/test'+import {+ zGetAppsByAppIdExportResponse,+ zPostAppsImportsBody,+} from './generated/api/console/apps/zod.gen'import { zPostFilesUploadBody } from './generated/api/console/files/zod.gen'import { zPostWorkspacesCurrentPluginUploadPkgBody } from './generated/api/console/workspaces/zod.gen'describe('generated binary schemas', () => {+ it('accepts binary package imports alongside YAML import requests', () => {+ const file = new File(['PK'], 'agent.ifpkg', { type: 'application/zip' })+ expect(zPostAppsImportsBody.safeParse({ file }).success).toBe(true)+ expect(+ zPostAppsImportsBody.safeParse({ mode: 'yaml-content', yaml_content: 'kind: app' }).success,+ ).toBe(true)+ expect(zPostAppsImportsBody.safeParse({ file: 'not a binary file' }).success).toBe(false)+ })++ it('accepts both Agent archives and YAML JSON export responses', () => {+ const archive = new File(['PK'], 'agent.ifpkg', { type: 'application/zip' })+ expect(zGetAppsByAppIdExportResponse.safeParse(archive).success).toBe(true)+ expect(zGetAppsByAppIdExportResponse.safeParse({ data: 'kind: app' }).success).toBe(true)+ expect(zGetAppsByAppIdExportResponse.safeParse('kind: app').success).toBe(false)+ })+it.each([['file upload', zPostFilesUploadBody, 'file'],['plugin package upload', zPostWorkspacesCurrentPluginUploadPkgBody, 'pkg'],diff --git a/packages/contracts/generated/api/console/apps/types.gen.ts b/packages/contracts/generated/api/console/apps/types.gen.tsindex fa685709fe4..bfd59c89666 100644--- a/packages/contracts/generated/api/console/apps/types.gen.ts+++ b/packages/contracts/generated/api/console/apps/types.gen.ts@@ -76,6 +76,13 @@ export type Import = {warnings?: Array<DslImportWarning>}+export type RosterAgentPackageConflictResponse = {+ code: string+ leaked_dependencies?: Array<PluginDependency>+ message: string+ status?: 409+}+export type CheckDependenciesResult = {leaked_dependencies?: Array<PluginDependency>}@@ -3147,7 +3154,11 @@ export type PostAppsResponses = {export type PostAppsResponse = PostAppsResponses[keyof PostAppsResponses]export type PostAppsImportsData = {- body: AppImportPayload+ body:+ | AppImportPayload+ | {+ file: Blob | File+ }path?: neverquery?: neverurl: '/apps/imports'@@ -3155,6 +3166,9 @@ export type PostAppsImportsData = {export type PostAppsImportsErrors = {400: Import+ 403: unknown+ 409: RosterAgentPackageConflictResponse+ 413: unknown}export type PostAppsImportsError = PostAppsImportsErrors[keyof PostAppsImportsErrors]@@ -4417,6 +4431,7 @@ export type GetAppsByAppIdExportData = {app_id: string}query?: {+ format?: 'ifpkg' | 'yaml'include_secret?: booleanworkflow_id?: string}@@ -4428,7 +4443,7 @@ export type GetAppsByAppIdExportErrors = {}export type GetAppsByAppIdExportResponses = {- 200: AppExportResponse+ 200: AppExportResponse | Blob | File}export type GetAppsByAppIdExportResponse =diff --git a/packages/contracts/generated/api/console/apps/zod.gen.ts b/packages/contracts/generated/api/console/apps/zod.gen.tsindex a29b6c275de..7b20baca4ea 100644--- a/packages/contracts/generated/api/console/apps/zod.gen.ts+++ b/packages/contracts/generated/api/console/apps/zod.gen.ts@@ -2258,6 +2258,16 @@ export const zPluginDependency = z.object({value: z.union([zGithub, zMarketplace, zPackage]),})+/**+ * RosterAgentPackageConflictResponse+ */+export const zRosterAgentPackageConflictResponse = z.object({+ code: z.string(),+ leaked_dependencies: z.array(zPluginDependency).optional(),+ message: z.string(),+ status: z.literal(409).optional().default(409),+})+/*** CheckDependenciesResult*/@@ -4244,7 +4254,12 @@ export const zPostAppsBody = zCreateAppPayload*/export const zPostAppsResponse = zAppDetailWithSite-export const zPostAppsImportsBody = zAppImportPayload+export const zPostAppsImportsBody = z.union([+ zAppImportPayload,+ z.object({+ file: z.custom<Blob | File>((value) => value instanceof Blob || value instanceof File),+ }),+])/*** Import completed@@ -5041,6 +5056,7 @@ export const zGetAppsByAppIdExportPath = z.object({})export const zGetAppsByAppIdExportQuery = z.object({+ format: z.enum(['ifpkg', 'yaml']).optional(),include_secret: z.boolean().optional().default(false),workflow_id: z.string().optional(),})@@ -5048,7 +5064,10 @@ export const zGetAppsByAppIdExportQuery = z.object({/*** App exported successfully*/-export const zGetAppsByAppIdExportResponse = zAppExportResponse+export const zGetAppsByAppIdExportResponse = z.union([+ zAppExportResponse,+ z.custom<Blob | File>((value) => value instanceof Blob || value instanceof File),+])export const zPostAppsByAppIdFeedbacksBody = zMessageFeedbackPayloaddiff --git a/packages/contracts/openapi-ts.api.config.ts b/packages/contracts/openapi-ts.api.config.tsindex a2b272336cb..05d91cd0852 100644--- a/packages/contracts/openapi-ts.api.config.ts+++ b/packages/contracts/openapi-ts.api.config.ts@@ -261,7 +261,31 @@ const filterContractOperations = (document: SwaggerDocument) => {}}-const includeEventStreamInJsonResponseSchemas = (document: SwaggerDocument) => {+const includeMultipartRequestSchemas = (document: SwaggerDocument) => {+ for (const pathItem of Object.values(document.paths ?? {})) {+ for (const [method, operation] of Object.entries(pathItem)) {+ if (!operationMethods.has(method) || !isObject(operation) || !isObject(operation.requestBody))+ continue+ const content = operation.requestBody.content+ if (!isObject(content)) continue+ const json = content['application/json']+ const multipart = content['multipart/form-data']+ if (+ !isObject(json) ||+ !isObject(json.schema) ||+ !isObject(multipart) ||+ !isObject(multipart.schema)+ )+ continue++ // hey-api selects JSON for mixed request media; retain the multipart shape+ // so the generated client can serialize File values as FormData.+ json.schema = { anyOf: [json.schema, multipart.schema] }+ }+ }+}++const includeNonJsonResponseSchemas = (document: SwaggerDocument) => {for (const pathItem of Object.values(document.paths ?? {})) {for (const [method, operation] of Object.entries(pathItem)) {if (!operationMethods.has(method) || !isObject(operation)) continue@@ -272,21 +296,22 @@ const includeEventStreamInJsonResponseSchemas = (document: SwaggerDocument) => {if (!/^2\d\d$/.test(status) || !isObject(response) || !isObject(response.content)) continueconst jsonMedia = response.content['application/json']- const eventStreamMedia = response.content['text/event-stream']- if (- !isObject(jsonMedia) ||- !isObject(jsonMedia.schema) ||- !isObject(eventStreamMedia) ||- !isObject(eventStreamMedia.schema)- ) {- continue+ if (!isObject(jsonMedia) || !isObject(jsonMedia.schema)) continue++ const alternatives: SwaggerSchema[] = []+ for (const [mediaType, media] of Object.entries(response.content)) {+ if (mediaType === 'application/json' || !isObject(media) || !isObject(media.schema))+ continue+ if (mediaType === 'text/event-stream' || media.schema.format === 'binary')+ alternatives.push(media.schema)}+ if (alternatives.length === 0) continue// hey-api selects the JSON schema when one status advertises multiple- // response media types. Preserve the SSE transport in the generated+ // response media types. Preserve SSE and binary transports in the generated// TypeScript and Zod contracts by making that selected schema a union.jsonMedia.schema = {- anyOf: [jsonMedia.schema, eventStreamMedia.schema],+ anyOf: [jsonMedia.schema, ...alternatives],}}}@@ -369,7 +394,8 @@ const normalizeApiSwagger = (document: SwaggerDocument) => {normalizeOpaqueContractResponses(document)filterContractOperations(document)addOperationIds(document)- includeEventStreamInJsonResponseSchemas(document)+ includeMultipartRequestSchemas(document)+ includeNonJsonResponseSchemas(document)// OpenAPI defaults describe server behavior. Keep them in the exported specs,// but do not let Zod synthesize omitted transport fields during client-side// request or response validation. Non-null defaults remain useful for querydiff --git a/web/app/components/app/__tests__/use-export-app-dsl.spec.tsx b/web/app/components/app/__tests__/use-export-app-dsl.spec.tsxindex 315b6adb42c..cd54f987bc9 100644--- a/web/app/components/app/__tests__/use-export-app-dsl.spec.tsx+++ b/web/app/components/app/__tests__/use-export-app-dsl.spec.tsx@@ -59,6 +59,33 @@ describe('useExportAppDsl', () => {mocks.getEnvironmentVariables.mockResolvedValue({ items: [] })})+ it.each([+ ['download.ifpkg', 'download.ifpkg'],+ ['blob', 'Support Agent.ifpkg'],+ ])('downloads binary exports using %s without rebuilding their bytes', async (name, fileName) => {+ const archive = new File([new Uint8Array([0x50, 0x4b, 0x03, 0x04, 0x00, 0xff])], name, {+ type: 'application/zip',+ })+ mocks.exportAppDsl.mockResolvedValue(archive)+ const { result } = renderHook(() => useExportAppDsl(), { wrapper: createWrapper() })++ await act(async () => {+ await expect(+ result.current.exportAppDsl({+ appId: 'agent-app-id',+ appName: 'Support Agent',+ }),+ ).resolves.toEqual({ status: 'downloaded' })+ })++ expect(mocks.downloadBlob).toHaveBeenCalledWith({ data: archive, fileName })+ const [{ data }] = mocks.downloadBlob.mock.calls[0] as [{ data: Blob }]+ expect(new Uint8Array(await data.arrayBuffer())).toEqual(+ new Uint8Array([0x50, 0x4b, 0x03, 0x04, 0x00, 0xff]),+ )+ expect(mocks.getEnvironmentVariables).not.toHaveBeenCalled()+ })+it('exports through the generated client and hands the YAML file to the browser', async () => {mocks.exportAppDsl.mockResolvedValue({ data: 'kind: app\nversion: 0.1.5\n' })const { result } = renderHook(() => useExportAppDsl(), { wrapper: createWrapper() })diff --git a/web/app/components/app/create-from-dsl-modal/__tests__/index.spec.tsx b/web/app/components/app/create-from-dsl-modal/__tests__/index.spec.tsxindex 0707531b0b7..fc0af74cfae 100644--- a/web/app/components/app/create-from-dsl-modal/__tests__/index.spec.tsx+++ b/web/app/components/app/create-from-dsl-modal/__tests__/index.spec.tsx@@ -166,6 +166,63 @@ describe('CreateFromDSLModal', () => {const getCreateButton = () => screen.getByRole('button', { name: /newApp\.Create/i })+ it.each(['agent.ifpkg', 'agent.IFPKG'])(+ 'imports %s as a binary file and handles Agent warnings',+ async (filename) => {+ const user = userEvent.setup()+ const file = new File([new Uint8Array([0x50, 0x4b, 0x00, 0xff])], filename)+ const readText = vi.spyOn(file, 'text')+ const onClose = vi.fn()+ mockImportDSL.mockResolvedValue({+ id: 'package-import',+ status: 'completed-with-warnings',+ app_id: 'agent-app',+ app_mode: AppModeEnum.AGENT,+ warnings: [+ { code: 'agent_skill_missing', path: 'skills.s_000001', message: 'Missing Skill' },+ ],+ })+ render(<CreateFromDSLModal show onClose={onClose} droppedFile={file} />)+ await user.click(getCreateButton())++ await waitFor(() => expect(mockImportDSL).toHaveBeenCalledWith({ file }))+ expect(readText).not.toHaveBeenCalled()+ expect(onClose).toHaveBeenCalledTimes(1)+ expect(toastMocks.call).toHaveBeenCalledWith(expect.any(String), {+ type: 'warning',+ description: expect.anything(),+ })+ expect(mockResolveImportedAppRedirectionTarget).toHaveBeenCalledWith({+ id: 'agent-app',+ mode: AppModeEnum.AGENT,+ permission_keys: undefined,+ })+ },+ )++ it('accepts an ifpkg from the file picker even when the ordinary App quota is full', async () => {+ const user = userEvent.setup()+ appCount = 10+ appLimit = 10+ mockImportDSL.mockResolvedValue({+ id: 'import',+ status: 'completed',+ app_mode: AppModeEnum.AGENT,+ })+ render(<CreateFromDSLModal show onClose={vi.fn()} />)+ const input = document.querySelector<HTMLInputElement>('input[type="file"]')+ expect(input).not.toBeNull()+ if (!input) throw new Error('Missing file picker')+ const file = new File(['PK'], 'agent.ifpkg')+ await user.upload(input, file)++ expect(await screen.findByText('agent.ifpkg')).toBeInTheDocument()+ expect(screen.getByText('IFPKG')).toBeInTheDocument()+ expect(screen.queryByText('apps-full')).not.toBeInTheDocument()+ await user.click(getCreateButton())+ await waitFor(() => expect(mockImportDSL).toHaveBeenCalledWith({ file }))+ })+it('should render the file tab and show the dropped file', async () => {render(<CreateFromDSLModaldiff --git a/web/app/components/app/create-from-dsl-modal/index.tsx b/web/app/components/app/create-from-dsl-modal/index.tsxindex 5959ac3f7d6..95a0cdf0ba1 100644--- a/web/app/components/app/create-from-dsl-modal/index.tsx+++ b/web/app/components/app/create-from-dsl-modal/index.tsx@@ -103,6 +103,12 @@ function CreateFromDSLModal({)const importMutation = useMutation({mutationFn: async (source: ImportSource) => {+ if (+ source.type === CreateFromDSLModalTab.FROM_FILE &&+ source.file.name.toLowerCase().endsWith('.ifpkg')+ )+ return requestImport({ body: { file: source.file } })+const body =source.type === CreateFromDSLModalTab.FROM_FILE? ({@@ -134,9 +140,14 @@ function CreateFromDSLModal({select: (data) => data.apps,}),)- const isAppQuotaUnavailable = deploymentEdition === 'CLOUD' && appQuota === undefined+ const isPackageImport =+ currentTab === CreateFromDSLModalTab.FROM_FILE &&+ currentFile?.name.toLowerCase().endsWith('.ifpkg') === true+ const isAppQuotaUnavailable =+ !isPackageImport && deploymentEdition === 'CLOUD' && appQuota === undefined// A limit of 0 means unlimited.const isAppsFull =+ !isPackageImport &&deploymentEdition === 'CLOUD' &&appQuota !== undefined &&appQuota.limit > 0 &&@@ -309,6 +320,8 @@ function CreateFromDSLModal({className="px-6 py-4"><Uploader+ accept=".yaml,.yml,.ifpkg"+ displayName={isPackageImport ? 'IFPKG' : 'YAML'}browseButtonRef={browseButtonRef}className="mt-0"file={currentFile}diff --git a/web/app/components/app/use-export-app-dsl.ts b/web/app/components/app/use-export-app-dsl.tsindex 5d1975d2c18..32533de40d4 100644--- a/web/app/components/app/use-export-app-dsl.ts+++ b/web/app/components/app/use-export-app-dsl.ts@@ -40,7 +40,7 @@ async function getSecretEnvironmentVariables(appId: string) {}async function exportAppDslFile({ appId, appName, includeSecret = false }: ExportAppDslInput) {- const { data } = await consoleClient.apps.byAppId.export.get(+ const response = await consoleClient.apps.byAppId.export.get({params: { app_id: appId },query: { include_secret: includeSecret },@@ -48,8 +48,17 @@ async function exportAppDslFile({ appId, appName, includeSecret = false }: Expor{ context: { silent: true } },)+ if (response instanceof Blob) {+ const name = response instanceof File ? response.name : undefined+ downloadBlob({+ data: response,+ fileName: name && name !== 'blob' ? name : `${appName}.ifpkg`,+ })+ return+ }+downloadBlob({- data: new Blob([data], { type: 'application/yaml' }),+ data: new Blob([response.data], { type: 'application/yaml' }),fileName: `${appName}.yml`,})}diff --git a/web/app/components/apps/hooks/__tests__/use-dsl-drag-drop.spec.ts b/web/app/components/apps/hooks/__tests__/use-dsl-drag-drop.spec.tsindex 8a8a534fceb..36312a31572 100644--- a/web/app/components/apps/hooks/__tests__/use-dsl-drag-drop.spec.ts+++ b/web/app/components/apps/hooks/__tests__/use-dsl-drag-drop.spec.ts@@ -188,24 +188,27 @@ describe('useDSLDragDrop', () => {})describe('Drop functionality', () => {- it('should call onDSLFileDropped for .yaml file', () => {- const dropZoneRef = { current: container }- renderHook(() =>- useDSLDragDrop({- onDSLFileDropped: mockOnDSLFileDropped,- dropZoneRef,- }),- )+ it.each(['test.yaml', 'agent.ifpkg', 'agent.IFPKG'])(+ 'should call onDSLFileDropped for %s',+ (filename) => {+ const dropZoneRef = { current: container }+ renderHook(() =>+ useDSLDragDrop({+ onDSLFileDropped: mockOnDSLFileDropped,+ dropZoneRef,+ }),+ )- const file = createMockFile('test.yaml')- const dropEvent = createDragEvent('drop', [file])+ const file = createMockFile(filename)+ const dropEvent = createDragEvent('drop', [file])- act(() => {- container.dispatchEvent(dropEvent)- })+ act(() => {+ container.dispatchEvent(dropEvent)+ })- expect(mockOnDSLFileDropped).toHaveBeenCalledWith(file)- })+ expect(mockOnDSLFileDropped).toHaveBeenCalledWith(file)+ },+ )it('should call onDSLFileDropped for .yml file', () => {const dropZoneRef = { current: container }diff --git a/web/app/components/apps/hooks/use-dsl-drag-drop.ts b/web/app/components/apps/hooks/use-dsl-drag-drop.tsindex 53198fc4eba..dd33c84cfae 100644--- a/web/app/components/apps/hooks/use-dsl-drag-drop.ts+++ b/web/app/components/apps/hooks/use-dsl-drag-drop.ts@@ -42,8 +42,7 @@ export const useDSLDragDrop = ({if (files.length === 0) returnconst file = files[0]- if (file!.name.toLowerCase().endsWith('.yaml') || file!.name.toLowerCase().endsWith('.yml'))- onDSLFileDropped(file!)+ if (/\.(?:yaml|yml|ifpkg)$/i.test(file!.name)) onDSLFileDropped(file!)})useEffect(() => {diff --git a/web/service/console/client.spec.ts b/web/service/console/client.spec.tsindex d065ba52279..e954aaf1751 100644--- a/web/service/console/client.spec.ts+++ b/web/service/console/client.spec.ts@@ -199,6 +199,61 @@ describe('consoleQuery transport context', () => {vi.restoreAllMocks()})+ it('uploads ifpkg imports as multipart files without decoding their bytes as YAML', async () => {+ const bytes = new Uint8Array([0x50, 0x4b, 0x03, 0x04, 0x00, 0xff])+ const file = new File([bytes], 'agent.ifpkg', { type: 'application/zip' })+ const request = vi.fn().mockResolvedValue(+ new Response(JSON.stringify({ id: 'import-1', status: 'completed' }), {+ status: 200,+ headers: { 'content-type': 'application/json' },+ }),+ )+ const consoleQuery = await loadConsoleQueryWithRequest(request)+ const mutation = new MutationObserver(+ new QueryClient(),+ consoleQuery.apps.imports.post.mutationOptions(),+ )+ await mutation.mutate({ body: { file } })++ const outgoing = request.mock.calls[0]?.[2]?.request as Request+ expect(outgoing.url).toContain('/apps/imports')+ expect(outgoing.headers.get('content-type')).toContain('multipart/form-data; boundary=')+ const form = await outgoing.formData()+ expect(Array.from(form.keys())).toEqual(['file'])+ const uploaded = form.get('file')+ expect(uploaded).toBeInstanceOf(File)+ if (!(uploaded instanceof File)) throw new TypeError('Expected an uploaded archive')+ expect(uploaded.name).toBe('agent.ifpkg')+ expect(new Uint8Array(await uploaded.arrayBuffer())).toEqual(bytes)+ })++ it('preserves archive bytes and the download filename for App exports', async () => {+ const bytes = new Uint8Array([0x50, 0x4b, 0x03, 0x04, 0x00, 0xff])+ const request = vi.fn().mockResolvedValue(+ new Response(bytes, {+ status: 200,+ headers: {+ 'content-type': 'application/zip',+ 'content-disposition': 'attachment; filename="agent.ifpkg"',+ },+ }),+ )+ const consoleQuery = await loadConsoleQueryWithRequest(request)+ const options = consoleQuery.apps.byAppId.export.get.queryOptions({+ input: { params: { app_id: 'app-1' } },+ context: { silent: true },+ })+ const result = await options.queryFn({+ signal: new AbortController().signal,+ } as QueryFunctionContext)++ expect(result).toBeInstanceOf(File)+ if (!(result instanceof File)) throw new TypeError('Expected an archive download')+ expect(result.name).toBe('agent.ifpkg')+ expect(result.type).toBe('application/zip')+ expect(new Uint8Array(await result.arrayBuffer())).toEqual(bytes)+ })+it('should forward silent context to the base request transport', async () => {const request = vi.fn().mockResolvedValue(new Response(JSON.stringify({}), {diff --git a/web/service/console/query-policies.ts b/web/service/console/query-policies.tsindex 4838d3e9282..2a6f97db8a7 100644--- a/web/service/console/query-policies.ts+++ b/web/service/console/query-policies.ts@@ -179,7 +179,7 @@ export function createConsoleQuery(consoleClient: ConsoleClient) {onSuccess: (data, variables, _onMutateResult, context) => {if (data.status !== 'completed' && data.status !== 'completed-with-warnings') return- if (!variables.body.app_id) {+ if (!('app_id' in variables.body) || !variables.body.app_id) {void context.client.invalidateQueries({queryKey: consoleQuery.features.get.key(),})