Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

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.py
index 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 Sequence
from datetime import datetime
from typing import Any, Literal
+from flask import send_file
from flask_restx import Resource
from pydantic import AliasChoices, BaseModel, Field, ValidationInfo, computed_field, field_validator, model_validator
from sqlalchemy import select
@@ -47,10 +48,12 @@ from extensions.ext_application_services import application_services
from extensions.ext_database import db
from fields.base import ResponseModel
from graphon.enums import WorkflowExecutionStatus
+from libs.flask_restx_compat import BINARY_RESPONSE_MEDIA_TYPES_VENDOR_KEY
from libs.helper import build_icon_url, dump_response, to_timestamp
from libs.login import login_required
from models import Account, App, DatasetPermissionEnum, Workflow
-from models.model import IconType
+from models.model import AppMode, IconType
+from services.agent.roster_package_exporter import RosterAgentPackageExporter
from services.app_dsl_service import AppDslService
from 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.py
index 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 request
from flask_restx import Resource
from pydantic import BaseModel, Field
from sqlalchemy.orm import Session
@@ -5,23 +9,27 @@ from werkzeug.exceptions import Forbidden
from configs import dify_config
from 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_models
from controllers.console.app.wraps import get_app_model
from 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 PluginDependency
from extensions.ext_database import db
from extensions.ext_redis import redis_client
+from fields.base import ResponseModel
from libs.login import current_account_with_tenant, login_required
from 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 RosterAgentPackageImporter
from 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 plain
diff --git a/api/events/event_handlers/create_installed_app_when_app_created.py b/api/events/event_handlers/create_installed_app_when_app_created.py
index 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 select
from sqlalchemy.orm import Session
from 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.py
index 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 Session
from 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.connect
def handle(sender, *, session: Session, **kwargs) -> None:
"""Create site record when an app is created."""
+ if kwargs.get("created_records_initialized"):
+ return
app = sender
account = 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.md
index 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}/feedbacks
Create 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.py
index 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)
+
@staticmethod
def _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.py
index 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.py
index 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.py
new file mode 100644
index 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 error
diff --git a/api/services/agent/roster_package_importer.py b/api/services/agent/roster_package_importer.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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.mode
initialize_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 App
diff --git a/api/tests/unit_tests/commands/test_generate_swagger_specs.py b/api/tests/unit_tests/commands/test_generate_swagger_specs.py
index 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(tmp
assert 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.py
index 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.py
new file mode 100644
index 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.py
index 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_updated
from models.account import Account
from models.agent import Agent, AgentWorkspace
from models.dataset import AppDatasetJoin
-from models.model import App, AppMode, AppModelConfig, IconType, InstalledApp
+from models.model import App, AppMode, AppModelConfig, IconType, InstalledApp, Site
from 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.id
assert installed_app.tenant_id == app_model.tenant_id
assert 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 None
diff --git a/api/tests/unit_tests/services/agent/test_agent_dsl_service.py b/api/tests/unit_tests/services/agent/test_agent_dsl_service.py
index 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: Se
service = 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.py
new file mode 100644
index 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",
+ 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 True
diff --git a/api/tests/unit_tests/services/agent/test_roster_package_service.py b/api/tests/unit_tests/services/agent/test_roster_package_service.py
index 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, AgentPackageM
from 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.ts
index 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.ts
index 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?: never
query?: never
url: '/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?: boolean
workflow_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.ts
index 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 = zMessageFeedbackPayload
diff --git a/packages/contracts/openapi-ts.api.config.ts b/packages/contracts/openapi-ts.api.config.ts
index 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)) continue
const 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 query
diff --git a/web/app/components/app/__tests__/use-export-app-dsl.spec.tsx b/web/app/components/app/__tests__/use-export-app-dsl.spec.tsx
index 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.tsx
index 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(
<CreateFromDSLModal
diff --git a/web/app/components/app/create-from-dsl-modal/index.tsx b/web/app/components/app/create-from-dsl-modal/index.tsx
index 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.ts
index 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.ts
index 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.ts
index 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) return
const 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.ts
index 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.ts
index 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(),
})