Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
feat(agent): add roster package export foundation (#42066)
林玮 (Jade Lin)93895fa7fb4a
diff --git a/api/.env.example b/api/.env.exampleindex 0bf7b9493ac..7d3ff606049 100644--- a/api/.env.example+++ b/api/.env.example@@ -460,6 +460,12 @@ UPLOAD_IMAGE_FILE_SIZE_LIMIT=10UPLOAD_VIDEO_FILE_SIZE_LIMIT=100UPLOAD_AUDIO_FILE_SIZE_LIMIT=50UPLOAD_SKILL_FILE_SIZE_LIMIT=50+SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES=209715200+SKILL_PACKAGE_MAX_ENTRIES=5000+SKILL_PACKAGE_MAX_SKILL_MD_BYTES=1048576+AGENT_PACKAGE_MAX_BYTES=536870912+AGENT_PACKAGE_MAX_MANIFEST_BYTES=5242880+AGENT_PACKAGE_MAX_ENTRIES=5000# Comma-separated list of file extensions blocked from upload for security reasons.# Extensions should be lowercase without dots (e.g., exe,bat,sh,dll).diff --git a/api/configs/feature/__init__.py b/api/configs/feature/__init__.pyindex facc092575e..f3eabbafcb9 100644--- a/api/configs/feature/__init__.py+++ b/api/configs/feature/__init__.py@@ -481,6 +481,36 @@ class FileUploadConfig(BaseSettings):default=50,)+ SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES: PositiveInt = Field(+ description="Maximum total uncompressed size of a Skill package in bytes",+ default=200 * 1024 * 1024,+ )++ SKILL_PACKAGE_MAX_ENTRIES: PositiveInt = Field(+ description="Maximum number of entries in a Skill package",+ default=5000,+ )++ SKILL_PACKAGE_MAX_SKILL_MD_BYTES: PositiveInt = Field(+ description="Maximum allowed SKILL.md size in bytes",+ default=1 * 1024 * 1024,+ )++ AGENT_PACKAGE_MAX_BYTES: PositiveInt = Field(+ description="Maximum allowed Agent package size in bytes",+ default=512 * 1024 * 1024,+ )++ AGENT_PACKAGE_MAX_MANIFEST_BYTES: PositiveInt = Field(+ description="Maximum allowed size of each Agent package YAML document in bytes",+ default=5 * 1024 * 1024,+ )++ AGENT_PACKAGE_MAX_ENTRIES: PositiveInt = Field(+ description="Maximum number of entries in an Agent package",+ default=5000,+ )+BATCH_UPLOAD_LIMIT: NonNegativeInt = Field(description="Maximum number of files allowed in a batch upload operation",default=20,diff --git a/api/libs/zip_filename_recovery.py b/api/libs/zip_filename_recovery.pynew file mode 100644index 00000000000..9b813e7b1a9--- /dev/null+++ b/api/libs/zip_filename_recovery.py@@ -0,0 +1,158 @@+"""Read malformed UTF-8 ZIP names without weakening payload integrity checks."""++from __future__ import annotations++import io+import struct+import zipfile+from dataclasses import dataclass++_UTF8_FLAG = 1 << 11+_END_RECORD = struct.Struct("<4s4H2IH")+_CENTRAL_HEADER = struct.Struct("<4s6H3I5H2I")+_LOCAL_HEADER = struct.Struct("<4s5H3I2H")+_ZIP64_LOCATOR = struct.Struct("<4sIQI")+_ZIP64_END_RECORD = struct.Struct("<4sQ2H2I4Q")+++@dataclass(frozen=True)+class _Directory:+ start: int+ end: int+ entries: int+ prefix_size: int+++def _locate_directory(content: bytes) -> _Directory:+ end = content.rfind(b"PK\x05\x06", max(0, len(content) - 65535 - _END_RECORD.size))+ if end < 0 or end + _END_RECORD.size > len(content):+ raise zipfile.BadZipFile("Missing ZIP end record")+ _, disk, directory_disk, disk_entries, entries, size, offset, comment_size = _END_RECORD.unpack_from(content, end)+ if end + _END_RECORD.size + comment_size != len(content):+ raise zipfile.BadZipFile("Invalid ZIP comment length")++ locator_position = end - _ZIP64_LOCATOR.size+ if locator_position >= 0 and content[locator_position : locator_position + 4] == b"PK\x06\x07":+ _, record_disk, record_offset, disks = _ZIP64_LOCATOR.unpack_from(content, locator_position)+ if record_disk != 0 or disks != 1:+ raise zipfile.BadZipFile("Multi-disk ZIP64 archives are not supported")+ record_position = record_offset+ if record_position + _ZIP64_END_RECORD.size > locator_position:+ raise zipfile.BadZipFile("Invalid ZIP64 end record offset")+ if content[record_position : record_position + 4] != b"PK\x06\x06":+ # Match zipfile's handling of prepended data: in this case it+ # locates the fixed-size ZIP64 record immediately before the locator.+ record_position = locator_position - _ZIP64_END_RECORD.size+ if record_position < 0:+ raise zipfile.BadZipFile("Missing ZIP64 end record")+ signature, record_size, _, _, disk, directory_disk, disk_entries, entries, size, offset = (+ _ZIP64_END_RECORD.unpack_from(content, record_position)+ )+ if (+ signature != b"PK\x06\x06"+ or record_size + 12 != locator_position - record_position+ or offset + size != record_offset+ ):+ raise zipfile.BadZipFile("Invalid ZIP64 end record")+ end = record_position+ elif entries == 0xFFFF or size == 0xFFFFFFFF or offset == 0xFFFFFFFF:+ raise zipfile.BadZipFile("Missing ZIP64 directory information")++ start = end - size+ prefix_size = start - offset+ if disk != 0 or directory_disk != 0 or disk_entries != entries:+ raise zipfile.BadZipFile("Multi-disk ZIP archives are not supported")+ if start < 0 or prefix_size < 0 or entries > size // _CENTRAL_HEADER.size:+ raise zipfile.BadZipFile("Invalid ZIP directory bounds")+ return _Directory(start=start, end=end, entries=entries, prefix_size=prefix_size)+++def _local_header_offset(*, offset: int, file_size: int, compressed_size: int, extra: bytes) -> int:+ if offset != 0xFFFFFFFF:+ return offset+ cursor = 0+ while cursor + 4 <= len(extra):+ tag, size = struct.unpack_from("<HH", extra, cursor)+ cursor += 4+ if cursor + size > len(extra):+ raise zipfile.BadZipFile("Truncated ZIP extra field")+ if tag == 1:+ # ZIP64 includes only values whose corresponding 32-bit field+ # contains the sentinel, in size/compressed-size/offset order.+ skipped = 8 * (int(file_size == 0xFFFFFFFF) + int(compressed_size == 0xFFFFFFFF))+ if skipped + 8 > size:+ raise zipfile.BadZipFile("Missing ZIP64 local header offset")+ return struct.unpack_from("<Q", extra, cursor + skipped)[0]+ cursor += size+ raise zipfile.BadZipFile("Missing ZIP64 extra field")+++def open_zip_with_replacement_names(content: bytes) -> zipfile.ZipFile:+ """Open a bounded ZIP, replacing invalid UTF-8 name bytes with U+FFFD.++ The normal path delegates entirely to zipfile. For a damaged directory,+ temporarily read affected names as CP437 (a reversible byte mapping), and+ expose their lossy UTF-8 form through ZipInfo.filename. orig_filename stays+ byte-preserving so zipfile still checks local/central name consistency.+ Callers must reject collisions and unsafe paths in the recovered names.+ """+ try:+ return zipfile.ZipFile(io.BytesIO(content))+ except UnicodeDecodeError:+ pass++ directory = _locate_directory(content)++ patched = bytearray(content)+ recovered: dict[int, str] = {}+ cursor = directory.start+ for index in range(directory.entries):+ if cursor + _CENTRAL_HEADER.size > directory.end:+ raise zipfile.BadZipFile("Truncated ZIP directory")+ header = _CENTRAL_HEADER.unpack_from(content, cursor)+ if header[0] != b"PK\x01\x02":+ raise zipfile.BadZipFile("Invalid ZIP directory header")+ flags, name_size, extra_size, entry_comment_size = header[3], header[10], header[11], header[12]+ name_start = cursor + _CENTRAL_HEADER.size+ next_cursor = name_start + name_size + extra_size + entry_comment_size+ if next_cursor > directory.end:+ raise zipfile.BadZipFile("Truncated ZIP directory name")+ raw_name = content[name_start : name_start + name_size]+ if flags & _UTF8_FLAG:+ try:+ raw_name.decode("utf-8")+ except UnicodeDecodeError:+ extra_start = name_start + name_size+ local_offset = (+ _local_header_offset(+ offset=header[16],+ file_size=header[9],+ compressed_size=header[8],+ extra=content[extra_start : extra_start + extra_size],+ )+ + directory.prefix_size+ )+ if local_offset < 0 or local_offset + _LOCAL_HEADER.size > directory.start:+ raise zipfile.BadZipFile("Invalid ZIP local header offset")+ local = _LOCAL_HEADER.unpack_from(content, local_offset)+ local_name_start = local_offset + _LOCAL_HEADER.size+ if (+ local[0] != b"PK\x03\x04"+ or local[9] != name_size+ or content[local_name_start : local_name_start + local[9]] != raw_name+ or not local[2] & _UTF8_FLAG+ ):+ raise zipfile.BadZipFile("ZIP local and directory names differ")+ struct.pack_into("<H", patched, cursor + 8, flags & ~_UTF8_FLAG)+ struct.pack_into("<H", patched, local_offset + 6, local[2] & ~_UTF8_FLAG)+ recovered[index] = raw_name.decode("utf-8", errors="replace")+ cursor = next_cursor+ if cursor != directory.end:+ raise zipfile.BadZipFile("ZIP directory length mismatch")++ archive = zipfile.ZipFile(io.BytesIO(patched))+ for index, info in enumerate(archive.infolist()):+ if index in recovered:+ info.filename = recovered[index]+ archive.NameToInfo = {info.filename: info for info in archive.infolist()}+ return archivediff --git a/api/services/agent/config_skill_normalize_service.py b/api/services/agent/config_skill_normalize_service.pyindex 7093b49ce1c..51aee675137 100644--- a/api/services/agent/config_skill_normalize_service.py+++ b/api/services/agent/config_skill_normalize_service.py@@ -9,7 +9,7 @@ from __future__ import annotationsfrom core.tools.tool_file_manager import ToolFileManagerfrom models.agent_config_entities import AgentConfigSkillRefConfig, validate_config_skill_name-from services.agent.skill_package_service import NormalizedSkillPackage, SkillPackageError, SkillPackageService+from services.agent.skill_package_service import SkillPackageError, SkillPackageServiceclass ConfigSkillNormalizeService:@@ -32,7 +32,7 @@ class ConfigSkillNormalizeService:requested_name: str | None,tenant_id: str,user_id: str,- ) -> tuple[AgentConfigSkillRefConfig, NormalizedSkillPackage]:+ ) -> AgentConfigSkillRefConfig:package = self._package.validate_and_normalize(content=content, filename=filename)normalized_name = validate_config_skill_name(requested_name or package.manifest.name)if package.manifest.name != normalized_name:@@ -50,16 +50,13 @@ class ConfigSkillNormalizeService:mimetype="application/zip",filename=f"{normalized_name}.zip",)- return (- AgentConfigSkillRefConfig(- name=normalized_name,- description=package.manifest.description,- file_id=tool_file.id,- size=tool_file.size,- hash=package.manifest.hash,- mime_type=tool_file.mimetype,- ),- package,+ return AgentConfigSkillRefConfig(+ name=normalized_name,+ description=package.manifest.description,+ file_id=tool_file.id,+ size=tool_file.size,+ hash=package.manifest.hash,+ mime_type=tool_file.mimetype,)diff --git a/api/services/agent/dependency_service.py b/api/services/agent/dependency_service.pynew file mode 100644index 00000000000..b523cb3d039--- /dev/null+++ b/api/services/agent/dependency_service.py@@ -0,0 +1,65 @@+"""Plugin dependency discovery shared by portable Agent formats."""++from models.agent_config_entities import (+ AgentKnowledgeMetadataFilteringConfig,+ AgentKnowledgeRetrievalConfig,+ AgentSoulConfig,+)+from services.plugin.dependencies_analysis import DependenciesAnalysisService+++def _extract_knowledge_retrieval_dependencies(retrieval: AgentKnowledgeRetrievalConfig) -> list[str]:+ if retrieval.mode == "single":+ if retrieval.model is None:+ return []+ return [DependenciesAnalysisService.analyze_model_provider_dependency(retrieval.model.provider)]++ if not retrieval.reranking_enable:+ return []++ if retrieval.reranking_mode == "reranking_model":+ if retrieval.reranking_model is None:+ return []+ return [DependenciesAnalysisService.analyze_model_provider_dependency(retrieval.reranking_model.provider)]++ if retrieval.reranking_mode == "weighted_score" and retrieval.weights is not None:+ vector_setting = retrieval.weights.vector_setting+ embedding_provider = vector_setting.get("embedding_provider_name") if vector_setting is not None else None+ if embedding_provider:+ return [DependenciesAnalysisService.analyze_model_provider_dependency(embedding_provider)]++ return []+++def _extract_metadata_filtering_dependencies(+ metadata_filtering: AgentKnowledgeMetadataFilteringConfig,+) -> list[str]:+ if metadata_filtering.mode != "automatic" or metadata_filtering.metadata_model_config is None:+ return []+ return [+ DependenciesAnalysisService.analyze_model_provider_dependency(metadata_filtering.metadata_model_config.provider)+ ]+++def extract_agent_soul_dependencies(soul: AgentSoulConfig) -> list[str]:+ dependencies: list[str] = []+ if soul.model is not None:+ dependencies.append(DependenciesAnalysisService.analyze_model_provider_dependency(soul.model.model_provider))+ suggested_questions = soul.app_features.suggested_questions_after_answer+ if suggested_questions is not None and suggested_questions.model is not None:+ dependencies.append(+ DependenciesAnalysisService.analyze_model_provider_dependency(suggested_questions.model.provider)+ )+ for tool in soul.tools.dify_tools:+ provider_id = tool.provider_id or (+ f"{tool.plugin_id}/{tool.provider}" if tool.plugin_id and tool.provider else None+ )+ if provider_id:+ dependencies.append(DependenciesAnalysisService.analyze_tool_dependency(provider_id))+ for knowledge_set in soul.knowledge.sets:+ dependencies.extend(_extract_knowledge_retrieval_dependencies(knowledge_set.retrieval))+ dependencies.extend(_extract_metadata_filtering_dependencies(knowledge_set.metadata_filtering))+ return dependencies+++__all__ = ["extract_agent_soul_dependencies"]diff --git a/api/services/agent/dsl_entities.py b/api/services/agent/dsl_entities.pyindex 5fda1cfd92b..4231e6c4033 100644--- a/api/services/agent/dsl_entities.py+++ b/api/services/agent/dsl_entities.py@@ -3,12 +3,15 @@from __future__ import annotationsimport hashlib-from typing import Any, Literal+from typing import Any, Literal, Self-from pydantic import BaseModel, ConfigDict, Field+from pydantic import BaseModel, ConfigDict, Field, model_validator+from core.plugin.entities.plugin import PluginDependencyfrom models.agent import Agentfrom models.agent_config_entities import AgentSoulConfig+from models.model import App+from services.entities.dsl_entities import make_app_dslAGENT_PACKAGE_SCHEMA_VERSION = 1AGENT_PACKAGE_REF_KEY = "package_ref"@@ -59,6 +62,54 @@ class AgentPackage(BaseModel):workspace_skills: list[AgentPackageWorkspaceSkill] = Field(default_factory=list)+class AgentAppReference(BaseModel):+ model_config = ConfigDict(extra="forbid")++ package_ref: str = Field(min_length=1)+++class AgentAppDsl(BaseModel):+ """The existing standalone Agent App DSL, also stored as archive app.yaml."""++ model_config = ConfigDict(extra="forbid")++ version: str = Field(min_length=1)+ kind: Literal["app"]+ app: dict[str, Any]+ agent: AgentAppReference+ agent_packages: dict[str, AgentPackage]+ dependencies: list[PluginDependency] = Field(default_factory=list)++ @model_validator(mode="after")+ def validate_agent_app(self) -> Self:+ if self.app.get("mode") != "agent":+ raise ValueError("Agent App DSL requires app.mode=agent")+ if not isinstance(self.app.get("name"), str) or not self.app["name"]:+ raise ValueError("Agent App DSL requires an app name")+ if set(self.agent_packages) != {self.agent.package_ref}:+ raise ValueError("Agent App DSL must contain exactly the referenced Agent package")+ return self++ @property+ def package(self) -> AgentPackage:+ return self.agent_packages[self.agent.package_ref]+++def make_agent_app_dsl(+ app: App,+ *,+ package_ref: str,+ packages: dict[str, AgentPackage],+ dependencies: list[PluginDependency],+) -> AgentAppDsl:+ return AgentAppDsl(+ **make_app_dsl(app),+ agent=AgentAppReference(package_ref=package_ref),+ agent_packages=packages,+ dependencies=dependencies,+ )++def portable_ref(prefix: str, value: str) -> str:digest = hashlib.sha256(value.encode()).hexdigest()[:16]return f"{prefix}-{digest}"@@ -87,40 +138,15 @@ def _strip_sensitive_values(value: Any) -> Any:return result-def make_portable_agent_package(- agent: Agent,- agent_soul: AgentSoulConfig,- workspace_skills: list[AgentPackageWorkspaceSkill] | None = None,-) -> AgentPackage:- """Return a package safe to place in YAML or the system clipboard."""+def make_portable_agent_soul(agent_soul: AgentSoulConfig) -> AgentSoulConfig:+ """Return an Agent Soul without workspace-local credentials or identities.++ Resource references are intentionally preserved. Container formats decide+ whether to omit their payloads, as YAML DSL does, or remap them to+ package-local identifiers, as Roster packages do.+ """soul_data = agent_soul.model_dump(mode="json")- omitted_assets = [- AgentPackageOmittedAsset(- kind="skill",- name=item.name,- size=item.size,- hash=item.hash,- mime_type=item.mime_type,- )- for item in agent_soul.config_skills- ]- omitted_assets.extend(- AgentPackageOmittedAsset(- kind="file",- name=item.name,- size=item.size,- hash=item.hash,- mime_type=item.mime_type,- )- for item in agent_soul.config_files- )- for item in soul_data.get("config_skills", []):- item["file_id"] = ""- item["is_missing"] = True- for item in soul_data.get("config_files", []):- item["file_id"] = ""- item["is_missing"] = Trueif soul_data.get("model"):soul_data["model"]["credential_ref"] = None@@ -155,7 +181,53 @@ def make_portable_agent_package(for key in ("id", "contact_id", "human_id", "tenant_id"):contact[key] = None- portable_soul = AgentSoulConfig.model_validate(soul_data)+ return AgentSoulConfig.model_validate(soul_data)+++def make_portable_agent_package(+ agent: Agent,+ agent_soul: AgentSoulConfig,+ workspace_skills: list[AgentPackageWorkspaceSkill] | None = None,+ *,+ include_assets: bool = False,+) -> AgentPackage:+ """Return a portable package for YAML, clipboard, or an asset-bearing archive.++ Archives preserve package-local references to included assets; standalone+ YAML and clipboard exports mark resources missing because they omit payloads.+ """++ portable_soul = make_portable_agent_soul(agent_soul)+ omitted_assets = [+ AgentPackageOmittedAsset(+ kind="skill",+ name=item.name,+ size=item.size,+ hash=item.hash,+ mime_type=item.mime_type,+ )+ for item in agent_soul.config_skills+ if not include_assets or item.is_missing+ ]+ omitted_assets.extend(+ AgentPackageOmittedAsset(+ kind="file",+ name=item.name,+ size=item.size,+ hash=item.hash,+ mime_type=item.mime_type,+ )+ for item in agent_soul.config_files+ if not include_assets or item.is_missing+ )+ for skill_ref in portable_soul.config_skills:+ if not include_assets or skill_ref.is_missing:+ skill_ref.file_id = ""+ skill_ref.is_missing = True+ for file_ref in portable_soul.config_files:+ if not include_assets or file_ref.is_missing:+ file_ref.file_id = ""+ file_ref.is_missing = Trueicon_type = agent.icon_type.value if agent.icon_type is not None else Nonereturn AgentPackage(metadata=AgentPackageMetadata(diff --git a/api/services/agent/dsl_service.py b/api/services/agent/dsl_service.pyindex 454c887f901..4d56783296c 100644--- a/api/services/agent/dsl_service.py+++ b/api/services/agent/dsl_service.py@@ -41,6 +41,7 @@ from models.model import App, AppModelConfigfrom models.skill import AgentSkillBinding, AgentSkillBindingSnapshot, Skillfrom models.workflow import Workflowfrom services.agent.agent_soul_state import agent_soul_has_model+from services.agent.dependency_service import extract_agent_soul_dependenciesfrom services.agent.dsl_entities import (AGENT_NODE_JOB_DSL_KEY,AGENT_PACKAGE_REF_KEY,@@ -53,7 +54,6 @@ from services.agent.dsl_entities import (from services.agent.knowledge_datasets import get_tenant_knowledge_dataset_rowsfrom services.agent.roster_service import AgentRosterServicefrom services.entities.dsl_entities import DslImportWarning-from services.plugin.dependencies_analysis import DependenciesAnalysisServiceclass AgentPackageImportResult(BaseModel):@@ -375,29 +375,7 @@ class AgentDslService:def extract_package_dependencies(self, packages: Mapping[str, AgentPackage]) -> list[str]:dependencies: list[str] = []for package in packages.values():- soul = package.soul- if soul.model is not None:- dependencies.append(- DependenciesAnalysisService.analyze_model_provider_dependency(soul.model.model_provider)- )- for tool in soul.tools.dify_tools:- provider_id = tool.provider_id or (- f"{tool.plugin_id}/{tool.provider}" if tool.plugin_id and tool.provider else None- )- if provider_id:- dependencies.append(DependenciesAnalysisService.analyze_tool_dependency(provider_id))- for knowledge_set in soul.knowledge.sets:- retrieval = knowledge_set.retrieval- if retrieval.model is not None:- dependencies.append(- DependenciesAnalysisService.analyze_model_provider_dependency(retrieval.model.provider)- )- if retrieval.reranking_model is not None:- dependencies.append(- DependenciesAnalysisService.analyze_model_provider_dependency(- retrieval.reranking_model.provider- )- )+ dependencies.extend(extract_agent_soul_dependencies(package.soul))return dependenciesdef _workspace_skills_for_export(diff --git a/api/services/agent/errors.py b/api/services/agent/errors.pyindex 89875e4dc74..cda2656c197 100644--- a/api/services/agent/errors.py+++ b/api/services/agent/errors.py@@ -53,6 +53,24 @@ class AgentHomeSnapshotTooLargeError(BaseHTTPException):code = 413+class InvalidRosterAgentPackageError(BaseHTTPException):+ error_code = "invalid_roster_agent_package"+ description = "The Roster Agent package is invalid."+ code = 400+++class RosterAgentPackageTooLargeError(BaseHTTPException):+ error_code = "roster_agent_package_too_large"+ description = "The Roster Agent package exceeds the size limit."+ code = 413+++class RosterAgentPackageExportFailedError(BaseHTTPException):+ error_code = "roster_agent_package_export_failed"+ description = "The Roster Agent package could not be exported."+ code = 500++class AgentSoulLockedError(BadRequest):description = "Agent Soul is locked for this workflow node."diff --git a/api/services/agent/roster_package_entities.py b/api/services/agent/roster_package_entities.pynew file mode 100644index 00000000000..232a08e9675--- /dev/null+++ b/api/services/agent/roster_package_entities.py@@ -0,0 +1,202 @@+"""Strict data contract for portable Roster Agent archives."""++from __future__ import annotations++import re+from collections.abc import Mapping+from dataclasses import dataclass, field+from typing import BinaryIO, Final, Literal, Self++from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator++from services.agent.dsl_entities import AgentAppDsl++ROSTER_AGENT_PACKAGE_FORMAT: Final[Literal["dify.roster-agent"]] = "dify.roster-agent"+ROSTER_AGENT_PACKAGE_FORMAT_VERSION: Final[Literal[1]] = 1+ROSTER_AGENT_PACKAGE_MAX_SIGNATURE_BYTES = 64 * 1024++_SHA256_PATTERN = re.compile(r"^[0-9a-f]{64}$")+++@dataclass(frozen=True)+class RosterAgentPackageMember:+ size: int+ sha256: str+++class RosterAgentPackageAudit(BaseModel):+ model_config = ConfigDict(extra="forbid")++ ref: str = Field(min_length=1, max_length=255)+++class _RosterAgentPackageResource(BaseModel):+ model_config = ConfigDict(extra="forbid")++ path: str = Field(min_length=1, max_length=255)+ size: int = Field(ge=0)+ sha256: str+ audit: RosterAgentPackageAudit | None = None++ @field_validator("sha256")+ @classmethod+ def validate_sha256(cls, value: str) -> str:+ if _SHA256_PATTERN.fullmatch(value) is None:+ raise ValueError("sha256 must be a lowercase hexadecimal SHA-256 digest")+ return value+++class RosterAgentPackageApp(_RosterAgentPackageResource):+ @field_validator("path")+ @classmethod+ def validate_app_path(cls, value: str) -> str:+ if "/" in value or "\\" in value or not value.endswith((".yaml", ".yml")):+ raise ValueError("app path must be a root-level YAML member")+ if value.casefold() == "manifest.yaml":+ raise ValueError("app path must not use the package manifest name")+ return value+++class RosterAgentPackageSkill(_RosterAgentPackageResource):+ id: str = Field(pattern=r"^s_[0-9]{6}$")+ scope: Literal["agent_config", "workspace"]+ name: str = Field(min_length=1, max_length=64)++ @model_validator(mode="after")+ def validate_skill_path(self) -> Self:+ if self.path != f"{self.id}.zip":+ raise ValueError("skill path must be the resource id with a .zip extension")+ return self+++class RosterAgentPackageFile(_RosterAgentPackageResource):+ id: str = Field(pattern=r"^f_[0-9]{6}$")++ @model_validator(mode="after")+ def validate_file_metadata(self) -> Self:+ if self.path == self.id or not self.path.startswith(f"{self.id}."):+ raise ValueError("file path must start with the resource id and include an extension")+ if "/" in self.path or "\\" in self.path:+ raise ValueError("file path must be a root-level archive member")+ return self+++class RosterAgentPackageManifest(BaseModel):+ """Package metadata and resource index stored in ``manifest.yaml``."""++ model_config = ConfigDict(extra="forbid")++ format: Literal["dify.roster-agent"]+ format_version: Literal[1]+ audit: RosterAgentPackageAudit | None = None+ apps: list[RosterAgentPackageApp] = Field(min_length=1)+ skills: list[RosterAgentPackageSkill] = Field(default_factory=list)+ files: list[RosterAgentPackageFile] = Field(default_factory=list)++ @model_validator(mode="after")+ def validate_resource_index(self) -> Self:+ ids = [item.id for item in self.skills] + [item.id for item in self.files]+ if len(ids) != len(set(ids)):+ raise ValueError("resource ids must be unique")+ paths = [item.path.casefold() for item in [*self.apps, *self.skills, *self.files]]+ if len(paths) != len(set(paths)):+ raise ValueError("resource paths must be unique")+ skill_names = [item.name for item in self.skills]+ if len(skill_names) != len(set(skill_names)):+ raise ValueError("skill names must be unique after workspace Skills are localized")++ return self++ def validate_apps(self, apps: Mapping[str, AgentAppDsl]) -> None:+ """Resolve all application references against the shared resource index."""+ if set(apps) != {item.path for item in self.apps}:+ raise ValueError("app members must match the package app index")+ skill_by_id = {item.id: item for item in self.skills}+ file_by_id = {item.id: item for item in self.files}+ workspace_names = {item.name for item in self.skills if item.scope == "workspace"}+ referenced_skill_ids: set[str] = set()+ referenced_file_ids: set[str] = set()+ referenced_workspace_names: set[str] = set()+ for app in apps.values():+ if app.package.soul.schema_version != 1:+ raise ValueError("unsupported Agent Soul schema version")+ for skill_ref in app.package.soul.config_skills:+ if skill_ref.is_missing:+ continue+ skill_resource = skill_by_id.get(skill_ref.file_id)+ if skill_resource is None or skill_resource.scope != "agent_config":+ raise ValueError("config skill reference must resolve to an agent_config skill")+ if skill_resource.name != skill_ref.name:+ raise ValueError("config skill name must match its resource metadata")+ referenced_skill_ids.add(skill_resource.id)+ app_workspace_names = [item.name for item in app.package.workspace_skills]+ if len(app_workspace_names) != len(set(app_workspace_names)):+ raise ValueError("workspace skill names must be unique in the Agent DSL")+ if set(app_workspace_names) - workspace_names:+ raise ValueError("workspace skill references must match the package resource index")+ referenced_workspace_names.update(app_workspace_names)+ for file_ref in app.package.soul.config_files:+ if file_ref.is_missing:+ continue+ if file_ref.file_id not in file_by_id:+ raise ValueError("config file reference must resolve to a package file")+ referenced_file_ids.add(file_ref.file_id)+ if {item.id for item in self.skills if item.scope == "agent_config"} - referenced_skill_ids:+ raise ValueError("agent_config skill resources must be referenced by the Agent Soul")+ if workspace_names != referenced_workspace_names:+ raise ValueError("workspace skill references must match the package resource index")+ if set(file_by_id) - referenced_file_ids:+ raise ValueError("file resources must be referenced by the Agent Soul")+++@dataclass+class PreparedRosterAgentPackage:+ """Validated archive retained in a bounded spool for later materialization."""++ archive: BinaryIO+ manifest: RosterAgentPackageManifest+ apps: dict[str, AgentAppDsl]+ members: dict[str, RosterAgentPackageMember]+ invalid_skills: dict[str, str] = field(default_factory=dict)++ def close(self) -> None:+ self.archive.close()++ def __enter__(self) -> PreparedRosterAgentPackage:+ return self++ def __exit__(self, *_args: object) -> None:+ self.close()+++@dataclass+class RosterAgentPackageExport:+ """Download artifact owning its archive until the response closes."""++ archive: BinaryIO+ filename: str+ size: int++ def close(self) -> None:+ self.archive.close()++ def __enter__(self) -> RosterAgentPackageExport:+ return self++ def __exit__(self, *_args: object) -> None:+ self.close()+++__all__ = [+ "ROSTER_AGENT_PACKAGE_FORMAT",+ "ROSTER_AGENT_PACKAGE_FORMAT_VERSION",+ "ROSTER_AGENT_PACKAGE_MAX_SIGNATURE_BYTES",+ "PreparedRosterAgentPackage",+ "RosterAgentPackageApp",+ "RosterAgentPackageAudit",+ "RosterAgentPackageExport",+ "RosterAgentPackageFile",+ "RosterAgentPackageManifest",+ "RosterAgentPackageMember",+ "RosterAgentPackageSkill",+]diff --git a/api/services/agent/roster_package_exporter.py b/api/services/agent/roster_package_exporter.pynew file mode 100644index 00000000000..05d4f93e447--- /dev/null+++ b/api/services/agent/roster_package_exporter.py@@ -0,0 +1,468 @@+"""Export active Roster Agents as portable ``.ifpkg`` archives."""++from __future__ import annotations++import hashlib+import os+import re+import tempfile+import zipfile+from collections.abc import Callable, Generator, Sequence+from dataclasses import dataclass+from typing import BinaryIO, Literal, Protocol, cast++import yaml+from sqlalchemy import or_, select+from sqlalchemy.orm import Session++from configs import dify_config+from core.db.session_factory import session_factory+from core.plugin.entities.plugin import PluginDependency+from extensions.ext_storage import storage+from models.agent import (+ APP_BACKED_AGENT_SOURCES,+ Agent,+ AgentConfigDraft,+ AgentConfigDraftType,+ AgentConfigSnapshot,+ AgentScope,+ AgentStatus,+)+from models.agent_config_entities import AgentSoulConfig+from models.enums import AppStatus+from models.model import App, AppMode, UploadFile+from models.tools import ToolFile+from services.agent.dependency_service import extract_agent_soul_dependencies+from services.agent.dsl_entities import (+ AgentAppDsl,+ AgentPackageWorkspaceSkill,+ make_agent_app_dsl,+ make_portable_agent_package,+)+from services.agent.errors import (+ AgentNotFoundError,+ AgentVersionNotFoundError,+ RosterAgentPackageExportFailedError,+ RosterAgentPackageTooLargeError,+)+from services.agent.roster_package_entities import (+ ROSTER_AGENT_PACKAGE_FORMAT,+ ROSTER_AGENT_PACKAGE_FORMAT_VERSION,+ RosterAgentPackageApp,+ RosterAgentPackageAudit,+ RosterAgentPackageExport,+ RosterAgentPackageFile,+ RosterAgentPackageManifest,+ RosterAgentPackageSkill,+)+from services.agent.skill_package_service import SkillPackageError, SkillPackageService+from services.plugin.dependencies_analysis import DependenciesAnalysisService+from services.skill_management_service import RuntimeAgentSkillArchive, SkillManagementService+++class _Storage(Protocol):+ def load_stream(self, filename: str) -> Generator[bytes, None, None]: ...+++@dataclass(frozen=True)+class _SkillSource:+ path: str+ storage_key: str+ id: str+ scope: Literal["agent_config", "workspace"]+ name: str+ display_name: str | None+ description: str+ priority: int | None+ audit_ref: str+++@dataclass(frozen=True)+class _FileSource:+ path: str+ storage_key: str+ id: str+ audit_ref: str+++class RosterAgentPackageExporter:+ """Collect a Roster Agent through a dedicated read Session and build its archive."""++ def __init__(+ self,+ *,+ storage_backend: _Storage = storage,+ dependency_provider: Callable[[str, list[str]], list[PluginDependency]] | None = None,+ ) -> None:+ self._storage = storage_backend+ self._dependency_provider = dependency_provider or DependenciesAnalysisService.generate_dependencies++ def export(self, *, tenant_id: str, agent_id: str) -> RosterAgentPackageExport:+ with session_factory.create_session() as session:+ row = session.execute(+ select(Agent, App)+ .join(+ App,+ (App.id == Agent.app_id) & (App.tenant_id == Agent.tenant_id),+ )+ .where(+ Agent.id == agent_id,+ Agent.tenant_id == tenant_id,+ Agent.scope == AgentScope.ROSTER,+ Agent.source.in_(APP_BACKED_AGENT_SOURCES),+ Agent.status == AgentStatus.ACTIVE,+ Agent.app_id.is_not(None),+ or_(Agent.backing_app_id == Agent.app_id, Agent.backing_app_id.is_(None)),+ App.mode == AppMode.AGENT,+ App.status == AppStatus.NORMAL,+ )+ .limit(1)+ ).one_or_none()+ if row is None:+ raise AgentNotFoundError()+ agent, app_model = row++ draft = session.scalar(+ select(AgentConfigDraft)+ .where(+ AgentConfigDraft.tenant_id == tenant_id,+ AgentConfigDraft.agent_id == agent.id,+ AgentConfigDraft.draft_type == AgentConfigDraftType.DRAFT,+ AgentConfigDraft.draft_owner_key == "",+ )+ .limit(1)+ )+ if draft is not None:+ soul = AgentSoulConfig.model_validate(draft.config_snapshot_dict)+ else:+ snapshot = session.scalar(+ select(AgentConfigSnapshot)+ .where(+ AgentConfigSnapshot.id == agent.active_config_snapshot_id,+ AgentConfigSnapshot.tenant_id == tenant_id,+ AgentConfigSnapshot.agent_id == agent.id,+ )+ .limit(1)+ )+ if snapshot is None:+ raise AgentVersionNotFoundError()+ soul = AgentSoulConfig.model_validate(snapshot.config_snapshot_dict)++ resource_soul, skill_sources, file_sources = self._collect_payloads(+ session=session,+ tenant_id=tenant_id,+ soul=soul,+ )+ package = make_portable_agent_package(agent, resource_soul, include_assets=True)+ app = make_agent_app_dsl(app_model, package_ref="agent_1", packages={"agent_1": package}, dependencies=[])+ audit = RosterAgentPackageAudit(ref=agent.id)+ dependency_ids = extract_agent_soul_dependencies(package.soul)++ workspace_skills = SkillManagementService().list_runtime_agent_skill_archives(+ tenant_id=tenant_id,+ agent_id=agent_id,+ include_draft=draft is not None,+ )+ skill_sources.extend(+ self._workspace_skill_sources(+ soul=package.soul,+ archives=workspace_skills,+ start_index=len(skill_sources),+ )+ )+ package.workspace_skills = [+ AgentPackageWorkspaceSkill(+ name=item.name,+ display_name=item.display_name or "",+ description=item.description,+ priority=item.priority,+ )+ for item in skill_sources+ if item.scope == "workspace" and item.priority is not None+ ]+ app.dependencies = self._dependency_provider(tenant_id, dependency_ids)+ return self._build_archive(+ app=app,+ audit=audit,+ skill_sources=skill_sources,+ file_sources=file_sources,+ )++ def _build_archive(+ self,+ *,+ app: AgentAppDsl,+ skill_sources: Sequence[_SkillSource],+ file_sources: Sequence[_FileSource],+ audit: RosterAgentPackageAudit | None = None,+ ) -> RosterAgentPackageExport:+ required_entries = len(skill_sources) + len(file_sources) + 2+ if required_entries > dify_config.AGENT_PACKAGE_MAX_ENTRIES:+ raise RosterAgentPackageTooLargeError("Roster Agent package has too many members")++ # Ownership is transferred to RosterAgentPackageExport.+ output = cast(+ BinaryIO,+ tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b"), # noqa: SIM115+ )+ try:+ skills: list[RosterAgentPackageSkill] = []+ files: list[RosterAgentPackageFile] = []+ with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_STORED, allowZip64=True) as archive:+ total_size = 0+ nested_uncompressed_size = 0+ skill_packages = SkillPackageService()+ sources: list[_SkillSource | _FileSource] = [*skill_sources, *file_sources]+ for source in sources:+ remaining_bytes = dify_config.AGENT_PACKAGE_MAX_BYTES - total_size+ if isinstance(source, _SkillSource):+ remaining_bytes = min(remaining_bytes, dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024)+ member_size, member_digest = self._write_storage_member(+ archive, path=source.path, storage_key=source.storage_key, max_bytes=remaining_bytes+ )+ total_size += member_size+ if isinstance(source, _SkillSource):+ # Inspect only the embedded Skill; our writer already owns+ # the outer container, resource sizes, and digests.+ try:+ inspection = skill_packages.inspect(content=archive.read(source.path), filename=source.path)+ except SkillPackageError as exc:+ raise RosterAgentPackageExportFailedError(+ f"Roster Agent package contains unusable Skill {source.name!r}"+ ) from exc+ if inspection.name != source.name:+ raise RosterAgentPackageExportFailedError(+ f"Roster Agent package contains unusable Skill {source.name!r}: name mismatch"+ )+ nested_uncompressed_size += inspection.uncompressed_size+ if nested_uncompressed_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError(+ "Roster Agent package nested Skill contents exceed the size limit"+ )++ skills.append(+ RosterAgentPackageSkill(+ id=source.id,+ scope=source.scope,+ name=source.name,+ path=source.path,+ size=member_size,+ sha256=member_digest,+ audit=RosterAgentPackageAudit(ref=source.audit_ref),+ )+ )+ else:+ files.append(+ RosterAgentPackageFile(+ id=source.id,+ path=source.path,+ size=member_size,+ sha256=member_digest,+ audit=RosterAgentPackageAudit(ref=source.audit_ref),+ )+ )++ app_bytes = yaml.safe_dump(+ app.model_dump(mode="json", exclude_none=True), allow_unicode=True, sort_keys=False+ ).encode("utf-8")+ manifest = RosterAgentPackageManifest(+ format=ROSTER_AGENT_PACKAGE_FORMAT,+ format_version=ROSTER_AGENT_PACKAGE_FORMAT_VERSION,+ audit=audit,+ apps=[+ RosterAgentPackageApp(+ path="app.yaml", size=len(app_bytes), sha256=hashlib.sha256(app_bytes).hexdigest()+ )+ ],+ skills=skills,+ files=files,+ )+ manifest.validate_apps({"app.yaml": app})+ manifest_bytes = yaml.safe_dump(+ manifest.model_dump(mode="json", exclude_none=True), allow_unicode=True, sort_keys=False+ ).encode("utf-8")+ for path, document_bytes in (("app.yaml", app_bytes), ("manifest.yaml", manifest_bytes)):+ if len(document_bytes) > dify_config.AGENT_PACKAGE_MAX_MANIFEST_BYTES:+ raise RosterAgentPackageTooLargeError(f"Roster Agent package {path} exceeds the size limit")+ total_size += len(document_bytes)+ if total_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError("Roster Agent package exceeds the size limit")+ archive.writestr(path, document_bytes)++ size = output.tell()+ if size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError("Roster Agent package exceeds the archive size limit")+ output.seek(0)+ return RosterAgentPackageExport(+ archive=output,+ filename=f"{self._safe_slug(app.package.metadata.name)}.ifpkg",+ size=size,+ )+ except Exception:+ output.close()+ raise++ def _collect_payloads(+ self,+ *,+ session: Session,+ tenant_id: str,+ soul: AgentSoulConfig,+ ) -> tuple[AgentSoulConfig, list[_SkillSource], list[_FileSource]]:+ resource_data = soul.model_dump(mode="json")+ skill_sources: list[_SkillSource] = []+ file_sources: list[_FileSource] = []++ skill_file_ids = [item.file_id for item in soul.config_skills if not item.is_missing]+ tool_files = self._tool_files(session=session, tenant_id=tenant_id, file_ids=skill_file_ids)+ for skill_ref, portable_skill_ref in zip(soul.config_skills, resource_data["config_skills"]):+ if skill_ref.is_missing:+ continue+ resource_id = f"s_{len(skill_sources) + 1:06d}"+ tool_file = tool_files.get(skill_ref.file_id)+ if tool_file is None:+ raise RosterAgentPackageExportFailedError(f"Config skill {skill_ref.name!r} payload is unavailable")+ path = f"{resource_id}.zip"+ portable_skill_ref["file_id"] = resource_id+ portable_skill_ref["is_missing"] = False+ skill_sources.append(+ _SkillSource(+ path=path,+ storage_key=tool_file.file_key,+ id=resource_id,+ scope="agent_config",+ name=skill_ref.name,+ display_name=None,+ description=skill_ref.description,+ priority=None,+ audit_ref=tool_file.id,+ )+ )++ tool_file_refs = [+ item.file_id for item in soul.config_files if not item.is_missing and item.file_kind == "tool_file"+ ]+ upload_file_refs = [+ item.file_id for item in soul.config_files if not item.is_missing and item.file_kind == "upload_file"+ ]+ file_tool_files = self._tool_files(session=session, tenant_id=tenant_id, file_ids=tool_file_refs)+ upload_files = self._upload_files(session=session, tenant_id=tenant_id, file_ids=upload_file_refs)+ for file_ref, portable_file_ref in zip(soul.config_files, resource_data["config_files"]):+ if file_ref.is_missing:+ continue+ resource_id = f"f_{len(file_sources) + 1:06d}"+ extension = self._safe_extension(file_ref.name)+ path = f"{resource_id}{extension}"+ if file_ref.file_kind == "tool_file":+ tool_file = file_tool_files.get(file_ref.file_id)+ if tool_file is None:+ raise RosterAgentPackageExportFailedError(f"Config file {file_ref.name!r} payload is unavailable")+ storage_key = tool_file.file_key+ mime_type = file_ref.mime_type or tool_file.mimetype+ audit_ref = tool_file.id+ else:+ upload_file = upload_files.get(file_ref.file_id)+ if upload_file is None:+ raise RosterAgentPackageExportFailedError(f"Config file {file_ref.name!r} payload is unavailable")+ storage_key = upload_file.key+ mime_type = file_ref.mime_type or upload_file.mime_type+ audit_ref = upload_file.id+ portable_file_ref["file_id"] = resource_id+ portable_file_ref["is_missing"] = False+ portable_file_ref["mime_type"] = mime_type or "application/octet-stream"+ file_sources.append(+ _FileSource(+ path=path,+ storage_key=storage_key,+ id=resource_id,+ audit_ref=audit_ref,+ )+ )++ return AgentSoulConfig.model_validate(resource_data), skill_sources, file_sources++ @staticmethod+ def _workspace_skill_sources(+ *, soul: AgentSoulConfig, archives: Sequence[RuntimeAgentSkillArchive], start_index: int+ ) -> list[_SkillSource]:+ sources: list[_SkillSource] = []+ effective_skill_names = {item.name for item in soul.config_skills if not item.is_missing}+ for archive in sorted(archives, key=lambda item: item.priority):+ if archive.name in effective_skill_names:+ continue+ effective_skill_names.add(archive.name)+ resource_id = f"s_{start_index + len(sources) + 1:06d}"+ path = f"{resource_id}.zip"+ sources.append(+ _SkillSource(+ path=path,+ storage_key=archive.storage_key,+ id=resource_id,+ scope="workspace",+ name=archive.name,+ display_name=archive.display_name,+ description=archive.description,+ priority=archive.priority,+ audit_ref=archive.version_id,+ )+ )+ return sources++ @staticmethod+ def _tool_files(*, session: Session, tenant_id: str, file_ids: Sequence[str]) -> dict[str, ToolFile]:+ if not file_ids:+ return {}+ rows = session.scalars(+ select(ToolFile).where(ToolFile.tenant_id == tenant_id, ToolFile.id.in_(set(file_ids)))+ ).all()+ return {item.id: item for item in rows}++ @staticmethod+ def _upload_files(*, session: Session, tenant_id: str, file_ids: Sequence[str]) -> dict[str, UploadFile]:+ if not file_ids:+ return {}+ rows = session.scalars(+ select(UploadFile).where(UploadFile.tenant_id == tenant_id, UploadFile.id.in_(set(file_ids)))+ ).all()+ return {item.id: item for item in rows}++ def _write_storage_member(+ self,+ archive: zipfile.ZipFile,+ *,+ path: str,+ storage_key: str,+ max_bytes: int,+ ) -> tuple[int, str]:+ digest = hashlib.sha256()+ size = 0+ try:+ with archive.open(path, "w", force_zip64=True) as target:+ for chunk in self._storage.load_stream(storage_key):+ if not isinstance(chunk, bytes):+ raise TypeError("storage stream returned a non-bytes chunk")+ if size + len(chunk) > max_bytes:+ raise RosterAgentPackageTooLargeError("Roster Agent package payload exceeds the size limit")+ size += len(chunk)+ digest.update(chunk)+ target.write(chunk)+ except RosterAgentPackageTooLargeError:+ raise+ except Exception as exc:+ raise RosterAgentPackageExportFailedError(f"Unable to read package resource {path!r}") from exc+ return size, digest.hexdigest()++ @staticmethod+ def _safe_extension(filename: str) -> str:+ extension = os.path.splitext(filename)[1].lower()+ if not extension or not re.fullmatch(r"\.[a-z0-9]{1,16}", extension):+ return ".bin"+ return extension++ @staticmethod+ def _safe_slug(name: str) -> str:+ slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")+ return slug[:80] or "agent"+++__all__ = ["RosterAgentPackageExporter"]diff --git a/api/services/agent/roster_package_reader.py b/api/services/agent/roster_package_reader.pynew file mode 100644index 00000000000..2ef00ce3572--- /dev/null+++ b/api/services/agent/roster_package_reader.py@@ -0,0 +1,346 @@+"""Read and validate portable Roster Agent ``.ifpkg`` archives."""++from __future__ import annotations++import hashlib+import io+import posixpath+import stat+import tempfile+import zipfile+import zlib+from collections.abc import Hashable+from typing import Any, BinaryIO, cast, override++import yaml+from pydantic import ValidationError++from configs import dify_config+from constants.dsl_version import CURRENT_APP_DSL_VERSION+from services.agent.dsl_entities import AgentAppDsl+from services.agent.errors import InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError+from services.agent.roster_package_entities import (+ ROSTER_AGENT_PACKAGE_MAX_SIGNATURE_BYTES,+ PreparedRosterAgentPackage,+ RosterAgentPackageApp,+ RosterAgentPackageManifest,+ RosterAgentPackageMember,+ RosterAgentPackageSkill,+)+from services.agent.skill_package_service import SkillPackageError, SkillPackageService+from services.dsl_version import check_version_compatibility+from services.entities.dsl_entities import ImportStatus++_COPY_CHUNK_SIZE = 1024 * 1024+_ALLOWED_COMPRESSIONS = {zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED}+++class RosterAgentPackageReader:+ """Produce a validated, bounded package without external side effects."""++ def __init__(self) -> None:+ self._skill_packages = SkillPackageService()++ def read(self, source: BinaryIO) -> PreparedRosterAgentPackage:+ """Validate the container and record unusable Skill payloads for import warnings."""+ # Ownership is transferred to PreparedRosterAgentPackage.+ spool = cast(+ BinaryIO,+ tempfile.SpooledTemporaryFile(max_size=16 * 1024 * 1024, mode="w+b"), # noqa: SIM115+ )+ try:+ self._copy_bounded(source, spool)+ spool.seek(0)+ invalid_skills: dict[str, str] = {}+ manifest, apps, members = self._validate_archive(spool, invalid_skills=invalid_skills)+ spool.seek(0)+ return PreparedRosterAgentPackage(+ archive=spool, manifest=manifest, apps=apps, members=members, invalid_skills=invalid_skills+ )+ except Exception:+ spool.close()+ raise++ def read_member_bytes(self, package: PreparedRosterAgentPackage, path: str, *, max_bytes: int) -> bytes:+ """Read one already-validated member while rechecking its size and digest."""++ member = package.members.get(path)+ if member is None:+ raise InvalidRosterAgentPackageError("Roster Agent package member is unavailable")+ try:+ package.archive.seek(0)+ with zipfile.ZipFile(package.archive) as archive:+ info = archive.getinfo(path)+ payload, digest, _ = self._read_member(+ archive,+ info,+ collect=True,+ max_bytes=max_bytes,+ expected_size=member.size,+ )+ except (KeyError, OSError, zipfile.BadZipFile, EOFError, RuntimeError, ValueError, zlib.error) as exc:+ raise InvalidRosterAgentPackageError("Roster Agent package member is unavailable") from exc+ if digest != member.sha256:+ raise InvalidRosterAgentPackageError("Roster Agent package member failed integrity checks")+ return payload++ def _validate_archive(+ self, archive_file: BinaryIO, *, invalid_skills: dict[str, str]+ ) -> tuple[RosterAgentPackageManifest, dict[str, AgentAppDsl], dict[str, RosterAgentPackageMember]]:+ try:+ with zipfile.ZipFile(archive_file) as archive:+ infos = archive.infolist()+ if not infos:+ raise InvalidRosterAgentPackageError("Roster Agent package is empty")+ if len(infos) > dify_config.AGENT_PACKAGE_MAX_ENTRIES:+ raise InvalidRosterAgentPackageError("Roster Agent package has too many members")++ info_by_path: dict[str, zipfile.ZipInfo] = {}+ casefold_paths: set[str] = set()+ total_uncompressed = 0+ for info in infos:+ path = self._validate_member_info(info)+ if path in info_by_path or path.casefold() in casefold_paths:+ raise InvalidRosterAgentPackageError("Roster Agent package contains duplicate member paths")+ info_by_path[path] = info+ casefold_paths.add(path.casefold())+ total_uncompressed += info.file_size+ if total_uncompressed > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError("Roster Agent package uncompressed size exceeds the limit")++ manifest_data, manifest_size = self._read_yaml_document(archive, info_by_path, "manifest.yaml")+ try:+ manifest = RosterAgentPackageManifest.model_validate(manifest_data)+ except ValidationError as exc:+ raise InvalidRosterAgentPackageError("Roster Agent package manifest is invalid") from exc+ apps: dict[str, AgentAppDsl] = {}+ members: dict[str, RosterAgentPackageMember] = {}+ streamed_size = manifest_size+ for app_resource in manifest.apps:+ app_data, app_size = self._read_yaml_document(+ archive, info_by_path, app_resource.path, resource=app_resource+ )+ streamed_size += app_size+ if streamed_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError(+ "Roster Agent package uncompressed size exceeds the limit"+ )+ try:+ app = AgentAppDsl.model_validate(app_data)+ if check_version_compatibility(app.version, CURRENT_APP_DSL_VERSION) in {+ ImportStatus.FAILED,+ ImportStatus.PENDING,+ }:+ raise ValueError("unsupported App DSL version")+ except ValueError as exc:+ raise InvalidRosterAgentPackageError("Roster Agent package app is invalid") from exc+ apps[app_resource.path] = app+ members[app_resource.path] = RosterAgentPackageMember(size=app_size, sha256=app_resource.sha256)+ try:+ manifest.validate_apps(apps)+ except ValueError as exc:+ raise InvalidRosterAgentPackageError("Roster Agent package app is invalid") from exc++ expected_paths = {+ "manifest.yaml",+ *(item.path for item in manifest.apps),+ *(item.path for item in manifest.skills),+ *(item.path for item in manifest.files),+ }+ actual_paths = set(info_by_path)+ if "signature.sig" in actual_paths:+ if info_by_path["signature.sig"].file_size > ROSTER_AGENT_PACKAGE_MAX_SIGNATURE_BYTES:+ raise RosterAgentPackageTooLargeError("Roster Agent package signature is too large")+ actual_paths.remove("signature.sig")+ if actual_paths != expected_paths:+ raise InvalidRosterAgentPackageError("Roster Agent package members do not match the manifest")++ nested_uncompressed_size = 0+ signature_info = info_by_path.get("signature.sig")+ if signature_info is not None:+ _, _, signature_size = self._read_member(+ archive,+ signature_info,+ collect=False,+ max_bytes=min(+ ROSTER_AGENT_PACKAGE_MAX_SIGNATURE_BYTES,+ dify_config.AGENT_PACKAGE_MAX_BYTES - streamed_size,+ ),+ expected_size=signature_info.file_size,+ )+ streamed_size += signature_size+ for resource in [*manifest.skills, *manifest.files]:+ info = info_by_path[resource.path]+ payload = b""+ remaining_package_bytes = dify_config.AGENT_PACKAGE_MAX_BYTES - streamed_size+ if isinstance(resource, RosterAgentPackageSkill):+ max_skill_bytes = dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024+ if info.file_size > max_skill_bytes:+ raise RosterAgentPackageTooLargeError(+ f"Roster Agent package Skill {resource.name!r} exceeds the size limit"+ )+ try:+ payload, digest, actual_size = self._read_member(+ archive,+ info,+ collect=True,+ max_bytes=min(max_skill_bytes, remaining_package_bytes),+ expected_size=resource.size,+ )+ except (InvalidRosterAgentPackageError, zipfile.BadZipFile, EOFError, zlib.error):+ invalid_skills[resource.id] = "archive_integrity_failed"+ streamed_size += info.file_size+ continue+ else:+ _, digest, actual_size = self._read_member(+ archive,+ info,+ collect=False,+ max_bytes=remaining_package_bytes,+ expected_size=resource.size,+ )+ streamed_size += actual_size+ if digest != resource.sha256:+ if isinstance(resource, RosterAgentPackageSkill):+ invalid_skills[resource.id] = "checksum_mismatch"+ continue+ raise InvalidRosterAgentPackageError(+ f"Roster Agent package resource {resource.path!r} failed integrity checks",+ )+ members[resource.path] = RosterAgentPackageMember(+ size=resource.size,+ sha256=digest,+ )+ if isinstance(resource, RosterAgentPackageSkill):+ try:+ inspection = self._skill_packages.inspect(content=payload, filename=resource.path)+ except SkillPackageError as exc:+ invalid_skills[resource.id] = exc.code+ continue+ nested_uncompressed_size += inspection.uncompressed_size+ if nested_uncompressed_size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError(+ "Roster Agent package nested Skill contents exceed the size limit"+ )+ if inspection.name != resource.name:+ invalid_skills[resource.id] = "skill_name_mismatch"+ return manifest, apps, members+ except (InvalidRosterAgentPackageError, RosterAgentPackageTooLargeError):+ raise+ except (OSError, zipfile.BadZipFile, EOFError, RuntimeError, ValueError, zlib.error) as exc:+ raise InvalidRosterAgentPackageError("Roster Agent package is not a valid ZIP") from exc++ @staticmethod+ def _copy_bounded(source: BinaryIO, target: BinaryIO) -> None:+ size = 0+ while True:+ chunk = source.read(_COPY_CHUNK_SIZE)+ if not chunk:+ break+ if not isinstance(chunk, bytes):+ raise InvalidRosterAgentPackageError("Roster Agent package must be binary")+ size += len(chunk)+ if size > dify_config.AGENT_PACKAGE_MAX_BYTES:+ raise RosterAgentPackageTooLargeError("Roster Agent package exceeds the archive size limit")+ target.write(chunk)++ @staticmethod+ def _validate_member_info(info: zipfile.ZipInfo) -> str:+ name = info.filename+ if info.is_dir():+ raise InvalidRosterAgentPackageError("Roster Agent package must use root-level files")+ if "\x00" in name or "\\" in name or any(ord(char) < 0x20 for char in name):+ raise InvalidRosterAgentPackageError("Roster Agent package contains an unsafe path")+ normalized = posixpath.normpath(name)+ if normalized != name or normalized in {"", ".", ".."} or normalized.startswith("/") or "/" in normalized:+ raise InvalidRosterAgentPackageError("Roster Agent package contains an unsafe path")+ if stat.S_ISLNK(info.external_attr >> 16):+ raise InvalidRosterAgentPackageError("Roster Agent package must not contain symbolic links")+ if info.flag_bits & 0x1:+ raise InvalidRosterAgentPackageError("Roster Agent package must not contain encrypted members")+ if info.compress_type not in _ALLOWED_COMPRESSIONS:+ raise InvalidRosterAgentPackageError("Roster Agent package uses unsupported compression")+ if info.file_size and info.compress_size == 0:+ raise InvalidRosterAgentPackageError("Roster Agent package contains invalid ZIP metadata")+ return normalized++ @staticmethod+ def _read_member(+ archive: zipfile.ZipFile,+ info: zipfile.ZipInfo,+ *,+ collect: bool,+ max_bytes: int,+ expected_size: int,+ ) -> tuple[bytes, str, int]:+ digest = hashlib.sha256()+ output = io.BytesIO() if collect else None+ size = 0+ with archive.open(info) as member:+ while chunk := member.read(_COPY_CHUNK_SIZE):+ size += len(chunk)+ if size > max_bytes:+ raise RosterAgentPackageTooLargeError("Roster Agent package member exceeds the size limit")+ if size > expected_size:+ raise InvalidRosterAgentPackageError("Roster Agent package member failed integrity checks")+ digest.update(chunk)+ if output is not None:+ output.write(chunk)+ if size != expected_size:+ raise InvalidRosterAgentPackageError("Roster Agent package member failed integrity checks")+ return output.getvalue() if output is not None else b"", digest.hexdigest(), size++ def _read_yaml_document(+ self,+ archive: zipfile.ZipFile,+ infos: dict[str, zipfile.ZipInfo],+ path: str,+ *,+ resource: RosterAgentPackageApp | None = None,+ ) -> tuple[Any, int]:+ info = infos.get(path)+ if info is None:+ raise InvalidRosterAgentPackageError(f"Roster Agent package is missing {path}")+ if info.file_size > dify_config.AGENT_PACKAGE_MAX_MANIFEST_BYTES:+ raise RosterAgentPackageTooLargeError(f"Roster Agent package {path} exceeds the size limit")+ payload, digest, size = self._read_member(+ archive,+ info,+ collect=True,+ max_bytes=dify_config.AGENT_PACKAGE_MAX_MANIFEST_BYTES,+ expected_size=resource.size if resource is not None else info.file_size,+ )+ if resource is not None and digest != resource.sha256:+ raise InvalidRosterAgentPackageError(f"Roster Agent package {path} failed integrity checks")+ try:+ # The custom SafeLoader also rejects duplicate keys and aliases.+ return yaml.load(payload, Loader=_PackageYamlLoader), size # noqa: S506+ except (UnicodeDecodeError, yaml.YAMLError, ValueError, RecursionError) as exc:+ raise InvalidRosterAgentPackageError(+ f"Roster Agent package {path.removesuffix('.yaml')} is invalid"+ ) from exc+++class _PackageYamlLoader(yaml.SafeLoader):+ """Reject ambiguous mappings and aliases in untrusted package documents."""++ @override+ def compose_node(self, parent: yaml.Node | None, index: Any) -> yaml.Node | None:+ if self.check_event(yaml.AliasEvent):+ raise ValueError("YAML aliases are not supported")+ return super().compose_node(parent, index)++ @override+ def construct_mapping(self, node: yaml.MappingNode, deep: bool = False) -> dict[Hashable, Any]:+ result: dict[Hashable, Any] = {}+ for key_node, value_node in node.value:+ key = self.construct_object(key_node, deep=deep)+ if not isinstance(key, str):+ raise ValueError("YAML mapping keys must be strings")+ if key in result:+ raise ValueError(f"duplicate YAML key: {key}")+ result[key] = self.construct_object(value_node, deep=deep)+ return result+++__all__ = ["RosterAgentPackageReader"]diff --git a/api/services/agent/skill_package_service.py b/api/services/agent/skill_package_service.pyindex 42c48d2f26d..c275b2a169d 100644--- a/api/services/agent/skill_package_service.py+++ b/api/services/agent/skill_package_service.py@@ -20,16 +20,14 @@ import ioimport posixpathimport zipfileimport zlib+from dataclasses import dataclassimport yamlfrom pydantic import BaseModel, Field, ValidationError, field_validatorfrom configs import dify_config+from libs.zip_filename_recovery import open_zip_with_replacement_names-# Bounds — generous but finite so a hostile upload can't exhaust memory/disk.-_MAX_UNCOMPRESSED_BYTES = 200 * 1024 * 1024-_MAX_SKILL_MD_BYTES = 1 * 1024 * 1024-_MAX_ENTRIES = 5000_ALLOWED_EXTENSIONS = (".zip", ".skill")_SKILL_MD_NAME = "SKILL.md"_SKILL_NAME_PATTERN = r"^[a-z0-9]+(?:-[a-z0-9]+)*$"@@ -50,15 +48,9 @@ class SkillPackageError(Exception):self.status_code = status_code-class SkillManifest(BaseModel):- """Validated metadata extracted from a Skill package."""-+class _SkillMetadata(BaseModel):name: str = Field(min_length=1, max_length=64, pattern=_SKILL_NAME_PATTERN)description: str = Field(min_length=1, max_length=_MAX_SKILL_DESCRIPTION_LENGTH)- entry_path: str # path of SKILL.md inside the archive- files: list[str] # all (safe) file paths inside the archive- size: int # total uncompressed bytes- hash: str # sha256 of the archive bytes@field_validator("name", "description", mode="before")@classmethod@@ -66,18 +58,44 @@ class SkillManifest(BaseModel):return value.strip() if isinstance(value, str) else value+class SkillPackageInspection(_SkillMetadata):+ """Metadata read without rebuilding or fully extracting a Skill archive."""++ uncompressed_size: int = Field(ge=0)+++class SkillManifest(_SkillMetadata):+ """Validated metadata extracted from a Skill package."""++ entry_path: str # path of SKILL.md inside the archive+ files: list[str] # all (safe) file paths inside the archive+ size: int # total uncompressed bytes+ hash: str # sha256 of the archive bytes++class NormalizedSkillPackage(BaseModel):"""Canonical skill package bytes and metadata ready to store as Agent config."""manifest: SkillManifestarchive_bytes: bytes+++@dataclass(frozen=True)+class _InspectedSkillArchive:+ metadata: SkillPackageInspection+ normalized_members: dict[str, zipfile.ZipInfo]skill_md_bytes: bytes- strip_prefix: str | Noneclass SkillPackageService:"""Validate Skill archives and produce a normalized package."""+ def inspect(self, *, content: bytes, filename: str) -> SkillPackageInspection:+ """Validate archive metadata and SKILL.md without rebuilding the archive."""+ archive = self._open_archive(content=content, filename=filename)+ with archive:+ return self._inspect_archive(archive).metadata+def validate_and_normalize(self, *, content: bytes, filename: str) -> NormalizedSkillPackage:"""Return the canonical package for an uploaded skill archive.@@ -89,43 +107,30 @@ class SkillPackageService:The returned manifest is normalized to archive-root ``SKILL.md`` and itshash describes the rebuilt archive bytes. Member read/decompressionfailures while consuming the archive are mapped to ``invalid_archive``.+ Malformed UTF-8 member names are decoded with replacement characters;+ recovered path collisions still fail the normal duplicate-path check."""archive = self._open_archive(content=content, filename=filename)with archive:- members = self._collect_file_members(archive)- member_paths = [safe_path for _, safe_path in members]- entry_path = self._find_skill_md(member_paths)- strip_prefix = self._skill_root_prefix(entry_path)- normalized_members = self._normalize_members(- members=members,- skill_root_prefix=strip_prefix,- ignore_outside_selected_root=self._can_strip_single_top_level_folder(- paths=member_paths, entry_path=entry_path- ),- )- skill_md_member = normalized_members[_SKILL_MD_NAME]- self._validate_skill_md_size(skill_md_member)- raw_skill_md_bytes = self._read_member_bytes_from_archive(archive, member_info=skill_md_member)- skill_md = self._decode_skill_md(raw_skill_md_bytes)- skill_md_bytes = skill_md.encode("utf-8")+ inspection = self._inspect_archive(archive)normalized_archive_bytes = self._build_normalized_archive(archive=archive,- normalized_members=normalized_members,- skill_md_bytes=skill_md_bytes,- )- normalized_size = sum(- len(skill_md_bytes) if path == _SKILL_MD_NAME else max(info.file_size, 0)- for path, info in normalized_members.items()+ normalized_members=inspection.normalized_members,+ skill_md_bytes=inspection.skill_md_bytes,)- name, description = self._parse_skill_md(skill_md)+ if len(normalized_archive_bytes) > dify_config.UPLOAD_SKILL_FILE_SIZE_LIMIT * 1024 * 1024:+ raise SkillPackageError("archive_too_large", "normalized skill archive exceeds size limit", status_code=400)try:manifest = SkillManifest(- name=name,- description=description,+ name=inspection.metadata.name,+ description=inspection.metadata.description,entry_path=_SKILL_MD_NAME,- files=sorted(normalized_members),- size=normalized_size,+ files=sorted(inspection.normalized_members),+ size=sum(+ len(inspection.skill_md_bytes) if path == _SKILL_MD_NAME else info.file_size+ for path, info in inspection.normalized_members.items()+ ),hash=hashlib.sha256(normalized_archive_bytes).hexdigest(),)except ValidationError as exc:@@ -133,8 +138,38 @@ class SkillPackageService:return NormalizedSkillPackage(manifest=manifest,archive_bytes=normalized_archive_bytes,+ )++ def _inspect_archive(self, archive: zipfile.ZipFile) -> _InspectedSkillArchive:+ members = self._collect_file_members(archive)+ member_paths = [safe_path for _, safe_path in members]+ entry_path = self._find_skill_md(member_paths)+ strip_prefix = self._skill_root_prefix(entry_path)+ normalized_members = self._normalize_members(+ members=members,+ skill_root_prefix=strip_prefix,+ ignore_outside_selected_root=self._can_strip_single_top_level_folder(+ paths=member_paths, entry_path=entry_path+ ),+ )+ skill_md_member = normalized_members[_SKILL_MD_NAME]+ self._validate_skill_md_size(skill_md_member)+ raw_skill_md_bytes = self._read_member_bytes_from_archive(archive, member_info=skill_md_member)+ skill_md = self._decode_skill_md(raw_skill_md_bytes)+ skill_md_bytes = skill_md.encode("utf-8")+ name, description = self._parse_skill_md(skill_md)+ try:+ metadata = SkillPackageInspection(+ name=name,+ description=description,+ uncompressed_size=sum(info.file_size for info, _ in members),+ )+ except ValidationError as exc:+ raise self._manifest_validation_error(exc) from exc+ return _InspectedSkillArchive(+ metadata=metadata,+ normalized_members=normalized_members,skill_md_bytes=skill_md_bytes,- strip_prefix=strip_prefix,)@staticmethod@@ -171,21 +206,24 @@ class SkillPackageService:raise SkillPackageError("archive_too_large", "skill archive exceeds size limit", status_code=400)try:- return zipfile.ZipFile(io.BytesIO(content))+ return open_zip_with_replacement_names(content)except zipfile.BadZipFile as exc:raise SkillPackageError("invalid_archive", "skill archive is not a valid zip", status_code=400) from excdef _collect_file_members(self, archive: zipfile.ZipFile) -> list[tuple[zipfile.ZipInfo, str]]:- infos = [info for info in archive.infolist() if not info.is_dir()]- if len(infos) > _MAX_ENTRIES:+ archive_infos = archive.infolist()+ if len(archive_infos) > dify_config.SKILL_PACKAGE_MAX_ENTRIES:raise SkillPackageError("too_many_entries", "skill archive has too many files", status_code=400)+ infos = [info for info in archive_infos if not info.is_dir()]members: list[tuple[zipfile.ZipInfo, str]] = []total_uncompressed = 0for info in infos:members.append((info, self._safe_member_path(info.filename)))- total_uncompressed += max(info.file_size, 0)- if total_uncompressed > _MAX_UNCOMPRESSED_BYTES:+ total_uncompressed += info.file_size+ if info.file_size and info.compress_size == 0:+ raise SkillPackageError("invalid_archive", "skill package has invalid ZIP metadata", status_code=400)+ if total_uncompressed > dify_config.SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES:raise SkillPackageError("archive_too_large","skill archive uncompressed size exceeds limit",@@ -225,12 +263,8 @@ class SkillPackageService:else:normalized_path = safe_path- if (- not normalized_path- or normalized_path in {".", ".."}- or normalized_path.startswith("/")- or "\\" in normalized_path- ):+ # Paths are already normalized and safe; "." is not a file.+ if normalized_path == ".":raise SkillPackageError("unsafe_path", "skill archive contains an unsafe path", status_code=400)if normalized_path in normalized_members:raise SkillPackageError(@@ -306,7 +340,7 @@ class SkillPackageService:@staticmethoddef _validate_skill_md_size(member_info: zipfile.ZipInfo) -> None:- if member_info.file_size > _MAX_SKILL_MD_BYTES:+ if member_info.file_size > dify_config.SKILL_PACKAGE_MAX_SKILL_MD_BYTES:raise SkillPackageError("skill_md_too_large", "SKILL.md exceeds size limit", status_code=400)@staticmethod@@ -343,4 +377,10 @@ class SkillPackageService:return loaded if isinstance(loaded, dict) else {}-__all__ = ["NormalizedSkillPackage", "SkillManifest", "SkillPackageError", "SkillPackageService"]+__all__ = [+ "NormalizedSkillPackage",+ "SkillManifest",+ "SkillPackageError",+ "SkillPackageInspection",+ "SkillPackageService",+]diff --git a/api/services/agent_config_service.py b/api/services/agent_config_service.pyindex e4bfe2a0b9e..56a1ecb342b 100644--- a/api/services/agent_config_service.py+++ b/api/services/agent_config_service.py@@ -609,7 +609,7 @@ class AgentConfigService:)self._require_writable(target, surface=surface)try:- skill_ref, _package = self._skill_normalizer.normalize(+ skill_ref = self._skill_normalizer.normalize(content=content,filename=filename,requested_name=None,@@ -1064,7 +1064,7 @@ class AgentConfigService:)archive_bytes = storage.load_once(tool_file.file_key)try:- skill_ref, _package = self._skill_normalizer.normalize(+ skill_ref = self._skill_normalizer.normalize(content=archive_bytes,filename=tool_file.name,requested_name=name,diff --git a/api/services/app_dsl_service.py b/api/services/app_dsl_service.pyindex 4c9f10729a0..75b74b9a42e 100644--- a/api/services/app_dsl_service.py+++ b/api/services/app_dsl_service.py@@ -47,7 +47,8 @@ from models import Account, App, AppModefrom models.agent import AgentScopefrom models.model import AppModelConfig, AppModelConfigDict, IconType, load_annotation_reply_configfrom models.workflow import Workflow-from services.agent.dsl_service import AgentDslService, AgentPackage+from services.agent.dsl_entities import AgentPackage, make_agent_app_dsl+from services.agent.dsl_service import AgentDslServicefrom services.agent.retirement_service import WorkflowAgentRetirementServicefrom services.agent.workflow_publish_service import WorkflowAgentPublishServicefrom services.dsl_content import DSL_MAX_SIZE, dsl_content_size@@ -60,6 +61,7 @@ from services.entities.dsl_entities import (ImportMode,ImportStatus,PendingImportOwner,+ make_app_dsl,)from services.errors.account import NoPermissionErrorfrom services.errors.app import WorkflowNotFoundError@@ -762,44 +764,29 @@ class AppDslService:"""app_mode = AppMode.value_of(app_model.mode)- export_data: dict[str, Any] = {- "version": CURRENT_DSL_VERSION,- "kind": "app",- "app": {- "name": app_model.name,- "mode": app_model.mode.value if isinstance(app_model.mode, AppMode) else app_model.mode,- "icon": app_model.icon,- "icon_type": (- app_model.icon_type.value if isinstance(app_model.icon_type, IconType) else app_model.icon_type- ),- "icon_background": app_model.icon_background,- "description": app_model.description,- "use_icon_as_answer_icon": app_model.use_icon_as_answer_icon,- },- }-- if app_mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:- cls._append_workflow_export_data(- export_data=export_data,- app_model=app_model,- include_secret=include_secret,- workflow_id=workflow_id,- session=session,- )- elif app_mode == AppMode.AGENT:+ if app_mode == AppMode.AGENT:package_ref, packages = AgentDslService(session).export_agent_app(app=app_model)- export_data["agent"] = {"package_ref": package_ref}- export_data["agent_packages"] = {key: package.model_dump(mode="json") for key, package in packages.items()}dependencies = AgentDslService(session).extract_package_dependencies(packages)- export_data["dependencies"] = [- jsonable_encoder(item.model_dump())- for item in DependenciesAnalysisService.generate_dependencies(- tenant_id=app_model.tenant_id,- dependencies=dependencies,- )- ]+ export_data = make_agent_app_dsl(+ app_model,+ package_ref=package_ref,+ packages=packages,+ dependencies=DependenciesAnalysisService.generate_dependencies(+ tenant_id=app_model.tenant_id, dependencies=dependencies+ ),+ ).model_dump(mode="json")else:- cls._append_model_config_export_data(export_data, app_model, session=session)+ export_data = make_app_dsl(app_model)+ if app_mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:+ cls._append_workflow_export_data(+ export_data=export_data,+ app_model=app_model,+ include_secret=include_secret,+ workflow_id=workflow_id,+ session=session,+ )+ else:+ cls._append_model_config_export_data(export_data, app_model, session=session)return yaml.dump(export_data, allow_unicode=True)diff --git a/api/services/entities/dsl_entities.py b/api/services/entities/dsl_entities.pyindex 67bada2207e..3cdb0d5c42e 100644--- a/api/services/entities/dsl_entities.py+++ b/api/services/entities/dsl_entities.py@@ -3,7 +3,9 @@ from typing import Anyfrom pydantic import BaseModel, ConfigDict, Field+from constants.dsl_version import CURRENT_APP_DSL_VERSIONfrom core.plugin.entities.plugin import PluginDependency+from models.model import App, AppMode, IconTypeclass ImportMode(StrEnum):@@ -39,3 +41,20 @@ class DslImportWarning(BaseModel):class CheckDependenciesResult(BaseModel):leaked_dependencies: list[PluginDependency] = Field(default_factory=list)+++def make_app_dsl(app: App) -> dict[str, Any]:+ """Build the shared App DSL envelope for standalone and archive exports."""+ return {+ "version": CURRENT_APP_DSL_VERSION,+ "kind": "app",+ "app": {+ "name": app.name,+ "mode": app.mode.value if isinstance(app.mode, AppMode) else app.mode,+ "icon": app.icon,+ "icon_type": app.icon_type.value if isinstance(app.icon_type, IconType) else app.icon_type,+ "icon_background": app.icon_background,+ "description": app.description,+ "use_icon_as_answer_icon": app.use_icon_as_answer_icon,+ },+ }diff --git a/api/services/skill_management_service.py b/api/services/skill_management_service.pyindex b0731b82f3f..2c4bbe28060 100644--- a/api/services/skill_management_service.py+++ b/api/services/skill_management_service.py@@ -98,9 +98,6 @@ from services.file_service import FileServicelogger = logging.getLogger(__name__)_SKILL_MD = "SKILL.md"-_MAX_SKILL_BYTES = 200 * 1024 * 1024-_MAX_FILES_PER_SKILL = 5000-_MAX_ZIP_COMPRESSION_RATIO = 1000_MAX_FILE_CHECK_ITEMS = 100_MAX_SKILLS_PER_WORKSPACE = 500_MAX_AGENT_SKILLS = 20@@ -509,6 +506,20 @@ class PublishedSkillArchive:payload: bytes+@dataclass(frozen=True, slots=True)+class RuntimeAgentSkillArchive:+ skill_id: str+ version_id: str+ tool_file_id: str+ storage_key: str+ name: str+ display_name: str+ description: str+ priority: int+ size: int+ hash: str++@dataclass(frozen=True, slots=True)class SkillFileContent:filename: str@@ -2269,6 +2280,34 @@ class SkillManagementService:config_snapshot_id: str | None = None,) -> list[dict[str, Any]]:"""Return workspace Skills from the Agent draft or a published snapshot."""+ return [+ {+ "id": item.skill_id,+ "name": item.name,+ "file_id": item.tool_file_id,+ "description": item.description,+ "size": item.size,+ "hash": item.hash,+ "mime_type": "application/zip",+ }+ for item in self.list_runtime_agent_skill_archives(+ tenant_id=tenant_id,+ agent_id=agent_id,+ include_draft=include_draft,+ config_snapshot_id=config_snapshot_id,+ )+ ]++ def list_runtime_agent_skill_archives(+ self,+ *,+ tenant_id: str,+ agent_id: str,+ include_draft: bool = False,+ config_snapshot_id: str | None = None,+ ) -> list[RuntimeAgentSkillArchive]:+ """Return export-ready workspace Skill archives with published identity compatibility."""+with self._session_scope() as session:binding_model = AgentSkillBinding if include_draft else AgentSkillBindingSnapshotconditions = [@@ -2284,29 +2323,37 @@ class SkillManagementService:conditions.append(AgentSkillBindingSnapshot.config_snapshot_id == config_snapshot_id)rows = list(session.execute(- select(binding_model, Skill, SkillVersion)+ select(binding_model, Skill, SkillVersion, ToolFile).join(Skill, Skill.id == binding_model.skill_id).join(SkillVersion, SkillVersion.id == Skill.latest_published_version_id).join(Agent, Agent.id == binding_model.agent_id)+ .join(+ ToolFile,+ (ToolFile.id == SkillVersion.archive_tool_file_id) & (ToolFile.tenant_id == tenant_id),+ ).where(*conditions).order_by(Skill.name)))- return [- {- "id": skill.id,- "name": published_name,- "file_id": version.archive_tool_file_id,- "description": published_description,- "size": version.archive_size,- "hash": version.hash_code,- "mime_type": "application/zip",- }- for _binding, skill, version in rows- for published_name, _published_display_name, published_description in [- self._published_skill_identity(skill, version)- ]++ return [+ RuntimeAgentSkillArchive(+ skill_id=skill.id,+ version_id=version.id,+ tool_file_id=version.archive_tool_file_id,+ storage_key=tool_file.file_key,+ name=published_name,+ display_name=published_display_name,+ description=published_description,+ priority=binding.priority,+ size=version.archive_size,+ hash=version.hash_code,+ )+ for binding, skill, version, tool_file in rows+ for published_name, published_display_name, published_description in [+ self._published_skill_identity(skill, version)]+ ]def pull_runtime_agent_skill(self,@@ -3899,7 +3946,7 @@ class SkillManagementService:def _validate_archive_limits(archive: zipfile.ZipFile) -> list[zipfile.ZipInfo]:"""Validate ZIP metadata before any member is decompressed or persisted."""infos = archive.infolist()- if len(infos) > _MAX_FILES_PER_SKILL:+ if len(infos) > dify_config.SKILL_PACKAGE_MAX_ENTRIES:raise SkillManagementServiceError("too_many_files", "skill file count limit exceeded")total_uncompressed = 0@@ -3908,16 +3955,13 @@ class SkillManagementService:raise SkillManagementServiceError("invalid_skill_package", "skill package has invalid ZIP metadata")total_uncompressed += info.file_size- if total_uncompressed > _MAX_SKILL_BYTES:- raise SkillManagementServiceError("skill_too_large", "skill exceeds 200MB limit")+ if total_uncompressed > dify_config.SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES:+ raise SkillManagementServiceError("skill_too_large", "skill exceeds uncompressed size limit")if info.is_dir() or info.file_size == 0:continue- if info.compress_size == 0 or info.file_size / info.compress_size > _MAX_ZIP_COMPRESSION_RATIO:- raise SkillManagementServiceError(- "invalid_skill_package",- "skill package compression ratio exceeds the allowed limit",- )+ if info.compress_size == 0:+ raise SkillManagementServiceError("invalid_skill_package", "skill package has invalid ZIP metadata")return infosdef _draft_rows_from_archive_bytes(@@ -4107,7 +4151,7 @@ class SkillManagementService:)parent = posixpath.dirname(parent)- if len(entries_by_path) > _MAX_FILES_PER_SKILL:+ if len(entries_by_path) > dify_config.SKILL_PACKAGE_MAX_ENTRIES:raise SkillManagementServiceError("too_many_files", "skill file count limit exceeded")rows: list[SkillDraftFile] = []@@ -4140,8 +4184,8 @@ class SkillManagementService:))- if total_size > _MAX_SKILL_BYTES:- raise SkillManagementServiceError("skill_too_large", "skill exceeds 200MB limit")+ if total_size > dify_config.SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES:+ raise SkillManagementServiceError("skill_too_large", "skill exceeds uncompressed size limit")return rowsdef _sync_skill_metadata_from_draft_skill_md(self, *, skill: Skill, content: str) -> None:@@ -4401,8 +4445,8 @@ class SkillManagementService:@staticmethoddef _enforce_total_size(files: list[SkillDraftFile]) -> None:total = sum(file.size or 0 for file in {file.path: file for file in files}.values())- if total > _MAX_SKILL_BYTES:- raise SkillManagementServiceError("skill_too_large", "skill exceeds 200MB limit")+ if total > dify_config.SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES:+ raise SkillManagementServiceError("skill_too_large", "skill exceeds uncompressed size limit")@staticmethoddef _load_tool_file_bytes(*, tenant_id: str, file_id: str) -> bytes:@@ -4410,14 +4454,15 @@ class SkillManagementService:tool_file = session.scalar(select(ToolFile).where(ToolFile.tenant_id == tenant_id, ToolFile.id == file_id))if tool_file is None:raise SkillManagementServiceError("skill_archive_missing", "skill archive is missing", status_code=404)- try:- return storage.load_once(tool_file.file_key)- except (OSError, SQLAlchemyError) as exc:- raise SkillManagementServiceError(- "skill_archive_missing",- "skill archive is missing",- status_code=404,- ) from exc+ file_key = tool_file.file_key+ try:+ return storage.load_once(file_key)+ except (OSError, SQLAlchemyError) as exc:+ raise SkillManagementServiceError(+ "skill_archive_missing",+ "skill archive is missing",+ status_code=404,+ ) from exc@staticmethoddef _load_assistant_tool_file_bytes(*, tenant_id: str, file_id: str) -> bytes:diff --git a/api/tests/unit_tests/configs/test_dify_config.py b/api/tests/unit_tests/configs/test_dify_config.pyindex 8e9547ad68f..dd9f3313534 100644--- a/api/tests/unit_tests/configs/test_dify_config.py+++ b/api/tests/unit_tests/configs/test_dify_config.py@@ -64,7 +64,12 @@ class _IsolatedDifyConfig(DifyConfig):def _make_config(**values: object) -> DifyConfig:- return _IsolatedDifyConfig(**values)+ # Pydantic exposes a generated field-wise signature, while this helper intentionally forwards heterogeneous input.+ return _IsolatedDifyConfig(**values) # pyrefly: ignore[bad-argument-type]+++def test_skill_package_default_limit_matches_documentation() -> None:+ assert _make_config().UPLOAD_SKILL_FILE_SIZE_LIMIT == 50def test_dify_config_keeps_secret_key_empty_when_missing(tmp_path) -> None:diff --git a/api/tests/unit_tests/libs/test_zip_filename_recovery.py b/api/tests/unit_tests/libs/test_zip_filename_recovery.pynew file mode 100644index 00000000000..c06581434c0--- /dev/null+++ b/api/tests/unit_tests/libs/test_zip_filename_recovery.py@@ -0,0 +1,94 @@+import io+import struct+import zipfile++import pytest++from libs.zip_filename_recovery import open_zip_with_replacement_names+++def _zip64(monkeypatch: pytest.MonkeyPatch, limit: int) -> bytes:+ output = io.BytesIO()+ with monkeypatch.context() as scoped:+ scoped.setattr(zipfile, "ZIP64_LIMIT", limit)+ with zipfile.ZipFile(output, "w", allowZip64=True) as archive:+ archive.writestr("padding.txt", b"p" * 200)+ archive.writestr("scripts/\u00e9.py", b"print('ok')\n")+ content = output.getvalue()+ assert len(content) < 2048+ assert b"PK\x06\x06" in content+ return content++[email protected]("limit", [0, 100])[email protected]("prefix", [b"", b"self-extracting-prefix"])+def test_zip64_replaces_names_and_preserves_payload(monkeypatch: pytest.MonkeyPatch, limit: int, prefix: bytes) -> None:+ original = prefix + _zip64(monkeypatch, limit)+ with zipfile.ZipFile(io.BytesIO(original)) as archive:+ assert archive.read("scripts/\u00e9.py") == b"print('ok')\n"+ damaged = original.replace(b"\xc3\xa9.py", b"\xffa.py")+ with open_zip_with_replacement_names(damaged) as archive:+ assert archive.read("scripts/\ufffda.py") == b"print('ok')\n"+ assert archive.testzip() is None+++def test_zip64_uses_extended_values_when_legacy_fields_are_sentinels(monkeypatch: pytest.MonkeyPatch) -> None:+ content = bytearray(_zip64(monkeypatch, 0))+ end = content.rfind(b"PK\x05\x06")+ struct.pack_into("<HHII", content, end + 8, 0xFFFF, 0xFFFF, 0xFFFFFFFF, 0xFFFFFFFF)+ damaged = bytes(content).replace(b"\xc3\xa9.py", b"\xffa.py")+ with open_zip_with_replacement_names(damaged) as archive:+ assert archive.read("scripts/\ufffda.py") == b"print('ok')\n"+++def test_zip64_extensible_data_is_not_part_of_central_directory(monkeypatch: pytest.MonkeyPatch) -> None:+ content = bytearray(_zip64(monkeypatch, 0))+ record = content.rfind(b"PK\x06\x06")+ locator = content.rfind(b"PK\x06\x07")+ extension = b"extension"+ struct.pack_into("<Q", content, record + 4, 44 + len(extension))+ content[locator:locator] = extension+ damaged = bytes(content).replace(b"\xc3\xa9.py", b"\xffa.py")+ with open_zip_with_replacement_names(damaged) as archive:+ assert archive.read("scripts/\ufffda.py") == b"print('ok')\n"+++def test_zip64_recovery_preserves_crc_checks(monkeypatch: pytest.MonkeyPatch) -> None:+ content = _zip64(monkeypatch, 0)+ damaged = content.replace(b"\xc3\xa9.py", b"\xffa.py").replace(b"print('ok')", b"print('NO')")+ with open_zip_with_replacement_names(damaged) as archive:+ with pytest.raises(zipfile.BadZipFile, match="CRC"):+ archive.read("scripts/\ufffda.py")+++def test_zip64_recovery_rejects_mismatched_local_name(monkeypatch: pytest.MonkeyPatch) -> None:+ original = _zip64(monkeypatch, 0)+ directory = original.index(b"PK\x01\x02")+ damaged = original[:directory] + original[directory:].replace(b"\xc3\xa9.py", b"\xffa.py")+ with pytest.raises(zipfile.BadZipFile, match="names differ"):+ open_zip_with_replacement_names(damaged)+++def _damaged_utf8_zip() -> bytearray:+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w") as archive:+ archive.writestr("scripts/\u00e9.py", b"print('ok')\n")+ return bytearray(output.getvalue().replace(b"\xc3\xa9.py", b"\xffa.py"))++[email protected]("offset", [0xFFFFFFFF, 0xFFFFFFFE])+def test_recovery_rejects_unresolvable_local_header_offsets(offset: int) -> None:+ content = _damaged_utf8_zip()+ directory = content.index(b"PK\x01\x02")+ struct.pack_into("<I", content, directory + 42, offset)+ with pytest.raises(zipfile.BadZipFile, match="ZIP64 extra field|local header offset"):+ open_zip_with_replacement_names(bytes(content))++[email protected]("entries", [0, 2])+def test_recovery_rejects_inconsistent_directory_entry_counts(entries: int) -> None:+ content = _damaged_utf8_zip()+ end = content.rfind(b"PK\x05\x06")+ struct.pack_into("<HH", content, end + 8, entries, entries)+ with pytest.raises(zipfile.BadZipFile, match="directory bounds|directory length mismatch"):+ open_zip_with_replacement_names(bytes(content))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.pyindex c3a069f15d3..76f0f93e497 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@@ -124,7 +124,8 @@ def _agent_node(node_id: str, binding: object | None = None) -> dict:return {"id": node_id, "data": data}-def test_make_portable_agent_package_strips_workspace_credentials_and_assets() -> None:[email protected]("include_assets", [False, True])+def test_make_portable_agent_package_strips_workspace_credentials_and_assets(include_assets: bool) -> None:soul = AgentSoulConfig.model_validate({"model": {@@ -164,8 +165,10 @@ def test_make_portable_agent_package_strips_workspace_credentials_and_assets() -],},"env": {"secret_refs": [{"name": "GLOBAL_TOKEN", "value": "plain-secret", "id": "secret-1"}]},- "config_skills": [{"name": "research", "file_kind": "tool_file", "file_id": "skill-file"}],- "config_files": [{"name": "guide.md", "file_kind": "upload_file", "file_id": "config-file"}],+ "config_skills": [{"name": "research", "file_id": "skill-file"}, {"name": "missing", "is_missing": True}],+ "config_files": [+ {"name": "guide.md", "file_kind": "upload_file", "file_id": "config-file", "mime_type": "text/markdown"}+ ],"human": {"contacts": [{@@ -179,7 +182,9 @@ def test_make_portable_agent_package_strips_workspace_credentials_and_assets() -})- package = make_portable_agent_package(_agent(), soul)+ original = soul.model_dump(mode="json")+ package = make_portable_agent_package(_agent(), soul, include_assets=include_assets)+ assert soul.model_dump(mode="json") == originalserialized = package.model_dump(mode="json")assert package.soul.model is not None@@ -189,20 +194,32 @@ def test_make_portable_agent_package_strips_workspace_credentials_and_assets() -assert package.soul.tools.dify_tools[0].runtime_parameters["upload_file_id"] is Noneassert package.soul.tools.dify_tools[0].runtime_parameters["api_key"] is Noneassert package.soul.config_skills[0].name == "research"- assert package.soul.config_skills[0].file_id == ""- assert package.soul.config_skills[0].is_missing is True+ assert package.soul.config_skills[0].file_id == ("skill-file" if include_assets else "")+ assert package.soul.config_skills[0].is_missing is (not include_assets)assert package.soul.config_files[0].name == "guide.md"- assert package.soul.config_files[0].file_id == ""- assert package.soul.config_files[0].is_missing is True- assert [asset.kind for asset in package.omitted_assets] == ["skill", "file"]+ assert package.soul.config_files[0].file_id == ("config-file" if include_assets else "")+ assert package.soul.config_files[0].is_missing is (not include_assets)+ assert package.soul.config_skills[1].is_missing+ assert package.soul.config_files[0].mime_type == "text/markdown"+ assert [asset.kind for asset in package.omitted_assets] == (+ ["skill"] if include_assets else ["skill", "skill", "file"]+ )+ assert [asset.name for asset in package.omitted_assets] == (+ ["missing"] if include_assets else ["research", "missing", "guide.md"]+ )assert "plain-secret" not in str(serialized)assert "model-secret" not in str(serialized)assert "tool-secret" not in str(serialized)- assert "skill-file" not in str(serialized)- assert "config-file" not in str(serialized)+ assert ("skill-file" in str(serialized)) is include_assets+ assert ("config-file" in str(serialized)) is include_assetsassert package.soul.human.contacts[0].id is Noneassert package.soul.human.contacts[0].name == "Reviewer"+ package.soul.config_skills[0].description = "Changed"+ package.soul.config_files[0].name = "changed.md"+ package.soul.tools.cli_tools[0].env.secret_refs[0].name = "CHANGED"+ assert soul.model_dump(mode="json") == original+def test_agent_package_round_trips_as_strict_dsl_dto() -> None:package = make_portable_agent_package(_agent(), AgentSoulConfig())@@ -590,22 +607,28 @@ def test_clone_inline_binding_copies_soul(unbound_session: Session) -> None:assert create_kwargs["source"] == AgentSource.WORKFLOW-def test_extract_package_dependencies_covers_model_tools_and_knowledge(+def test_extract_package_dependencies_covers_models_features_tools_and_knowledge(monkeypatch: pytest.MonkeyPatch, unbound_session: Session) -> None:model_dependency = Mock(side_effect=lambda provider: f"model:{provider}")tool_dependency = Mock(side_effect=lambda provider: f"tool:{provider}")monkeypatch.setattr(- "services.agent.dsl_service.DependenciesAnalysisService.analyze_model_provider_dependency",+ "services.agent.dependency_service.DependenciesAnalysisService.analyze_model_provider_dependency",model_dependency,)monkeypatch.setattr(- "services.agent.dsl_service.DependenciesAnalysisService.analyze_tool_dependency",+ "services.agent.dependency_service.DependenciesAnalysisService.analyze_tool_dependency",tool_dependency,)soul = AgentSoulConfig.model_validate({"model": {"plugin_id": "model-plugin", "model_provider": "provider/model", "model": "model"},+ "app_features": {+ "suggested_questions_after_answer": {+ "enabled": True,+ "model": {"provider": "provider/follow-up", "name": "follow-up-model"},+ }+ },"tools": {"dify_tools": [{@@ -631,9 +654,49 @@ def test_extract_package_dependencies_covers_model_tools_and_knowledge("retrieval": {"mode": "single","model": {"provider": "provider/retrieval", "name": "embed", "mode": "embedding"},+ },+ "metadata_filtering": {+ "mode": "automatic",+ "model_config": {+ "provider": "provider/metadata",+ "name": "metadata-model",+ "mode": "chat",+ },+ },+ },+ {+ "id": "set-2",+ "name": "Reranked Set",+ "datasets": [{"id": "dataset-2", "name": "Reranked Docs"}],+ "query": {"mode": "user_query", "value": "query"},+ "retrieval": {+ "mode": "multiple",+ "top_k": 5,+ "reranking_enable": True,+ "reranking_mode": "reranking_model","reranking_model": {"provider": "provider/rerank", "model": "rerank"},},- }+ },+ {+ "id": "set-3",+ "name": "Weighted Set",+ "datasets": [{"id": "dataset-3", "name": "Weighted Docs"}],+ "query": {"mode": "user_query", "value": "query"},+ "retrieval": {+ "mode": "multiple",+ "top_k": 5,+ "reranking_enable": True,+ "reranking_mode": "weighted_score",+ "weights": {+ "vector_setting": {+ "embedding_provider_name": "provider/embedding",+ "embedding_model_name": "embedding-model",+ "vector_weight": 0.7,+ },+ "keyword_setting": {"keyword_weight": 0.3},+ },+ },+ },]},}@@ -645,13 +708,72 @@ def test_extract_package_dependencies_covers_model_tools_and_knowledge(assert dependencies == ["model:provider/model",+ "model:provider/follow-up","tool:provider/tool","tool:plugin-id/fallback-provider","model:provider/retrieval",+ "model:provider/metadata","model:provider/rerank",+ "model:provider/embedding",]+def test_extract_package_dependencies_ignores_inactive_knowledge_models(+ monkeypatch: pytest.MonkeyPatch, unbound_session: Session+) -> None:+ model_dependency = Mock(side_effect=lambda provider: f"model:{provider}")+ monkeypatch.setattr(+ "services.agent.dependency_service.DependenciesAnalysisService.analyze_model_provider_dependency",+ model_dependency,+ )+ soul = AgentSoulConfig.model_validate(+ {+ "knowledge": {+ "sets": [+ {+ "id": "set-1",+ "name": "Set",+ "datasets": [{"id": "dataset-1", "name": "Docs"}],+ "query": {"mode": "user_query", "value": "query"},+ "retrieval": {+ "mode": "multiple",+ "top_k": 5,+ "reranking_enable": False,+ "reranking_mode": "weighted_score",+ "reranking_model": {"provider": "provider/inactive-rerank", "model": "rerank"},+ "weights": {+ "vector_setting": {+ "embedding_provider_name": "provider/inactive-embedding",+ }+ },+ "model": {+ "provider": "provider/inactive-retrieval",+ "name": "retrieval-model",+ "mode": "chat",+ },+ },+ "metadata_filtering": {+ "mode": "disabled",+ "model_config": {+ "provider": "provider/inactive-metadata",+ "name": "metadata-model",+ "mode": "chat",+ },+ },+ }+ ]+ }+ }+ )++ dependencies = AgentDslService(unbound_session).extract_package_dependencies(+ {"agent_1": make_portable_agent_package(_agent(), soul)}+ )++ assert dependencies == []+ model_dependency.assert_not_called()++def test_create_imported_inline_agent_uses_import_provenance(unbound_session: Session) -> None:service = AgentDslService(unbound_session)soul = AgentSoulConfig(config_note="inline")diff --git a/api/tests/unit_tests/services/agent/test_agent_services.py b/api/tests/unit_tests/services/agent/test_agent_services.pyindex 90435a5ef12..43ed0043d64 100644--- a/api/tests/unit_tests/services/agent/test_agent_services.py+++ b/api/tests/unit_tests/services/agent/test_agent_services.py@@ -40,6 +40,7 @@ from models.agent_config_entities import (from models.enums import AppStatus, ConversationFromSource, ConversationStatusfrom models.model import App, AppMode, AppModelConfig, Conversation, IconType, Messagefrom models.skill import AgentSkillBindingSnapshot, Skill, SkillVersion, SkillVersionManifest+from models.tools import ToolFilefrom models.workflow import Workflow, WorkflowTypefrom services.agent import composer_service, roster_servicefrom services.agent.agent_soul_state import agent_soul_has_model@@ -5603,7 +5604,17 @@ class TestWorkflowAgentDraftBindingSync:skill_id="skill-1",priority=0,)- session.add_all([binding, agent, snapshot, skill, skill_version, skill_binding])+ archive_file = ToolFile(+ user_id="account-1",+ tenant_id="tenant-1",+ conversation_id=None,+ file_key="tools/research.zip",+ mimetype="application/zip",+ name="research.zip",+ size=1,+ )+ archive_file.id = "archive-1"+ session.add_all([binding, agent, snapshot, skill, skill_version, skill_binding, archive_file])session.commit()WorkflowAgentPublishService.validate_agent_nodes_for_publish(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.pynew file mode 100644index 00000000000..19c0f2ccec4--- /dev/null+++ b/api/tests/unit_tests/services/agent/test_roster_package_service.py@@ -0,0 +1,1387 @@+from __future__ import annotations++import hashlib+import io+import zipfile+from collections.abc import Callable, Generator++import pytest+import yaml+from flask import Flask, send_file+from pydantic import ValidationError+from sqlalchemy.orm import Session, sessionmaker++from configs import dify_config+from models.agent import (+ Agent,+ AgentConfigDraft,+ AgentConfigDraftType,+ AgentConfigSnapshot,+ AgentKind,+ AgentScope,+ AgentSource,+ AgentStatus,+)+from models.agent_config_entities import AgentSoulConfig+from models.enums import AppStatus+from models.model import App, AppMode, IconType+from models.skill import AgentSkillBindingSnapshot, Skill, SkillVersion, SkillVersionManifest+from models.tools import ToolFile+from services.agent import roster_package_exporter as roster_package_exporter_module+from services.agent.dsl_entities import AgentAppDsl, AgentPackage, AgentPackageMetadata, make_agent_app_dsl+from services.agent.errors import (+ InvalidRosterAgentPackageError,+ RosterAgentPackageExportFailedError,+ 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_exporter import RosterAgentPackageExporter+from services.agent.roster_package_reader import RosterAgentPackageReader+from services.app_dsl_service import AppDslService+from services.plugin.dependencies_analysis import DependenciesAnalysisService+from tests.unit_tests.config_override import apply_config_overrides+++class _MemoryStorage:+ def __init__(self, files: dict[str, bytes], *, before_read: Callable[[], None] | None = None) -> None:+ self.files = files+ self.before_read = before_read+ self.read_count = 0+ self.bytes_yielded: dict[str, int] = {}++ def load_stream(self, filename: str) -> Generator[bytes, None, None]:+ self.read_count += 1+ if self.before_read is not None:+ self.before_read()+ content = self.files[filename]+ for offset in range(0, len(content), 7):+ chunk = content[offset : offset + 7]+ self.bytes_yielded[filename] = self.bytes_yielded.get(filename, 0) + len(chunk)+ yield chunk+++def _zip(members: dict[str, bytes]) -> bytes:+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_DEFLATED) as archive:+ for path, payload in members.items():+ archive.writestr(path, payload)+ return output.getvalue()+++def _skill_archive(name: str = "research") -> bytes:+ return _zip(+ {+ "SKILL.md": (f"---\nname: {name}\ndescription: Research skill.\n---\n\n# Research\n").encode(),+ "scripts/run.py": b"print('ok')\n",+ }+ )+++def _package_app(soul: AgentSoulConfig | None = None) -> AgentAppDsl:+ soul = soul or AgentSoulConfig.model_validate(+ {+ "config_skills": [{"name": "research", "file_id": "s_000001"}],+ "config_files": [+ {+ "name": "guide.pdf",+ "file_kind": "tool_file",+ "file_id": "f_000001",+ }+ ],+ }+ )+ return make_agent_app_dsl(+ _app("app-1"),+ package_ref="agent_1",+ packages={"agent_1": AgentPackage(metadata=AgentPackageMetadata(name="Research Agent"), soul=soul)},+ dependencies=[],+ )+++def _yaml_bytes(document: RosterAgentPackageManifest | AgentAppDsl) -> bytes:+ return yaml.safe_dump(document.model_dump(mode="json", exclude_none=True)).encode()+++def _app_member(payload: bytes, path: str = "app.yaml") -> RosterAgentPackageApp:+ return RosterAgentPackageApp(path=path, size=len(payload), sha256=hashlib.sha256(payload).hexdigest())+++def _manifest(*, skill_payload: bytes, file_payload: bytes) -> RosterAgentPackageManifest:+ return RosterAgentPackageManifest(+ format=ROSTER_AGENT_PACKAGE_FORMAT,+ format_version=ROSTER_AGENT_PACKAGE_FORMAT_VERSION,+ apps=[_app_member(_yaml_bytes(_package_app()))],+ skills=[+ RosterAgentPackageSkill(+ id="s_000001",+ scope="agent_config",+ name="research",+ path="s_000001.zip",+ size=len(skill_payload),+ sha256=hashlib.sha256(skill_payload).hexdigest(),+ )+ ],+ files=[+ RosterAgentPackageFile(+ id="f_000001",+ path="f_000001.pdf",+ size=len(file_payload),+ sha256=hashlib.sha256(file_payload).hexdigest(),+ )+ ],+ )+++def _app(app_id: str) -> App:+ return App(+ id=app_id,+ tenant_id="tenant-1",+ name="Research Agent",+ description="",+ mode=AppMode.AGENT,+ icon_type=IconType.EMOJI,+ icon="R",+ icon_background="#FFFFFF",+ status=AppStatus.NORMAL,+ enable_site=False,+ enable_api=False,+ max_active_requests=None,+ created_by="account-1",+ )+++def _package_bytes(+ manifest: RosterAgentPackageManifest,+ *,+ skill_payload: bytes,+ file_payload: bytes,+ extra_members: dict[str, bytes] | None = None,+ app: AgentAppDsl | None = None,+) -> bytes:+ app_payload = (extra_members or {}).get("app.yaml", _yaml_bytes(app or _package_app()))+ manifest = manifest.model_copy(update={"apps": [_app_member(app_payload)]})+ return _zip(+ {+ "manifest.yaml": _yaml_bytes(manifest),+ "app.yaml": app_payload,+ "s_000001.zip": skill_payload,+ "f_000001.pdf": file_payload,+ **(extra_members or {}),+ }+ )+++def test_manifest_rejects_dangling_resource_references() -> None:+ manifest = RosterAgentPackageManifest(+ format=ROSTER_AGENT_PACKAGE_FORMAT,+ format_version=ROSTER_AGENT_PACKAGE_FORMAT_VERSION,+ apps=[_app_member(_yaml_bytes(_package_app()))],+ )+ with pytest.raises(ValueError, match="config skill reference must resolve"):+ manifest.validate_apps({"app.yaml": _package_app()})+++ ("overrides", "message"),+ [+ ({"path": "wrong.zip"}, "skill path must be"),+ ({"sha256": "not-a-digest"}, "sha256 must be"),+ ],+)+def test_skill_resource_rejects_invalid_metadata(overrides: dict[str, object], message: str) -> None:+ values: dict[str, object] = {+ "id": "s_000001",+ "scope": "agent_config",+ "name": "research",+ "path": "s_000001.zip",+ "size": 1,+ "sha256": "0" * 64,+ }+ values.update(overrides)++ with pytest.raises(ValidationError, match=message):+ RosterAgentPackageSkill.model_validate(values)+++ ("overrides", "message"),+ [+ ({"path": "f_000001"}, "file path must start"),+ ({"path": "f_000001.dir/file"}, "root-level archive member"),+ ],+)+def test_file_resource_rejects_invalid_metadata(overrides: dict[str, object], message: str) -> None:+ values: dict[str, object] = {+ "id": "f_000001",+ "path": "f_000001.pdf",+ "size": 1,+ "sha256": "0" * 64,+ }+ values.update(overrides)++ with pytest.raises(ValidationError, match=message):+ RosterAgentPackageFile.model_validate(values)+++def test_manifest_rejects_unsupported_soul_version() -> None:+ manifest = _manifest(skill_payload=_skill_archive(), file_payload=b"pdf-content")+ with pytest.raises(ValueError, match="unsupported Agent Soul schema version"):+ manifest.validate_apps({"app.yaml": _package_app(AgentSoulConfig(schema_version=2))})+++ ("overrides", "message"),+ [+ pytest.param({"name": "duplicate"}, "resource ids must be unique", id="duplicate-id"),+ pytest.param(+ {"id": "s_000002", "path": "s_000002.zip", "scope": "workspace"},+ "skill names must be unique",+ id="duplicate-localized-name",+ ),+ ],+)+def test_manifest_rejects_duplicate_resources(overrides: dict[str, str], message: str) -> None:+ values = _manifest(skill_payload=_skill_archive(), file_payload=b"pdf-content").model_dump(mode="json")+ values["skills"].append({**values["skills"][0], **overrides})++ with pytest.raises(ValidationError, match=message):+ RosterAgentPackageManifest.model_validate(values)+++ ("mutation", "message"),+ [+ ("skill_name", "config skill name must match"),+ ("unreferenced_skill", "agent_config skill resources must be referenced"),+ ("missing_file", "config file reference must resolve"),+ ("unreferenced_file", "file resources must be referenced"),+ ],+)+def test_manifest_rejects_inconsistent_resource_index(mutation: str, message: str) -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ values = _manifest(skill_payload=skill_payload, file_payload=file_payload).model_dump(mode="json")+ app = _package_app()+ if mutation == "skill_name":+ values["skills"][0]["name"] = "renamed"+ elif mutation == "unreferenced_skill":+ app.package.soul.config_skills = []+ elif mutation == "missing_file":+ values["files"] = list[dict[str, object]]()+ else:+ app.package.soul.config_files = []++ with pytest.raises(ValueError, match=message):+ RosterAgentPackageManifest.model_validate(values).validate_apps({"app.yaml": app})++[email protected]("missing_field", ["format", "format_version", "apps"])+def test_reader_rejects_manifest_without_format_discriminator(missing_field: str) -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload).model_dump(mode="json")+ manifest.pop(missing_field)+ package = _zip(+ {+ "manifest.yaml": yaml.safe_dump(manifest).encode(),+ "app.yaml": _yaml_bytes(_package_app()),+ "s_000001.zip": skill_payload,+ "f_000001.pdf": file_payload,+ }+ )++ with pytest.raises(InvalidRosterAgentPackageError, match="manifest is invalid"):+ RosterAgentPackageReader().read(io.BytesIO(package))++[email protected]("file_kind", ["upload_file", "tool_file"])+def test_package_files_reuse_existing_dsl_file_kinds(file_kind: str) -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ app_data = _package_app().model_dump(mode="json")+ app_data["agent_packages"]["agent_1"]["soul"]["config_files"][0]["file_kind"] = file_kind+ app = AgentAppDsl.model_validate(app_data)+ content = _package_bytes(manifest, app=app, skill_payload=skill_payload, file_payload=file_payload)+ reader = RosterAgentPackageReader()+ with reader.read(io.BytesIO(content)) as prepared:+ assert prepared.apps["app.yaml"].package.soul.config_files[0].file_kind == file_kind+ assert reader.read_member_bytes(prepared, "f_000001.pdf", max_bytes=len(file_payload)) == file_payload+++ ("error", "error_code", "status"),+ [+ (InvalidRosterAgentPackageError(), "invalid_roster_agent_package", 400),+ (RosterAgentPackageTooLargeError(), "roster_agent_package_too_large", 413),+ (RosterAgentPackageExportFailedError(), "roster_agent_package_export_failed", 500),+ ],+)+def test_roster_package_errors_use_standard_http_payload(+ error: InvalidRosterAgentPackageError | RosterAgentPackageTooLargeError | RosterAgentPackageExportFailedError,+ error_code: str,+ status: int,+) -> None:+ assert error.error_code == error_code+ assert error.code == status+ assert error.data == {"code": error_code, "message": error.description, "status": status}+++def test_preflight_validates_resources_and_accepts_ignored_signature() -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(+ manifest,+ skill_payload=skill_payload,+ file_payload=file_payload,+ extra_members={"signature.sig": b"not-verified-in-v1"},+ )++ with RosterAgentPackageReader().read(io.BytesIO(package)) as prepared:+ assert prepared.manifest == manifest+ assert prepared.members["s_000001.zip"].sha256 == hashlib.sha256(skill_payload).hexdigest()+ assert prepared.members["f_000001.pdf"].size == len(file_payload)+++def test_reader_accepts_app_larger_than_legacy_limit() -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ app = _package_app()+ app.package.soul.prompt.system_prompt = "x" * (1024 * 1024)+ package = _package_bytes(manifest, app=app, skill_payload=skill_payload, file_payload=file_payload)++ assert len(_yaml_bytes(app)) > 1024 * 1024+ with RosterAgentPackageReader().read(io.BytesIO(package)) as prepared:+ assert prepared.apps["app.yaml"] == app++[email protected]("path", ["manifest.yaml", "app.yaml"])+def test_reader_rejects_oversized_documents(path: str, monkeypatch: pytest.MonkeyPatch) -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ limit = 4096+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_MANIFEST_BYTES=limit)+ package = _package_bytes(+ manifest,+ skill_payload=skill_payload,+ file_payload=file_payload,+ extra_members={path: b"x" * (limit + 1)},+ )+ with pytest.raises(RosterAgentPackageTooLargeError, match=path):+ RosterAgentPackageReader().read(io.BytesIO(package))+++def test_reader_applies_the_whole_package_size_limit(monkeypatch: pytest.MonkeyPatch) -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(manifest, skill_payload=skill_payload, file_payload=file_payload)+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_BYTES=len(package) - 1)++ with pytest.raises(RosterAgentPackageTooLargeError):+ RosterAgentPackageReader().read(io.BytesIO(package))+++def test_preflight_rejects_tampered_payload() -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(+ manifest,+ skill_payload=skill_payload,+ file_payload=b"tampered",+ )++ with pytest.raises(InvalidRosterAgentPackageError, match="failed integrity checks"):+ RosterAgentPackageReader().read(io.BytesIO(package))+++def test_preflight_rejects_members_not_declared_by_manifest() -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(+ manifest,+ skill_payload=skill_payload,+ file_payload=file_payload,+ extra_members={"undeclared.txt": b"unexpected"},+ )++ with pytest.raises(InvalidRosterAgentPackageError, match="members do not match"):+ RosterAgentPackageReader().read(io.BytesIO(package))+++def test_preflight_rejects_unsafe_member_path() -> None:+ package = _zip({"../manifest.yaml": b"{}"})++ with pytest.raises(InvalidRosterAgentPackageError, match="unsafe path"):+ RosterAgentPackageReader().read(io.BytesIO(package))+++def test_high_compression_ratio_uses_absolute_package_limit(monkeypatch: pytest.MonkeyPatch) -> None:+ skill_payload = _skill_archive()+ file_payload = b"x" * (1024 * 1024)+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(manifest, skill_payload=skill_payload, file_payload=file_payload)+ reader = RosterAgentPackageReader()+ with reader.read(io.BytesIO(package)) as prepared:+ assert prepared.members["f_000001.pdf"].size == len(file_payload)+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_BYTES=128 * 1024)+ with pytest.raises(RosterAgentPackageTooLargeError, match="uncompressed size"):+ reader.read(io.BytesIO(package))++[email protected]("path", ["manifest.yaml", "app.yaml"])+ "payload",+ [+ b"format: dify.roster-agent\nformat: dify.roster-agent\n",+ b"metadata:\n name: first\n name: second\n",+ b"value: &value [1]\ncopy: *value\n",+ b"value: !!python/object/apply:os.system ['false']\n",+ b"[invalid",+ b"\xff",+ b"null",+ b"[]",+ b"1: value",+ b"---\n{}\n---\n{}",+ ],+)+def test_preflight_rejects_invalid_yaml_documents(path: str, payload: bytes) -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ package = _package_bytes(+ _manifest(skill_payload=skill_payload, file_payload=file_payload),+ skill_payload=skill_payload,+ file_payload=file_payload,+ extra_members={path: payload},+ )+ with pytest.raises(InvalidRosterAgentPackageError, match=f"{path.removesuffix('.yaml')} is invalid"):+ RosterAgentPackageReader().read(io.BytesIO(package))++[email protected]("missing_path", ["manifest.yaml", "app.yaml"])+def test_reader_requires_both_yaml_documents(missing_path: str) -> None:+ documents = {+ "manifest.yaml": _yaml_bytes(_manifest(skill_payload=_skill_archive(), file_payload=b"pdf-content")),+ "app.yaml": _yaml_bytes(_package_app()),+ }+ del documents[missing_path]+ with pytest.raises(InvalidRosterAgentPackageError, match=f"missing {missing_path}"):+ RosterAgentPackageReader().read(io.BytesIO(_zip(documents)))+++ "mutation",+ [+ "legacy_app",+ "wrong_kind",+ "wrong_mode",+ "missing_ref",+ "dangling_ref",+ "extra_package",+ "invalid_version",+ "future_version",+ ],+)+def test_reader_rejects_invalid_agent_app_dsl(mutation: str) -> None:+ app = _package_app().model_dump(mode="json")+ if mutation == "legacy_app":+ app = {+ "metadata": app["agent_packages"]["agent_1"]["metadata"],+ "soul": app["agent_packages"]["agent_1"]["soul"],+ }+ elif mutation == "wrong_kind":+ app["kind"] = "workflow"+ elif mutation == "wrong_mode":+ app["app"]["mode"] = "workflow"+ elif mutation == "missing_ref":+ app["agent"] = dict[str, str]()+ elif mutation == "dangling_ref":+ app["agent"]["package_ref"] = "agent_2"+ elif mutation == "extra_package":+ app["agent_packages"]["agent_2"] = app["agent_packages"]["agent_1"]+ else:+ app["version"] = "invalid" if mutation == "invalid_version" else "999.0.0"+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ package = _package_bytes(+ _manifest(skill_payload=skill_payload, file_payload=file_payload),+ skill_payload=skill_payload,+ file_payload=file_payload,+ extra_members={"app.yaml": yaml.safe_dump(app).encode()},+ )+ with pytest.raises(InvalidRosterAgentPackageError, match="app is invalid"):+ RosterAgentPackageReader().read(io.BytesIO(package))+++def test_reader_rejects_cross_document_reference_mismatch() -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ app = _package_app()+ app.package.soul.config_skills[0].file_id = "s_000002"+ package = _package_bytes(+ _manifest(skill_payload=skill_payload, file_payload=file_payload),+ app=app,+ skill_payload=skill_payload,+ file_payload=file_payload,+ )+ with pytest.raises(InvalidRosterAgentPackageError, match="app is invalid"):+ RosterAgentPackageReader().read(io.BytesIO(package))+++def test_preflight_records_invalid_skill_payload() -> None:+ skill_payload = _zip({"README.md": b"missing skill manifest"})+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(manifest, skill_payload=skill_payload, file_payload=file_payload)++ with RosterAgentPackageReader().read(io.BytesIO(package)) as prepared:+ assert prepared.invalid_skills == {"s_000001": "missing_skill_md"}+++def test_preflight_rejects_oversized_skill_before_materializing(monkeypatch: pytest.MonkeyPatch) -> None:+ apply_config_overrides(monkeypatch, UPLOAD_SKILL_FILE_SIZE_LIMIT=0)+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(manifest, skill_payload=skill_payload, file_payload=file_payload)++ with pytest.raises(RosterAgentPackageTooLargeError) as exc_info:+ RosterAgentPackageReader().read(io.BytesIO(package))++ assert exc_info.value.error_code == "roster_agent_package_too_large"+ assert exc_info.value.code == 413+++def test_preflight_rejects_aggregate_nested_skill_expansion(monkeypatch: pytest.MonkeyPatch) -> None:+ skill_payloads = {+ "s_000001.zip": _zip(+ {+ "SKILL.md": b"---\nname: research-one\ndescription: Research skill.\n---\n",+ "data.bin": b"x" * 8192,+ }+ ),+ "s_000002.zip": _zip(+ {+ "SKILL.md": b"---\nname: research-two\ndescription: Research skill.\n---\n",+ "data.bin": b"x" * 8192,+ }+ ),+ }+ soul = AgentSoulConfig.model_validate(+ {+ "config_skills": [+ {"name": "research-one", "file_id": "s_000001"},+ {"name": "research-two", "file_id": "s_000002"},+ ]+ }+ )+ manifest = RosterAgentPackageManifest(+ format=ROSTER_AGENT_PACKAGE_FORMAT,+ format_version=ROSTER_AGENT_PACKAGE_FORMAT_VERSION,+ apps=[_app_member(_yaml_bytes(_package_app(soul)))],+ skills=[+ RosterAgentPackageSkill(+ id=path.removesuffix(".zip"),+ scope="agent_config",+ name=f"research-{index}",+ path=path,+ size=len(payload),+ sha256=hashlib.sha256(payload).hexdigest(),+ )+ for index, (path, payload) in zip(("one", "two"), skill_payloads.items())+ ],+ )+ package = _zip(+ {+ "manifest.yaml": _yaml_bytes(manifest),+ "app.yaml": _yaml_bytes(_package_app(soul)),+ **skill_payloads,+ }+ )+ nested_limit = 12 * 1024+ assert len(package) < nested_limit+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_BYTES=nested_limit)++ with pytest.raises(RosterAgentPackageTooLargeError, match="nested Skill contents"):+ RosterAgentPackageReader().read(io.BytesIO(package))++ exporter = RosterAgentPackageExporter(storage_backend=_MemoryStorage(skill_payloads))+ sources = [+ roster_package_exporter_module._SkillSource(+ path=item.path,+ storage_key=item.path,+ id=item.id,+ scope=item.scope,+ name=item.name,+ display_name=None,+ description="Research skill.",+ priority=None,+ audit_ref="source",+ )+ for item in manifest.skills+ ]+ with pytest.raises(RosterAgentPackageTooLargeError, match="nested Skill contents"):+ exporter._build_archive(app=_package_app(soul), skill_sources=sources, file_sources=[])++[email protected]("failure", ["checksum", "size", "name", "crc"])+def test_reader_records_unusable_skills_and_preserves_other_members(failure: str) -> None:+ skill_payload = _skill_archive("different" if failure == "name" else "research")+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ if failure == "checksum":+ manifest.skills[0].sha256 = "0" * 64+ elif failure == "size":+ manifest.skills[0].size += 1+ package = _package_bytes(manifest, skill_payload=skill_payload, file_payload=file_payload)+ if failure == "crc":+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_STORED) as archive:+ archive.writestr("manifest.yaml", _yaml_bytes(manifest))+ archive.writestr("app.yaml", _yaml_bytes(_package_app()))+ archive.writestr("s_000001.zip", skill_payload)+ archive.writestr("f_000001.pdf", file_payload)+ package = output.getvalue().replace(skill_payload, b"X" + skill_payload[1:])+ reader = RosterAgentPackageReader()+ with reader.read(io.BytesIO(package)) as prepared:+ expected = {+ "checksum": "checksum_mismatch",+ "size": "archive_integrity_failed",+ "name": "skill_name_mismatch",+ "crc": "archive_integrity_failed",+ }+ assert prepared.invalid_skills == {"s_000001": expected[failure]}+ assert reader.read_member_bytes(prepared, "f_000001.pdf", max_bytes=len(file_payload)) == file_payload++[email protected]("rewrite_manifest", [False, True])+def test_member_read_rechecks_limit_and_integrity_after_preflight(rewrite_manifest: bool) -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload)+ package = _package_bytes(manifest, skill_payload=skill_payload, file_payload=file_payload)+ reader = RosterAgentPackageReader()+ with reader.read(io.BytesIO(package)) as prepared:+ assert reader.read_member_bytes(prepared, "s_000001.zip", max_bytes=len(skill_payload)) == skill_payload+ with pytest.raises(RosterAgentPackageTooLargeError):+ reader.read_member_bytes(prepared, "f_000001.pdf", max_bytes=len(file_payload) - 1)+ with pytest.raises(InvalidRosterAgentPackageError, match="unavailable"):+ reader.read_member_bytes(prepared, "unknown", max_bytes=100)+ modified = _package_bytes(manifest, skill_payload=skill_payload, file_payload=b"bad-content")+ prepared.archive.seek(0)+ prepared.archive.truncate()+ prepared.archive.write(modified)+ if rewrite_manifest:+ prepared.manifest.files[0].sha256 = hashlib.sha256(b"bad-content").hexdigest()+ with pytest.raises(InvalidRosterAgentPackageError, match="integrity checks"):+ reader.read_member_bytes(prepared, "f_000001.pdf", max_bytes=len(file_payload))+++ ("case", "error_type", "message"),+ [+ ("missing_manifest", RosterAgentPackageExportFailedError, "unusable Skill"),+ ("name_mismatch", RosterAgentPackageExportFailedError, "unusable Skill"),+ ("size_limit", RosterAgentPackageTooLargeError, "exceeds the size limit"),+ ],+)+def test_export_rejects_unusable_or_oversized_skill_payload(+ case: str,+ error_type: type[RosterAgentPackageExportFailedError | RosterAgentPackageTooLargeError],+ message: str,+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ payload = _zip({"README.md": b"missing skill manifest"}) if case == "missing_manifest" else _skill_archive("other")+ if case == "size_limit":+ apply_config_overrides(monkeypatch, UPLOAD_SKILL_FILE_SIZE_LIMIT=0)+ source = roster_package_exporter_module._SkillSource(+ path="s_000001.zip",+ storage_key="skill",+ id="s_000001",+ scope="agent_config",+ name="research",+ display_name=None,+ description="Research skill.",+ priority=None,+ audit_ref="source",+ )+ app = _package_app()+ app.package.soul.config_files = []+ exporter = RosterAgentPackageExporter(storage_backend=_MemoryStorage({"skill": payload}))+ with pytest.raises(error_type, match=message):+ exporter._build_archive(app=app, skill_sources=[source], file_sources=[])++[email protected]("max_bytes", [0, 8])+def test_read_member_enforces_actual_output_limit(max_bytes: int) -> None:+ package = _zip({"payload.bin": b"x" * 32})++ with zipfile.ZipFile(io.BytesIO(package)) as archive:+ with pytest.raises(RosterAgentPackageTooLargeError) as exc_info:+ RosterAgentPackageReader._read_member(+ archive,+ archive.getinfo("payload.bin"),+ collect=True,+ max_bytes=max_bytes,+ expected_size=32,+ )++ assert exc_info.value.error_code == "roster_agent_package_too_large"++[email protected]("expected_size", [8, 64])+def test_read_member_validates_actual_size_while_streaming(expected_size: int) -> None:+ package = _zip({"payload.bin": b"x" * 32})++ with zipfile.ZipFile(io.BytesIO(package)) as archive:+ with pytest.raises(InvalidRosterAgentPackageError, match="failed integrity checks"):+ RosterAgentPackageReader._read_member(+ archive,+ archive.getinfo("payload.bin"),+ collect=False,+ max_bytes=32,+ expected_size=expected_size,+ )++[email protected]("collect", [False, True])+def test_read_empty_member_with_zero_budget(collect: bool) -> None:+ with zipfile.ZipFile(io.BytesIO(_zip({"empty.bin": b""}))) as archive:+ payload, digest, size = RosterAgentPackageReader._read_member(+ archive, archive.getinfo("empty.bin"), collect=collect, max_bytes=0, expected_size=0+ )+ assert payload == b""+ assert digest == hashlib.sha256(b"").hexdigest()+ assert size == 0+++def test_export_accepts_legacy_agent_and_preserves_caller_transaction(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ sqlite_session_factory: sessionmaker[Session],+) -> None:+ skill_payload = _skill_archive()+ file_payload = b"0" * (1024 * 1024)+ read_sessions: list[Session] = []++ def create_read_session() -> Session:+ session = sqlite_session_factory()+ read_sessions.append(session)+ return session++ def assert_read_session_closed() -> None:+ assert read_sessions+ assert not read_sessions[-1].in_transaction()++ monkeypatch.setattr(roster_package_exporter_module.session_factory, "create_session", create_read_session)++ storage = _MemoryStorage(+ {"tools/skill.zip": skill_payload, "tools/guide.pdf": file_payload},+ before_read=assert_read_session_closed,+ )+ skill_file = ToolFile(+ user_id="account-1",+ tenant_id="tenant-1",+ conversation_id=None,+ file_key="tools/skill.zip",+ mimetype="application/zip",+ name="research.zip",+ size=len(skill_payload),+ original_url=None,+ )+ skill_file.id = "11111111-1111-4111-8111-111111111111"+ config_file = ToolFile(+ user_id="account-1",+ tenant_id="tenant-1",+ conversation_id=None,+ file_key="tools/guide.pdf",+ mimetype="application/pdf",+ name="guide.pdf",+ size=len(file_payload),+ original_url=None,+ )+ config_file.id = "22222222-2222-4222-8222-222222222222"+ published_soul = AgentSoulConfig.model_validate({"prompt": {"system_prompt": "published"}})+ draft_soul = AgentSoulConfig.model_validate(+ {+ "model": {+ "plugin_id": "langgenius/openai",+ "model_provider": "langgenius/openai/openai",+ "model": "gpt-test",+ "credential_ref": {"type": "provider", "id": "private-model"},+ },+ "tools": {+ "dify_tools": [+ {+ "provider_id": "langgenius/google/google",+ "provider_type": "plugin",+ "tool_name": "search",+ "credential_type": "api-key",+ "credential_ref": {"type": "tool", "id": "private-tool"},+ "runtime_parameters": {"query": "retain", "api_key": "private-value"},+ }+ ],+ },+ "prompt": {"system_prompt": "draft"},+ "config_skills": [+ {"name": "research", "file_id": skill_file.id},+ {"name": "missing-skill", "file_id": "", "is_missing": True},+ ],+ "config_files": [+ {"name": "guide.pdf", "file_kind": "tool_file", "file_id": config_file.id},+ {"name": "missing.txt", "file_kind": "upload_file", "file_id": "", "is_missing": True},+ ],+ }+ )+ agent = Agent(+ tenant_id="tenant-1",+ name="Research Agent",+ description="description",+ role="researcher",+ agent_kind=AgentKind.DIFY_AGENT,+ scope=AgentScope.ROSTER,+ source=AgentSource.AGENT_APP,+ app_id="33333333-3333-4333-8333-333333333333",+ backing_app_id=None,+ status=AgentStatus.ACTIVE,+ created_by="account-1",+ updated_by="account-1",+ )+ agent.id = "44444444-4444-4444-8444-444444444444"+ snapshot = AgentConfigSnapshot(+ tenant_id="tenant-1",+ agent_id=agent.id,+ version=1,+ config_snapshot=published_soul,+ created_by="account-1",+ )+ snapshot.id = "55555555-5555-4555-8555-555555555555"+ agent.active_config_snapshot_id = snapshot.id+ draft = AgentConfigDraft(+ tenant_id="tenant-1",+ agent_id=agent.id,+ draft_type=AgentConfigDraftType.DRAFT,+ account_id=None,+ draft_owner_key="",+ base_snapshot_id=snapshot.id,+ config_snapshot=draft_soul,+ created_by="account-1",+ updated_by="account-1",+ )+ sqlite_session.add_all(+ [_app("33333333-3333-4333-8333-333333333333"), skill_file, config_file, agent, snapshot, draft]+ )+ sqlite_session.commit()++ caller_owned_file = ToolFile(+ user_id="account-1",+ tenant_id="tenant-1",+ conversation_id=None,+ file_key="tools/caller-owned.txt",+ mimetype="text/plain",+ name="caller-owned.txt",+ size=1,+ original_url=None,+ )+ caller_owned_file.id = "77777777-7777-4777-8777-777777777777"+ sqlite_session.add(caller_owned_file)+ sqlite_session.flush()+ assert caller_owned_file not in sqlite_session.new++ exporter = RosterAgentPackageExporter(+ storage_backend=storage,+ dependency_provider=lambda _tenant_id, _dependencies: [],+ )+ monkeypatch.setattr(DependenciesAnalysisService, "generate_dependencies", lambda **_kwargs: [])+ app_model = sqlite_session.get(App, agent.app_id)+ assert app_model is not None+ standalone_dsl = yaml.safe_load(AppDslService.export_dsl(app_model, session=sqlite_session))+ with exporter.export(tenant_id="tenant-1", agent_id=agent.id) as exported:+ archive_bytes = exported.archive.read()+ assert exported.filename == "research-agent.ifpkg"+ with zipfile.ZipFile(io.BytesIO(archive_bytes)) as archive:+ assert set(archive.namelist()) == {"manifest.yaml", "app.yaml", "s_000001.zip", "f_000001.pdf"}+ manifest_data = yaml.safe_load(archive.read("manifest.yaml"))+ app_data = yaml.safe_load(archive.read("app.yaml"))+ exported_app = AgentAppDsl.model_validate(app_data)+ exported_soul = exported_app.package.soul+ assert exported_soul.model is not None+ assert exported_soul.model.credential_ref is None+ assert exported_soul.tools.dify_tools[0].credential_ref is None+ assert exported_soul.tools.dify_tools[0].runtime_parameters == {"query": "retain", "api_key": None}+ assert "private-" not in exported_app.model_dump_json()+ assert draft_soul.model is not None+ assert draft_soul.model.credential_ref is not None+ assert draft_soul.tools.dify_tools[0].runtime_parameters["api_key"] == "private-value"+ assert exported_app.package.soul.prompt.system_prompt == "draft"+ assert exported_app.package.soul.config_skills[0].file_id == "s_000001"+ assert exported_app.package.soul.config_files[0].file_id == "f_000001"+ assert exported_app.package.soul.config_files[0].mime_type == "application/pdf"+ assert exported_app.package.soul.config_skills[1].is_missing is True+ assert exported_app.package.soul.config_skills[1].file_id == ""+ assert exported_app.package.soul.config_files[1].is_missing is True+ assert exported_app.package.soul.config_files[1].file_id == ""+ assert set(manifest_data) == {"format", "format_version", "audit", "apps", "skills", "files"}+ assert set(manifest_data["files"][0]) == {+ "id",+ "path",+ "size",+ "sha256",+ "audit",+ }+ assert manifest_data["apps"] == [+ {+ "path": "app.yaml",+ "size": len(archive.read("app.yaml")),+ "sha256": hashlib.sha256(archive.read("app.yaml")).hexdigest(),+ }+ ]+ assert set(app_data) == {"version", "kind", "app", "agent", "agent_packages", "dependencies"}+ assert app_data["kind"] == "app"+ assert app_data["app"]["mode"] == "agent"+ assert app_data["app"]["icon"] == "R"+ assert app_data["agent"]["package_ref"] == "agent_1"+ assert "audit" not in app_data["agent_packages"]["agent_1"]["metadata"]+ for key in ("version", "kind", "app", "agent", "dependencies"):+ assert app_data[key] == standalone_dsl[key]+ standalone_package = AgentPackage.model_validate(standalone_dsl["agent_packages"]["agent_1"])+ assert exported_app.package.metadata == standalone_package.metadata+ assert standalone_package.soul.config_skills[0].is_missing is True+ assert standalone_package.soul.config_skills[0].file_id == ""+ assert standalone_package.soul.config_files[0].is_missing is True+ assert {item.name for item in exported_app.package.omitted_assets} == {"missing-skill", "missing.txt"}+ assert {item.name for item in standalone_package.omitted_assets} == {+ "research",+ "guide.pdf",+ "missing-skill",+ "missing.txt",+ }+ assert archive.read("s_000001.zip") == skill_payload+ assert all(info.compress_type == zipfile.ZIP_STORED for info in archive.infolist())+ assert "signature.sig" not in archive.namelist()++ with RosterAgentPackageReader().read(io.BytesIO(archive_bytes)) as prepared:+ assert prepared.apps["app.yaml"].package.soul.prompt.system_prompt == "draft"++ assert sqlite_session.in_transaction()+ assert sqlite_session.get(ToolFile, caller_owned_file.id) is caller_owned_file++ max_entries = dify_config.AGENT_PACKAGE_MAX_ENTRIES+ max_manifest_bytes = dify_config.AGENT_PACKAGE_MAX_MANIFEST_BYTES+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_ENTRIES=4)+ with exporter.export(tenant_id="tenant-1", agent_id=agent.id) as exported:+ with zipfile.ZipFile(exported.archive) as archive:+ assert len(archive.infolist()) == 4++ reads_before_limit_check = storage.read_count+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_ENTRIES=3)+ with pytest.raises(RosterAgentPackageTooLargeError):+ exporter.export(tenant_id="tenant-1", agent_id=agent.id)+ assert storage.read_count == reads_before_limit_check+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_ENTRIES=max_entries)++ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_MANIFEST_BYTES=1)+ with pytest.raises(RosterAgentPackageTooLargeError):+ exporter.export(tenant_id="tenant-1", agent_id=agent.id)+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_MANIFEST_BYTES=max_manifest_bytes)++ file_bytes_before_limit_check = storage.bytes_yielded["tools/guide.pdf"]+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_BYTES=len(skill_payload) + 1)+ with pytest.raises(RosterAgentPackageTooLargeError):+ exporter.export(tenant_id="tenant-1", agent_id=agent.id)+ assert storage.bytes_yielded["tools/guide.pdf"] - file_bytes_before_limit_check == 7+++def test_export_uses_current_workspace_skill_bindings(+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+) -> None:+ workspace_payload = _skill_archive("legacy-published")+ storage = _MemoryStorage({"tools/workspace.zip": workspace_payload})+ monkeypatch.setattr(+ "services.skill_management_service.SkillManagementService._load_tool_file_bytes",+ staticmethod(lambda **_kwargs: workspace_payload),+ )+ archive_file = ToolFile(+ user_id="account-1",+ tenant_id="tenant-1",+ conversation_id=None,+ file_key="tools/workspace.zip",+ mimetype="application/zip",+ name="workspace-research.zip",+ size=len(workspace_payload),+ original_url=None,+ )+ archive_file.id = "11111111-1111-4111-8111-111111111111"+ skill = Skill(+ tenant_id="tenant-1",+ name="renamed-workspace",+ display_name="Renamed Workspace",+ description="Renamed description.",+ created_by="account-1",+ updated_by="account-1",+ )+ skill.id = "22222222-2222-4222-8222-222222222222"+ version = SkillVersion(+ skill_id=skill.id,+ version_number=1,+ version_name="1.0",+ publish_note="",+ manifest=SkillVersionManifest(+ name=None,+ display_name=None,+ description=None,+ files=[],+ ),+ archive_tool_file_id=archive_file.id,+ hash_code="hash-code",+ archive_size=len(workspace_payload),+ published_by="account-1",+ )+ version.id = "33333333-3333-4333-8333-333333333333"+ skill.latest_published_version_id = version.id+ agent = Agent(+ tenant_id="tenant-1",+ name="Research Agent",+ description="",+ role="",+ agent_kind=AgentKind.DIFY_AGENT,+ scope=AgentScope.ROSTER,+ source=AgentSource.AGENT_APP,+ app_id="44444444-4444-4444-8444-444444444444",+ backing_app_id="44444444-4444-4444-8444-444444444444",+ status=AgentStatus.ACTIVE,+ created_by="account-1",+ updated_by="account-1",+ )+ agent.id = "55555555-5555-4555-8555-555555555555"+ snapshot = AgentConfigSnapshot(+ tenant_id="tenant-1",+ agent_id=agent.id,+ version=1,+ config_snapshot=AgentSoulConfig.model_validate(+ {"config_skills": [{"name": "legacy-published", "file_id": "", "is_missing": True}]}+ ),+ created_by="account-1",+ )+ snapshot.id = "66666666-6666-4666-8666-666666666666"+ agent.active_config_snapshot_id = snapshot.id+ binding = AgentSkillBindingSnapshot(+ tenant_id="tenant-1",+ agent_id=agent.id,+ config_snapshot_id=snapshot.id,+ skill_id=skill.id,+ priority=0,+ created_by="account-1",+ )+ sqlite_session.add_all(+ [_app("44444444-4444-4444-8444-444444444444"), archive_file, skill, version, agent, snapshot, binding]+ )+ sqlite_session.commit()++ exporter = RosterAgentPackageExporter(+ storage_backend=storage,+ dependency_provider=lambda _tenant_id, _dependencies: [],+ )+ with exporter.export(tenant_id="tenant-1", agent_id=agent.id) as exported:+ with RosterAgentPackageReader().read(exported.archive) as prepared:+ assert len(prepared.manifest.skills) == 1+ assert prepared.manifest.skills[0].scope == "workspace"+ assert set(prepared.manifest.skills[0].model_dump()) == {+ "id",+ "path",+ "size",+ "sha256",+ "audit",+ "scope",+ "name",+ }+ assert prepared.apps["app.yaml"].package.workspace_skills[0].priority == 0+ assert prepared.manifest.skills[0].name == "legacy-published"+ assert prepared.apps["app.yaml"].package.workspace_skills[0].display_name == "Legacy Published"+ assert prepared.apps["app.yaml"].package.workspace_skills[0].description == "Research skill."+ assert prepared.apps["app.yaml"].package.soul.config_skills[0].is_missing is True+ assert prepared.manifest.skills[0].sha256 == hashlib.sha256(workspace_payload).hexdigest()++ draft = AgentConfigDraft(+ tenant_id="tenant-1",+ agent_id=agent.id,+ draft_type=AgentConfigDraftType.DRAFT,+ account_id=None,+ draft_owner_key="",+ base_snapshot_id=snapshot.id,+ config_snapshot=AgentSoulConfig.model_validate({"prompt": {"system_prompt": "current draft"}}),+ created_by="account-1",+ updated_by="account-1",+ )+ sqlite_session.add(draft)+ sqlite_session.commit()++ with exporter.export(tenant_id="tenant-1", agent_id=agent.id) as exported:+ with RosterAgentPackageReader().read(exported.archive) as prepared:+ assert prepared.apps["app.yaml"].package.soul.prompt.system_prompt == "current draft"+ assert prepared.manifest.skills == []+++def test_manifest_yaml_is_strict() -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ manifest = _manifest(skill_payload=skill_payload, file_payload=file_payload).model_dump(mode="json")+ manifest["unexpected"] = True++ with pytest.raises(ValidationError, match="Extra inputs are not permitted"):+ RosterAgentPackageManifest.model_validate(yaml.safe_load(yaml.safe_dump(manifest)))+++ ("case", "message"),+ [+ ("empty", "package is empty"),+ ("entries", "too many members"),+ ("duplicate", "duplicate member paths"),+ ("directory", "root-level files"),+ ("control_character", "unsafe path"),+ ("symlink", "symbolic links"),+ ("encrypted", "encrypted members"),+ ("compression", "unsupported compression"),+ ],+)+def test_reader_rejects_invalid_container_before_parsing_manifest(+ case: str, message: str, monkeypatch: pytest.MonkeyPatch+) -> None:+ if case == "empty":+ content = _zip({})+ elif case == "entries":+ apply_config_overrides(monkeypatch, AGENT_PACKAGE_MAX_ENTRIES=1)+ content = _zip({"manifest.yaml": b"", "app.yaml": b""})+ elif case == "duplicate":+ content = _zip({"manifest.yaml": b"", "MANIFEST.YAML": b""})+ elif case == "directory":+ content = _zip({"directory/": b""})+ elif case == "control_character":+ content = _zip({"bad\nname": b""})+ elif case == "symlink":+ output = io.BytesIO()+ info = zipfile.ZipInfo("manifest.yaml")+ info.create_system = 3+ info.external_attr = 0o120777 << 16+ with zipfile.ZipFile(output, "w") as archive:+ archive.writestr(info, b"target.yaml")+ content = output.getvalue()+ elif case == "encrypted":+ data = bytearray(_zip({"manifest.yaml": b"manifest"}))+ directory = data.index(b"PK\x01\x02")+ data[directory + 8] |= 1+ content = bytes(data)+ else:+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_BZIP2) as archive:+ archive.writestr("manifest.yaml", b"manifest")+ content = output.getvalue()+ with pytest.raises(InvalidRosterAgentPackageError, match=message):+ RosterAgentPackageReader().read(io.BytesIO(content))+++def test_member_read_reports_closed_prepared_archive() -> None:+ skill_payload = _skill_archive()+ file_payload = b"pdf-content"+ content = _package_bytes(+ _manifest(skill_payload=skill_payload, file_payload=file_payload),+ skill_payload=skill_payload,+ file_payload=file_payload,+ )+ reader = RosterAgentPackageReader()+ prepared = reader.read(io.BytesIO(content))+ prepared.close()+ with pytest.raises(InvalidRosterAgentPackageError, match="member is unavailable"):+ reader.read_member_bytes(prepared, "f_000001.pdf", max_bytes=len(file_payload))+++def test_export_download_closes_owned_archive(app: Flask) -> None:+ exported = RosterAgentPackageExporter()._build_archive(+ app=_package_app(AgentSoulConfig()), skill_sources=[], file_sources=[]+ )+ with app.test_request_context("/"):+ response = send_file(+ exported.archive, mimetype="application/zip", as_attachment=True, download_name=exported.filename+ )+ response.call_on_close(exported.close)+ try:+ content = b"".join(response.iter_encoded())+ assert len(content) == exported.size+ assert exported.filename in response.headers["Content-Disposition"]+ with zipfile.ZipFile(io.BytesIO(content)) as archive:+ assert set(archive.namelist()) == {"manifest.yaml", "app.yaml"}+ finally:+ response.close()+ assert exported.archive.closed++[email protected]("file_kind", ["upload_file", "tool_file"])+ ("declared_mime", "stored_mime", "expected_mime"),+ [+ ("text/plain", "application/pdf", "text/plain"),+ (None, "application/pdf", "application/pdf"),+ (None, "", "application/octet-stream"),+ ],+)+def test_export_preserves_file_metadata_in_dsl(+ monkeypatch: pytest.MonkeyPatch, file_kind: str, declared_mime: str | None, stored_mime: str, expected_mime: str+) -> None:+ from unittest.mock import Mock++ from models.model import UploadFile++ exporter = RosterAgentPackageExporter(storage_backend=_MemoryStorage({}))+ tool_file = ToolFile(+ user_id="account-1",+ tenant_id="tenant-1",+ conversation_id=None,+ file_key="payload",+ mimetype=stored_mime,+ name="original.pdf",+ size=1,+ original_url=None,+ )+ tool_file.id = "source-id"+ upload_file = Mock(spec=UploadFile, id="source-id", key="payload", mime_type=stored_mime)+ monkeypatch.setattr(exporter, "_tool_files", Mock(return_value={"source-id": tool_file}))+ monkeypatch.setattr(exporter, "_upload_files", Mock(return_value={"source-id": upload_file}))+ soul = AgentSoulConfig.model_validate(+ {+ "config_files": [+ {"name": "original.pdf", "file_kind": file_kind, "file_id": "source-id", "mime_type": declared_mime}+ ]+ }+ )++ portable_soul, _, sources = exporter._collect_payloads(session=Mock(spec=Session), tenant_id="tenant-1", soul=soul)++ ref = portable_soul.config_files[0]+ assert (ref.name, ref.file_kind, ref.mime_type, ref.file_id) == (+ "original.pdf",+ file_kind,+ expected_mime,+ sources[0].id,+ )+ assert sources[0].storage_key == "payload"+ assert soul.config_files[0].mime_type == declared_mime+ assert soul.config_files[0].file_id == "source-id"++[email protected]("mutation", ["missing", "extra", "duplicate"])+def test_manifest_requires_workspace_skill_dsl_metadata(mutation: str) -> None:+ from services.agent.dsl_entities import AgentPackageWorkspaceSkill++ manifest = _manifest(skill_payload=_skill_archive(), file_payload=b"pdf-content")+ app = _package_app()+ manifest.skills[0].scope = "workspace"+ app.package.soul.config_skills = []+ descriptor = AgentPackageWorkspaceSkill(+ name="research", display_name="Research", description="Research skill.", priority=3+ )+ app.package.workspace_skills = [descriptor]+ manifest.validate_apps({"app.yaml": app})+ if mutation == "missing":+ app.package.workspace_skills = []+ elif mutation == "extra":+ app.package.workspace_skills.append(descriptor.model_copy(update={"name": "extra"}))+ else:+ app.package.workspace_skills.append(descriptor)+ with pytest.raises(ValueError, match="workspace skill"):+ manifest.validate_apps({"app.yaml": app})+++ ("mutation", "message"),+ [+ (None, None),+ ("shared", None),+ ("size", "integrity checks"),+ ("checksum", "integrity checks"),+ ("missing", "missing assistant.yml"),+ ("schema", "app is invalid"),+ ("extra", "members do not match"),+ ("unreferenced", "app is invalid"),+ ],+)+def test_reader_resolves_multiple_indexed_apps(mutation: str | None, message: str | None) -> None:+ from services.agent.dsl_entities import AgentPackageWorkspaceSkill++ skill = _skill_archive()+ workspace_skill = _skill_archive("workspace")+ manifest = _manifest(skill_payload=skill, file_payload=b"pdf")+ first, second = _package_app(), _package_app()+ first.package.soul.config_files = []+ second.package.soul.config_skills = []+ second.package.workspace_skills = [AgentPackageWorkspaceSkill(name="workspace", priority=0)]+ manifest.skills.append(+ RosterAgentPackageSkill(+ id="s_000002",+ path="s_000002.zip",+ scope="workspace",+ name="workspace",+ size=len(workspace_skill),+ sha256=hashlib.sha256(workspace_skill).hexdigest(),+ )+ )+ if mutation == "shared":+ first.package.soul.config_files = second.package.soul.config_files+ second.package.soul.config_skills = first.package.soul.config_skills+ first.package.workspace_skills = second.package.workspace_skills+ elif mutation == "unreferenced":+ second.package.soul.config_files = []+ app_payloads = {"research.yaml": _yaml_bytes(first), "assistant.yml": _yaml_bytes(second)}+ if mutation == "schema":+ app_payloads["assistant.yml"] = b"kind: workflow\n"+ manifest.apps = [_app_member(payload, path) for path, payload in app_payloads.items()]+ if mutation == "size":+ manifest.apps[1].size += 1+ elif mutation == "checksum":+ manifest.apps[1].sha256 = "0" * 64+ elif mutation == "missing":+ del app_payloads["assistant.yml"]+ elif mutation == "extra":+ app_payloads["undeclared.yaml"] = b"{}"+ content = _zip(+ {+ "manifest.yaml": _yaml_bytes(manifest),+ **app_payloads,+ "s_000001.zip": skill,+ "s_000002.zip": workspace_skill,+ "f_000001.pdf": b"pdf",+ }+ )+ reader = RosterAgentPackageReader()+ if message is not None:+ with pytest.raises(InvalidRosterAgentPackageError, match=message):+ reader.read(io.BytesIO(content))+ else:+ with reader.read(io.BytesIO(content)) as prepared:+ assert prepared.apps == {"research.yaml": first, "assistant.yml": second}+ for path, payload in app_payloads.items():+ assert reader.read_member_bytes(prepared, path, max_bytes=len(payload)) == payload+++ "paths",+ [[], ["app.yaml", "app.yaml"], ["app.yaml", "APP.yaml"], ["manifest.yaml"], ["nested/app.yaml"], ["app.json"]],+)+def test_manifest_rejects_invalid_app_index(paths: list[str]) -> None:+ values = _manifest(skill_payload=_skill_archive(), file_payload=b"pdf").model_dump(mode="json")+ values["apps"] = [{"path": path, "size": 0, "sha256": "0" * 64} for path in paths]+ with pytest.raises(ValidationError):+ RosterAgentPackageManifest.model_validate(values)diff --git a/api/tests/unit_tests/services/agent/test_skill_package_service.py b/api/tests/unit_tests/services/agent/test_skill_package_service.pyindex 94aef19e514..d62318434ca 100644--- a/api/tests/unit_tests/services/agent/test_skill_package_service.py+++ b/api/tests/unit_tests/services/agent/test_skill_package_service.py@@ -9,8 +9,8 @@ import zlibimport pytest-from services.agent import skill_package_service as skill_package_service_modulefrom services.agent.skill_package_service import NormalizedSkillPackage, SkillPackageError, SkillPackageService+from tests.unit_tests.config_override import apply_config_overrides_SKILL_MD = """---name: pdf-toolkit@@ -35,134 +35,152 @@ def _normalize(members: dict[str, bytes], *, filename: str = "skill.zip") -> Norreturn SkillPackageService().validate_and_normalize(content=_zip(members), filename=filename)-def _archive_members(content: bytes) -> list[str]:- with zipfile.ZipFile(io.BytesIO(content)) as archive:- return sorted(info.filename for info in archive.infolist() if not info.is_dir())---def test_valid_skill_normalizes_manifest():- manifest = _normalize({"SKILL.md": _SKILL_MD.encode(), "scripts/run.py": b"print('hi')\n"}).manifest-- assert manifest.name == "pdf-toolkit"- assert manifest.description == "Tools for working with PDF files."- assert manifest.entry_path == "SKILL.md"- assert set(manifest.files) == {"SKILL.md", "scripts/run.py"}- assert manifest.size > 0- assert len(manifest.hash) == 64---def test_validate_and_normalize_accepts_crlf_skill_md():- crlf_skill_md = _SKILL_MD.replace("\n", "\r\n")- package = _normalize({"SKILL.md": crlf_skill_md.encode()})-- assert package.manifest.name == "pdf-toolkit"- assert package.manifest.description == "Tools for working with PDF files."- assert b"\r" not in package.skill_md_bytes- assert package.skill_md_bytes.decode() == _SKILL_MD---def test_name_and_description_are_required_in_frontmatter():- with pytest.raises(SkillPackageError) as exc_info:- _normalize({"SKILL.md": b"# heading-name\n\nbody"})- assert exc_info.value.code == "missing_skill_name"---def test_shallowest_skill_md_preferred_during_normalization():- manifest = _normalize({"SKILL.md": _SKILL_MD.encode(), "nested/SKILL.md": _SKILL_MD.encode()}).manifest- assert manifest.entry_path == "SKILL.md"- assert manifest.files == ["SKILL.md", "nested/SKILL.md"]---def test_validate_and_normalize_keeps_root_skill_unchanged():- package = _normalize({"SKILL.md": _SKILL_MD.encode(), "scripts/run.py": b"print('hi')\n"})-- assert package.manifest.entry_path == "SKILL.md"- assert package.manifest.files == ["SKILL.md", "scripts/run.py"]- assert package.skill_md_bytes == _SKILL_MD.encode()- assert package.strip_prefix is None- assert _archive_members(package.archive_bytes) == ["SKILL.md", "scripts/run.py"]- assert len(package.manifest.hash) == 64---def test_validate_and_normalize_strips_single_top_level_folder():- package = _normalize(+def test_normalize_replaces_invalid_utf8_member_names() -> None:+ original = _zip({- "pdf-toolkit/SKILL.md": _SKILL_MD.encode(),- "pdf-toolkit/scripts/run.py": b"print('hi')\n",+ "SKILL.md": _SKILL_MD.encode(),+ "scripts/\u00e9.py": b"print('keep payload')\n",+ "assets/\u00f6.txt": b"valid unicode name",+ "assets/X.txt": b"legacy encoded name",})-- assert package.manifest.entry_path == "SKILL.md"- assert package.manifest.files == ["SKILL.md", "scripts/run.py"]- assert package.skill_md_bytes == _SKILL_MD.encode()- assert package.strip_prefix == "pdf-toolkit/"- assert _archive_members(package.archive_bytes) == ["SKILL.md", "scripts/run.py"]---def test_validate_and_normalize_strips_single_top_level_folder_ignoring_other_root_entries():- package = _normalize(- {- "pdf-toolkit/SKILL.md": _SKILL_MD.encode(),- "pdf-toolkit/scripts/run.py": b"print('hi')\n",- "README.md": b"bundle notes\n",- }- )-- assert package.manifest.entry_path == "SKILL.md"- assert package.manifest.files == ["SKILL.md", "scripts/run.py"]- assert package.skill_md_bytes == _SKILL_MD.encode()- assert package.strip_prefix == "pdf-toolkit/"- assert _archive_members(package.archive_bytes) == ["SKILL.md", "scripts/run.py"]---def test_validate_and_normalize_strips_single_top_level_folder_dropping_nested_foreign_paths():- package = _normalize(+ damaged = original.replace(b"\xc3\xa9.py", b"\xffa.py").replace(b"assets/X.txt", b"assets/\x82.txt")+ service = SkillPackageService()+ assert service.inspect(content=damaged, filename="skill.zip").name == "pdf-toolkit"+ normalized = service.validate_and_normalize(content=damaged, filename="skill.zip")+ with zipfile.ZipFile(io.BytesIO(normalized.archive_bytes)) as archive:+ assert archive.read("scripts/\ufffda.py") == b"print('keep payload')\n"+ assert archive.read("assets/\u00f6.txt") == b"valid unicode name"+ assert archive.read("assets/\u00e9.txt") == b"legacy encoded name"+ assert archive.testzip() is None+++def test_normalize_recovers_zip64_skill_names(monkeypatch: pytest.MonkeyPatch) -> None:+ with monkeypatch.context() as scoped:+ scoped.setattr(zipfile, "ZIP64_LIMIT", 0)+ original = _zip({"SKILL.md": _SKILL_MD.encode(), "scripts/\u00e9.py": b"print('ok')\n"})+ damaged = original.replace(b"\xc3\xa9.py", b"\xffa.py")+ service = SkillPackageService()+ assert service.inspect(content=damaged, filename="skill.zip").name == "pdf-toolkit"+ normalized = service.validate_and_normalize(content=damaged, filename="skill.zip")+ with zipfile.ZipFile(io.BytesIO(normalized.archive_bytes)) as archive:+ assert archive.read("scripts/\ufffda.py") == b"print('ok')\n"+++def test_replacement_member_names_must_remain_unique() -> None:+ original = _zip({- "pdf-toolkit/SKILL.md": _SKILL_MD.encode(),- "pdf-toolkit/scripts/run.py": b"print('hi')\n",- "bundle/other.txt": b"x",+ "SKILL.md": _SKILL_MD.encode(),+ "scripts/\u00e9.py": b"one",+ "scripts/\u00f6.py": b"two",})-- assert package.manifest.entry_path == "SKILL.md"- assert package.manifest.files == ["SKILL.md", "scripts/run.py"]- assert package.skill_md_bytes == _SKILL_MD.encode()- assert package.strip_prefix == "pdf-toolkit/"- assert _archive_members(package.archive_bytes) == ["SKILL.md", "scripts/run.py"]+ damaged = original.replace(b"\xc3\xa9.py", b"\xffa.py").replace(b"\xc3\xb6.py", b"\xfea.py")+ with pytest.raises(SkillPackageError) as error:+ SkillPackageService().validate_and_normalize(content=damaged, filename="skill.zip")+ assert error.value.code == "duplicate_member_path"+++def test_replacement_names_do_not_hide_local_header_mismatch() -> None:+ original = _zip({"SKILL.md": _SKILL_MD.encode(), "\u00e9.py": b"payload"})+ # Damage only the central name, leaving the local header unchanged.+ central = original.index(b"PK\x01\x02")+ damaged = original[:central] + original[central:].replace(b"\xc3\xa9.py", b"\xffa.py")+ with pytest.raises(SkillPackageError) as error:+ SkillPackageService().validate_and_normalize(content=damaged, filename="skill.zip")+ assert error.value.code == "invalid_archive"+++def test_normalized_highly_compressible_skill_passes_reinspection() -> None:+ payload = b"x" * (1024 * 1024)+ content = _zip({"SKILL.md": _SKILL_MD.encode(), "data.bin": payload}, compression=zipfile.ZIP_STORED)+ service = SkillPackageService()+ normalized = service.validate_and_normalize(content=content, filename="skill.zip")+ inspection = service.inspect(content=normalized.archive_bytes, filename="skill.zip")+ assert inspection.name == normalized.manifest.name+ with zipfile.ZipFile(io.BytesIO(normalized.archive_bytes)) as archive:+ assert archive.getinfo("data.bin").compress_type == zipfile.ZIP_DEFLATED+ assert archive.read("data.bin") == payload+++def test_inspect_reports_uncompressed_size_without_rebuilding(monkeypatch: pytest.MonkeyPatch):+ members = {"SKILL.md": _SKILL_MD.encode(), "scripts/run.py": b"print('hi')\n"}++ def fail_if_called(*_args: object, **_kwargs: object) -> bytes:+ raise AssertionError("inspection must not rebuild the archive")++ monkeypatch.setattr(SkillPackageService, "_build_normalized_archive", fail_if_called)++ inspection = SkillPackageService().inspect(content=_zip(members), filename="skill.zip")++ assert inspection.name == "pdf-toolkit"+ assert inspection.uncompressed_size == sum(len(content) for content in members.values())++[email protected]("prefix", ["", "pdf-toolkit/"])[email protected]("crlf", [False, True])+def test_inspection_and_normalization_keep_distinct_size_meanings(prefix: str, crlf: bool) -> None:+ skill_md = _SKILL_MD.replace("\n", "\r\n") if crlf else _SKILL_MD+ script = b"print('hi')\n"+ members = {f"{prefix}SKILL.md": skill_md.encode(), f"{prefix}scripts/run.py": script}+ if prefix:+ members["README.md"] = b"ignored outside the selected root"+ content = _zip(members)+ service = SkillPackageService()+ inspection = service.inspect(content=content, filename="skill.zip")+ normalized = service.validate_and_normalize(content=content, filename="skill.zip")+ assert inspection.uncompressed_size == sum(len(value) for value in members.values())+ expected_size = len(_SKILL_MD.encode()) + len(script)+ assert normalized.manifest.size == expected_size+ assert normalized.manifest.name == "pdf-toolkit"+ assert normalized.manifest.description == "Tools for working with PDF files."+ with zipfile.ZipFile(io.BytesIO(normalized.archive_bytes)) as archive:+ assert sum(info.file_size for info in archive.infolist()) == expected_size+ assert archive.read("SKILL.md") == _SKILL_MD.encode()+ if prefix or crlf:+ assert inspection.uncompressed_size > normalized.manifest.size-def test_validate_and_normalize_rejects_multiple_depth_2_skill_roots_with_sibling_skill_tree():- with pytest.raises(SkillPackageError) as exc_info:- _normalize(- {- "pdf-toolkit/SKILL.md": _SKILL_MD.encode(),- "pdf-toolkit/scripts/run.py": b"print('hi')\n",- "other-tool/SKILL.md": _SKILL_MD.encode(),- }- )- assert exc_info.value.code == "files_outside_skill_root"+def test_shallowest_skill_md_preferred_during_normalization():+ manifest = _normalize({"SKILL.md": _SKILL_MD.encode(), "nested/SKILL.md": _SKILL_MD.encode()}).manifest+ assert manifest.entry_path == "SKILL.md"+ assert manifest.files == ["SKILL.md", "nested/SKILL.md"]-def test_validate_and_normalize_strips_deeper_selected_skill_root():- members = {- "bundle/pdf-toolkit/SKILL.md": _SKILL_MD.encode(),- "bundle/pdf-toolkit/scripts/run.py": b"print('hi')\n",- }- original_upload_bytes = _zip(members)- package = SkillPackageService().validate_and_normalize(content=original_upload_bytes, filename="skill.zip")+ ("prefix", "extra_members"),+ [+ pytest.param("", {}, id="root"),+ pytest.param("pdf-toolkit/", {}, id="single-folder"),+ pytest.param("pdf-toolkit/", {"README.md": b"bundle notes\n"}, id="root-outsider"),+ pytest.param("pdf-toolkit/", {".": b"x"}, id="dot-outsider"),+ pytest.param("pdf-toolkit/", {"bundle/other.txt": b"x"}, id="nested-outsider"),+ pytest.param("bundle/pdf-toolkit/", {}, id="deep-root"),+ ],+)+def test_normalization_preserves_selected_skill_contents(prefix: str, extra_members: dict[str, bytes]) -> None:+ expected = {"SKILL.md": _SKILL_MD.encode(), "scripts/run.py": b"print('hi')\n"}+ original = _zip({**{prefix + path: content for path, content in expected.items()}, **extra_members})+ package = SkillPackageService().validate_and_normalize(content=original, filename="skill.zip")+ assert package.manifest.name == "pdf-toolkit"+ assert package.manifest.description == "Tools for working with PDF files."+ assert package.manifest.size == sum(len(content) for content in expected.values())assert package.manifest.entry_path == "SKILL.md"- assert package.manifest.files == ["SKILL.md", "scripts/run.py"]- assert package.strip_prefix == "bundle/pdf-toolkit/"- assert _archive_members(package.archive_bytes) == ["SKILL.md", "scripts/run.py"]+ assert package.manifest.files == sorted(expected)+ with zipfile.ZipFile(io.BytesIO(package.archive_bytes)) as archive:+ assert archive.namelist() == sorted(expected)+ assert {path: archive.read(path) for path in archive.namelist()} == expectedassert package.manifest.hash == hashlib.sha256(package.archive_bytes).hexdigest()- assert package.manifest.hash != hashlib.sha256(original_upload_bytes).hexdigest()+ if prefix:+ assert package.manifest.hash != hashlib.sha256(original).hexdigest()@pytest.mark.parametrize(("members", "filename", "code"),[({"README.md": b"x"}, "skill.zip", "missing_skill_md"),+ ({"SKILL.md": _SKILL_MD.encode(), ".": b"x"}, "skill.zip", "unsafe_path"),({"SKILL.md": _SKILL_MD.encode()}, "skill.tar", "unsupported_extension"),({"SKILL.md": b""}, "skill.zip", "empty_skill_md"),({"SKILL.md": b"---\ndescription: valid\n---\n# no name here"}, "skill.zip", "missing_skill_name"),@@ -178,6 +196,43 @@ def test_validate_and_normalize_strips_deeper_selected_skill_root():"invalid_skill_description",),({"SKILL.md": b"\xff\xfenot utf8"}, "skill.zip", "skill_md_not_utf8"),+ pytest.param({"SKILL.md": b"# heading-name\n\nbody"}, "skill.zip", "missing_skill_name", id="no-frontmatter"),+ pytest.param(+ {+ "pdf-toolkit/SKILL.md": _SKILL_MD.encode(),+ "pdf-toolkit/scripts/run.py": b"print('hi')\n",+ "other-tool/SKILL.md": _SKILL_MD.encode(),+ },+ "skill.zip",+ "files_outside_skill_root",+ id="multiple-skill-roots",+ ),+ pytest.param({"../evil.txt": b"x", "SKILL.md": _SKILL_MD.encode()}, "skill.zip", "unsafe_path", id="zip-slip"),+ pytest.param(+ {"SKILL.md": b"---\n: : : not yaml\n---\n# x\n"},+ "skill.zip",+ "invalid_frontmatter",+ id="invalid-frontmatter",+ ),+ pytest.param(+ {"SKILL.md": b"---\n# heading-wins\nbody"}, "skill.zip", "missing_skill_name", id="unterminated-frontmatter"+ ),+ pytest.param(+ {"bundle/pdf-toolkit/SKILL.md": _SKILL_MD.encode(), "README.md": b"x"},+ "skill.zip",+ "files_outside_skill_root",+ id="outside-deep-root",+ ),+ pytest.param(+ {+ "pdf-toolkit/SKILL.md": _SKILL_MD.encode(),+ "pdf-toolkit/scripts/run.py": b"print('x')\n",+ "pdf-toolkit/scripts/./run.py": b"print('y')\n",+ },+ "skill.zip",+ "duplicate_member_path",+ id="duplicate-normalized-path",+ ),],)def test_invalid_packages_rejected(members: dict[str, bytes], filename: str, code: str):@@ -193,13 +248,6 @@ def test_non_zip_content_rejected():assert exc_info.value.code == "invalid_archive"-def test_zip_slip_member_rejected():- payload = _zip({"../evil.txt": b"x", "SKILL.md": _SKILL_MD.encode()})- with pytest.raises(SkillPackageError) as exc_info:- SkillPackageService().validate_and_normalize(content=payload, filename="skill.zip")- assert exc_info.value.code == "unsafe_path"--def test_empty_archive_rejected():with pytest.raises(SkillPackageError) as exc_info:SkillPackageService().validate_and_normalize(content=b"", filename="skill.zip")@@ -207,7 +255,7 @@ def test_empty_archive_rejected():def test_validate_and_normalize_rejects_skill_md_too_large(monkeypatch: pytest.MonkeyPatch):- monkeypatch.setattr(skill_package_service_module, "_MAX_SKILL_MD_BYTES", 8)+ apply_config_overrides(monkeypatch, SKILL_PACKAGE_MAX_SKILL_MD_BYTES=8)with pytest.raises(SkillPackageError) as exc_info:_normalize({"SKILL.md": _SKILL_MD.encode()})@@ -215,15 +263,15 @@ def test_validate_and_normalize_rejects_skill_md_too_large(monkeypatch: pytest.Mdef test_validate_and_normalize_rejects_too_many_entries(monkeypatch: pytest.MonkeyPatch):- monkeypatch.setattr(skill_package_service_module, "_MAX_ENTRIES", 1)+ apply_config_overrides(monkeypatch, SKILL_PACKAGE_MAX_ENTRIES=1)with pytest.raises(SkillPackageError) as exc_info:- _normalize({"SKILL.md": _SKILL_MD.encode(), "scripts/run.py": b"print('x')\n"})+ _normalize({"SKILL.md": _SKILL_MD.encode(), "assets/": b""})assert exc_info.value.code == "too_many_entries"def test_validate_and_normalize_rejects_archive_too_large_uncompressed(monkeypatch: pytest.MonkeyPatch):- monkeypatch.setattr(skill_package_service_module, "_MAX_UNCOMPRESSED_BYTES", 32)+ apply_config_overrides(monkeypatch, SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES=32)with pytest.raises(SkillPackageError) as exc_info:_normalize({"SKILL.md": _SKILL_MD.encode(), "scripts/run.py": b"x" * 33})@@ -231,8 +279,6 @@ def test_validate_and_normalize_rejects_archive_too_large_uncompressed(monkeypatdef test_validate_and_normalize_rejects_archive_too_large_uploaded_bytes(monkeypatch: pytest.MonkeyPatch):- from tests.unit_tests.config_override import apply_config_overrides-apply_config_overrides(monkeypatch, UPLOAD_SKILL_FILE_SIZE_LIMIT=1)with pytest.raises(SkillPackageError) as exc_info:@@ -240,35 +286,14 @@ def test_validate_and_normalize_rejects_archive_too_large_uploaded_bytes(monkeypassert exc_info.value.code == "archive_too_large"-def test_bad_frontmatter_yaml_rejected():- bad = b"---\n: : : not yaml\n---\n# x\n"- with pytest.raises(SkillPackageError) as exc_info:- _normalize({"SKILL.md": bad})- assert exc_info.value.code == "invalid_frontmatter"---def test_unterminated_frontmatter_rejected():+def test_high_compression_ratio_uses_absolute_expansion_limit(monkeypatch: pytest.MonkeyPatch) -> None:+ content = _zip({"SKILL.md": _SKILL_MD.encode(), "data.bin": b"x" * (1024 * 1024)})+ service = SkillPackageService()+ assert service.inspect(content=content, filename="skill.zip").name == "pdf-toolkit"+ apply_config_overrides(monkeypatch, SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES=1024)with pytest.raises(SkillPackageError) as exc_info:- _normalize({"SKILL.md": b"---\n# heading-wins\nbody"})- assert exc_info.value.code == "missing_skill_name"---def test_validate_and_normalize_rejects_files_outside_selected_skill_root():- with pytest.raises(SkillPackageError) as exc_info:- _normalize({"bundle/pdf-toolkit/SKILL.md": _SKILL_MD.encode(), "README.md": b"x"})- assert exc_info.value.code == "files_outside_skill_root"---def test_validate_and_normalize_rejects_duplicate_normalized_paths():- with pytest.raises(SkillPackageError) as exc_info:- _normalize(- {- "pdf-toolkit/SKILL.md": _SKILL_MD.encode(),- "pdf-toolkit/scripts/run.py": b"print('x')\n",- "pdf-toolkit/scripts/./run.py": b"print('y')\n",- }- )- assert exc_info.value.code == "duplicate_member_path"+ service.inspect(content=content, filename="skill.zip")+ assert exc_info.value.code == "archive_too_large"def test_validate_and_normalize_maps_member_decompression_failures_to_invalid_archive(monkeypatch: pytest.MonkeyPatch):diff --git a/api/tests/unit_tests/services/test_agent_config_service.py b/api/tests/unit_tests/services/test_agent_config_service.pyindex f69def8bd7c..dcd6af670c4 100644--- a/api/tests/unit_tests/services/test_agent_config_service.py+++ b/api/tests/unit_tests/services/test_agent_config_service.py@@ -366,7 +366,7 @@ def test_push_accepts_tenant_scoped_tool_file_sources_from_different_upload_ownepatch.object(service._skill_normalizer,"normalize",- return_value=(skill_ref, object()),+ return_value=skill_ref,),):manifest = service.push(diff --git a/api/tests/unit_tests/services/test_app_dsl_service.py b/api/tests/unit_tests/services/test_app_dsl_service.pyindex 86a410c665e..b7d84895d04 100644--- a/api/tests/unit_tests/services/test_app_dsl_service.py+++ b/api/tests/unit_tests/services/test_app_dsl_service.py@@ -9,11 +9,13 @@ import yamlfrom sqlalchemy import event, selectfrom sqlalchemy.orm import Session, sessionmaker+from constants.dsl_version import CURRENT_APP_DSL_VERSIONfrom core.rbac import RBACPermission, RBACResourceScopefrom core.workflow.llm_environment_variable import LLMEnvironmentVariablefrom models import Account, App, AppMode, Tenantfrom models.model import AppModelConfig, AppModelConfigDict, IconTypefrom models.workflow import Workflow, WorkflowType+from services.agent.dsl_entities import AgentPackagefrom services.app_dsl_service import AppDslService, Import, PendingDatafrom services.enterprise.enterprise_service import EnterpriseServicefrom services.entities.dsl_entities import ImportStatus@@ -795,3 +797,56 @@ def test_append_workflow_export_data_reports_missing_selected_workflow(session=unbound_session,workflow_id=workflow_id,)+++ "mode",+ [AppMode.AGENT, AppMode.WORKFLOW, AppMode.ADVANCED_CHAT, AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.COMPLETION],+)+def test_export_dsl_preserves_envelope_and_mode_specific_content(+ mode: AppMode, monkeypatch: pytest.MonkeyPatch, unbound_session: Session+) -> None:+ app = _app(mode=mode)+ package = AgentPackage.model_validate({"metadata": {"name": app.name}, "soul": {}})+ monkeypatch.setattr(+ "services.app_dsl_service.AgentDslService.export_agent_app",+ Mock(return_value=("agent_1", {"agent_1": package})),+ )+ monkeypatch.setattr(+ "services.app_dsl_service.DependenciesAnalysisService.generate_dependencies", Mock(return_value=[])+ )++ def append_workflow(*, export_data: dict[str, object], **_kwargs: object) -> None:+ export_data["workflow"] = {"fixture": "workflow"}++ def append_model(export_data: dict[str, object], *_args: object, **_kwargs: object) -> None:+ export_data["model_config"] = {"fixture": "model"}++ monkeypatch.setattr(AppDslService, "_append_workflow_export_data", Mock(side_effect=append_workflow))+ monkeypatch.setattr(AppDslService, "_append_model_config_export_data", Mock(side_effect=append_model))+ data = yaml.safe_load(AppDslService.export_dsl(app, session=unbound_session))+ assert data["version"] == CURRENT_APP_DSL_VERSION+ assert data["kind"] == "app"+ assert data["app"] == {+ "name": "Existing app",+ "description": "",+ "mode": mode.value,+ "icon_type": "emoji",+ "icon": "robot",+ "icon_background": "#FFFFFF",+ "use_icon_as_answer_icon": False,+ }+ if mode == AppMode.AGENT:+ assert data["agent"] == {"package_ref": "agent_1"}+ assert AgentPackage.model_validate(data["agent_packages"]["agent_1"]) == package+ assert data["dependencies"] == []+ assert "workflow" not in data+ assert "model_config" not in data+ elif mode in {AppMode.WORKFLOW, AppMode.ADVANCED_CHAT}:+ assert data["workflow"] == {"fixture": "workflow"}+ assert "agent" not in data+ assert "model_config" not in data+ else:+ assert data["model_config"] == {"fixture": "model"}+ assert "agent" not in data+ assert "workflow" not in datadiff --git a/api/tests/unit_tests/services/test_skill_management_service.py b/api/tests/unit_tests/services/test_skill_management_service.pyindex 951c7147a36..7e83f39e82e 100644--- a/api/tests/unit_tests/services/test_skill_management_service.py+++ b/api/tests/unit_tests/services/test_skill_management_service.py@@ -2829,21 +2829,27 @@ def test_import_skill_package_rejects_archive_larger_than_upload_skill_limit(monassert exc_info.value.code == "archive_too_large"-def test_import_skill_package_rejects_zip_bomb_before_reading_members() -> None:+def test_import_skill_package_rejects_excessive_expansion_before_reading_members(+ monkeypatch: pytest.MonkeyPatch,+) -> None:+ apply_config_overrides(monkeypatch, SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES=1024 * 1024)package = io.BytesIO()with zipfile.ZipFile(package, "w", compression=zipfile.ZIP_DEFLATED) as archive:archive.writestr("payload.bin", b"\x00" * (8 * 1024 * 1024))service = SkillManagementService(tool_file_manager=_FakeToolFileManager())- with pytest.raises(SkillManagementServiceError) as exc_info:+ with (+ patch.object(zipfile.ZipFile, "read", side_effect=AssertionError("member read before size validation")),+ pytest.raises(SkillManagementServiceError) as exc_info,+ ):service._draft_payload_from_zip(tenant_id=TENANT,user_id=USER,archive_bytes=package.getvalue(),)- assert exc_info.value.code == "invalid_skill_package"+ assert exc_info.value.code == "skill_too_large"def test_publish_and_export_include_binary_tool_files() -> None:@@ -3273,6 +3279,7 @@ def test_runtime_agent_skills_use_published_identity_when_draft_metadata_changeddescription="draft description",)version = SimpleNamespace(+ id="version-1",archive_tool_file_id="archive-1",archive_size=10,hash_code="hash-1",@@ -3283,8 +3290,10 @@ def test_runtime_agent_skills_use_published_identity_when_draft_metadata_changeddescription="published description",),)+ binding = SimpleNamespace(priority=0)+ tool_file = SimpleNamespace(file_key="tools/archive-1.zip")session = MagicMock()- session.execute.return_value = [(SimpleNamespace(), skill, version)]+ session.execute.return_value = [(binding, skill, version, tool_file)]with patch("services.skill_management_service.session_factory.create_session") as create_session:create_session.return_value.__enter__.return_value = session@@ -3358,6 +3367,29 @@ def test_agent_skill_binding_changes_require_agent_publish_before_runtime_load()assert service.list_runtime_agent_skills(tenant_id=TENANT, agent_id=AGENT)[0]["name"] == "finance-sop"+ with session_factory.create_session() as session:+ agent = session.get(Agent, AGENT)+ assert agent is not None+ next_snapshot = AgentConfigSnapshot(+ tenant_id=TENANT,+ agent_id=AGENT,+ version=2,+ config_snapshot=AgentSoulConfig(),+ created_by=USER,+ )+ session.add(next_snapshot)+ session.flush()+ agent.active_config_snapshot_id = next_snapshot.id+ session.commit()++ assert service.list_runtime_agent_skills(tenant_id=TENANT, agent_id=AGENT) == []+ historical_skills = service.list_runtime_agent_skills(+ tenant_id=TENANT, agent_id=AGENT, config_snapshot_id=snapshot_id+ )+ assert [skill["name"] for skill in historical_skills] == ["finance-sop"]+ draft_skills = service.list_runtime_agent_skills(tenant_id=TENANT, agent_id=AGENT, include_draft=True)+ assert [skill["name"] for skill in draft_skills] == ["finance-sop"]+def test_runtime_agent_skill_pull_normalizes_archive_identity_to_published_metadata() -> None:archive_buffer = io.BytesIO()@@ -3378,3 +3410,14 @@ def test_runtime_agent_skill_pull_normalizes_archive_identity_to_published_metadassert "description: Published description" in skill_mdassert "display-name: Published Name" in skill_mdassert archive.read("references/example.md") == b"Example"+++def test_archive_limits_accept_high_compression_ratio_within_size_budget(monkeypatch: pytest.MonkeyPatch) -> None:+ output = io.BytesIO()+ with zipfile.ZipFile(output, "w", compression=zipfile.ZIP_DEFLATED) as archive:+ archive.writestr("data.bin", b"x" * (1024 * 1024))+ with zipfile.ZipFile(io.BytesIO(output.getvalue())) as archive:+ assert SkillManagementService._validate_archive_limits(archive)[0].file_size == 1024 * 1024+ apply_config_overrides(monkeypatch, SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES=1024)+ with pytest.raises(SkillManagementServiceError, match="uncompressed size limit"):+ SkillManagementService._validate_archive_limits(archive)diff --git a/docker/envs/core-services/shared.env.example b/docker/envs/core-services/shared.env.exampleindex f5ae7604d0c..fbb960b742c 100644--- a/docker/envs/core-services/shared.env.example+++ b/docker/envs/core-services/shared.env.example@@ -66,6 +66,12 @@ UPLOAD_IMAGE_FILE_SIZE_LIMIT=10UPLOAD_VIDEO_FILE_SIZE_LIMIT=100UPLOAD_AUDIO_FILE_SIZE_LIMIT=50UPLOAD_SKILL_FILE_SIZE_LIMIT=50+SKILL_PACKAGE_MAX_UNCOMPRESSED_BYTES=209715200+SKILL_PACKAGE_MAX_ENTRIES=5000+SKILL_PACKAGE_MAX_SKILL_MD_BYTES=1048576+AGENT_PACKAGE_MAX_BYTES=536870912+AGENT_PACKAGE_MAX_MANIFEST_BYTES=5242880+AGENT_PACKAGE_MAX_ENTRIES=5000API_SENTRY_DSN=API_SENTRY_TRACES_SAMPLE_RATE=1.0API_SENTRY_PROFILES_SAMPLE_RATE=1.0