Skip to content

armgit / dify

Public Imported from GitHub
0

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

61.8 KB
Raw Blame
from __future__ import annotations

import hashlib
import io
import zipfile
from collections.abc import Callable, Generator
from functools import partial
from uuid import UUID

import pytest
import yaml
from flask import Flask, send_file
from pydantic import ValidationError
from sqlalchemy import Engine
from sqlalchemy.orm import Session, sessionmaker
from sqlalchemy.pool import QueuePool

from configs import dify_config
from extensions.storage.storage_type import StorageType
from libs.datetime_utils import naive_utc_now
from models.agent import (
    Agent,
    AgentConfigDraft,
    AgentConfigDraftType,
    AgentConfigRevision,
    AgentConfigRevisionOperation,
    AgentConfigSnapshot,
    AgentKind,
    AgentScope,
    AgentSource,
    AgentStatus,
)
from models.agent_config_entities import AgentSoulConfig
from models.enums import AppStatus, CreatorUserRole, CustomizeTokenStrategy
from models.model import App, AppMode, IconType, Site
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 (
    AgentVersionNotFoundError,
    InvalidRosterAgentPackageError,
    RosterAgentPackageExportFailedError,
    RosterAgentPackageImportFailedError,
    RosterAgentPackageResourceUnavailableError,
    RosterAgentPackageTooLargeError,
)
from services.agent.package_resource_exporter import AgentPackageResourceExporter, _FileSource, _SkillSource
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.helpers.unit.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]:
        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()})


@pytest.mark.parametrize(
    ("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)


@pytest.mark.parametrize(
    ("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))})


@pytest.mark.parametrize(
    ("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)


@pytest.mark.parametrize(
    ("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})


@pytest.mark.parametrize("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))


@pytest.mark.parametrize("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


@pytest.mark.parametrize(
    ("error", "error_code", "status"),
    [
        (InvalidRosterAgentPackageError(), "invalid_roster_agent_package", 400),
        (RosterAgentPackageTooLargeError(), "roster_agent_package_too_large", 413),
        (RosterAgentPackageExportFailedError(), "roster_agent_package_export_failed", 500),
        (RosterAgentPackageImportFailedError(), "roster_agent_package_import_failed", 500),
        (
            RosterAgentPackageResourceUnavailableError(),
            "roster_agent_package_resource_unavailable",
            503,
        ),
    ],
)
def test_roster_package_errors_use_standard_http_payload(
    error: (
        InvalidRosterAgentPackageError
        | RosterAgentPackageTooLargeError
        | RosterAgentPackageExportFailedError
        | RosterAgentPackageImportFailedError
        | RosterAgentPackageResourceUnavailableError
    ),
    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


@pytest.mark.parametrize("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))


@pytest.mark.parametrize("path", ["manifest.yaml", "app.yaml"])
@pytest.mark.parametrize(
    "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))


@pytest.mark.parametrize("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)))


@pytest.mark.parametrize(
    "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(), strict=False)
        ],
    )
    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()
    resources = AgentPackageResourceExporter(storage_backend=_MemoryStorage(skill_payloads))
    sources = [
        _SkillSource(
            path=item.path,
            storage_key=item.path,
            id=item.id,
            scope=item.scope,
            name=item.name,
        )
        for item in manifest.skills
    ]
    resources.sources["agent_1"] = (sources, list[_FileSource]())
    with pytest.raises(RosterAgentPackageTooLargeError, match="nested Skill contents"):
        exporter._build_archive(app=_package_app(soul), resources=resources)


@pytest.mark.parametrize("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


@pytest.mark.parametrize("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))


@pytest.mark.parametrize(
    ("case", "error_type", "message"),
    [
        ("missing_manifest", RosterAgentPackageExportFailedError, "unusable Skill"),
        ("name_mismatch", RosterAgentPackageExportFailedError, "Skill"),
        ("size_limit", RosterAgentPackageTooLargeError, "size limit"),
        ("missing_payload", RosterAgentPackageExportFailedError, "Unable to read"),
    ],
)
@pytest.mark.parametrize("local", [False, True])
def test_export_rejects_unusable_or_oversized_skill_payload(
    case: str,
    error_type: type[RosterAgentPackageExportFailedError | RosterAgentPackageTooLargeError],
    message: str,
    monkeypatch: pytest.MonkeyPatch,
    local: bool,
) -> 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 = _SkillSource(
        path="s_000001.zip",
        storage_key="skill",
        id="s_000001",
        scope="agent_config",
        name="research",
    )
    app = _package_app()
    app.package.soul.config_files = []
    exporter = RosterAgentPackageExporter()
    resources = AgentPackageResourceExporter(
        storage_backend=_MemoryStorage({} if case == "missing_payload" else {"skill": payload})
    )
    resources.sources["agent_1"] = ([source], list[_FileSource]())
    resources.packages["agent_1"] = app.package
    export = (
        partial(resources.read_local_resources, "agent_1")
        if local
        else partial(exporter._build_archive, app=app, resources=resources)
    )
    with pytest.raises(error_type, match=message):
        export()


@pytest.mark.parametrize("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"


@pytest.mark.parametrize("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,
            )


@pytest.mark.parametrize("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",
    )
    assert agent.app_id is not None
    site = Site(
        app_id=agent.app_id,
        title="Agent Site",
        default_language="en",
        customize_token_strategy=CustomizeTokenStrategy.NOT_ALLOW,
        icon_type=IconType.EMOJI,
        icon="S",
    )
    sqlite_session.add_all(
        [_app("33333333-3333-4333-8333-333333333333"), site, 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))
    assert standalone_dsl["site"]["title"] == "Agent Site"
    assert standalone_dsl["site"]["default_language"] == "en-US"
    with exporter.export(tenant_id="tenant-1", agent_id=agent.id, version_id=None) 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)
            assert exported_app.site is not None
            assert exported_app.site.title == "Agent Site"
            assert exported_app.site.default_language == "en-US"
            assert exported_app.site.icon == "S"
            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", "apps", "skills", "files"}
            for source_id in (agent.id, skill_file.id, config_file.id):
                assert source_id.encode() not in archive.read("manifest.yaml")
                assert source_id.encode() not in archive.read("app.yaml")
            assert set(manifest_data["files"][0]) == {
                "id",
                "path",
                "size",
                "sha256",
            }
            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", "site", "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, version_id=None) 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, version_id=None)
    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, version_id=None)
    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, version_id=None)
    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,
    sqlite_engine: Engine,
) -> None:
    monkeypatch.setattr(DependenciesAnalysisService, "generate_dependencies", lambda **_kwargs: [])
    workspace_payload = _skill_archive("legacy-published")
    storage = _MemoryStorage({"tools/workspace.zip": workspace_payload})
    pool = sqlite_engine.pool
    assert isinstance(pool, QueuePool)

    def load_legacy_skill(*, tenant_id: str, file_id: str) -> bytes:
        assert tenant_id == "tenant-1"
        assert file_id
        assert pool.checkedout() == 0
        return workspace_payload

    monkeypatch.setattr(
        "services.skill_management_service.SkillManagementService._load_tool_file_bytes",
        staticmethod(load_legacy_skill),
    )
    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, version_id=None) 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",
                "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, version_id=None) 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 == []

    historical_version_id = UUID(snapshot.id)
    active_snapshot = AgentConfigSnapshot(
        tenant_id="tenant-1",
        agent_id=agent.id,
        version=2,
        config_snapshot=AgentSoulConfig.model_validate({"prompt": {"system_prompt": "current published"}}),
        created_by="account-1",
    )
    sqlite_session.add(active_snapshot)
    sqlite_session.flush()
    agent.active_config_snapshot_id = active_snapshot.id
    sqlite_session.add(
        AgentConfigRevision(
            tenant_id="tenant-1",
            agent_id=agent.id,
            current_snapshot_id=str(historical_version_id),
            revision=1,
            operation=AgentConfigRevisionOperation.PUBLISH_DRAFT,
            created_by="account-1",
        )
    )
    sqlite_session.commit()

    with exporter.export(tenant_id="tenant-1", agent_id=agent.id, version_id=historical_version_id) as exported:
        with RosterAgentPackageReader().read(exported.archive) as prepared:
            assert prepared.apps["app.yaml"].package.soul.prompt.system_prompt == ""
            assert prepared.manifest.skills[0].name == "legacy-published"
            assert prepared.apps["app.yaml"].package.workspace_skills[0].priority == 0

    app_model = sqlite_session.get(App, agent.app_id)
    assert app_model is not None
    dsl = AgentAppDsl.model_validate(
        yaml.safe_load(AppDslService.export_dsl(app_model, session=sqlite_session, version_id=historical_version_id))
    )
    assert dsl.package.soul.prompt.system_prompt == ""
    assert len(dsl.package.workspace_skills) == 1
    assert dsl.package.workspace_skills[0].priority == 0
    exported_yaml = exporter.export_yaml(
        tenant_id=agent.tenant_id,
        agent_id=agent.id,
        version_id=historical_version_id,
    )
    assert AgentAppDsl.model_validate(yaml.safe_load(exported_yaml)) == dsl


@pytest.mark.parametrize("source", ["missing", "other_tenant", "other_agent", "internal_snapshot"])
@pytest.mark.parametrize("export_format", ["ifpkg", "yaml"])
def test_export_rejects_unavailable_agent_versions(sqlite_session: Session, source: str, export_format: str) -> None:
    app_model = _app("44444444-4444-4444-8444-444444444444")
    agent = Agent(
        tenant_id="tenant-1",
        name="Agent",
        description="",
        role="",
        agent_kind=AgentKind.DIFY_AGENT,
        scope=AgentScope.ROSTER,
        source=AgentSource.AGENT_APP,
        app_id=app_model.id,
        backing_app_id=app_model.id,
        status=AgentStatus.ACTIVE,
        created_by="account-1",
        updated_by="account-1",
    )
    agent.id = "55555555-5555-4555-8555-555555555555"
    version_id = UUID("66666666-6666-4666-8666-666666666666")
    sqlite_session.add_all([app_model, agent])
    if source != "missing":
        snapshot = AgentConfigSnapshot(
            id=str(version_id),
            tenant_id="other-tenant" if source == "other_tenant" else agent.tenant_id,
            agent_id="other-agent" if source == "other_agent" else agent.id,
            version=1,
            config_snapshot=AgentSoulConfig(),
            created_by="account-1",
        )
        sqlite_session.add_all(
            [
                snapshot,
                AgentConfigRevision(
                    tenant_id=snapshot.tenant_id,
                    agent_id=snapshot.agent_id,
                    current_snapshot_id=snapshot.id,
                    revision=1,
                    operation=(
                        AgentConfigRevisionOperation.CREATE_VERSION
                        if source == "internal_snapshot"
                        else AgentConfigRevisionOperation.PUBLISH_DRAFT
                    ),
                ),
            ]
        )
    sqlite_session.commit()

    if export_format == "ifpkg":
        with pytest.raises(AgentVersionNotFoundError):
            RosterAgentPackageExporter().export(tenant_id=agent.tenant_id, agent_id=agent.id, version_id=version_id)
    else:
        with pytest.raises(AgentVersionNotFoundError):
            AppDslService.export_dsl(app_model, session=sqlite_session, version_id=version_id)


def test_manifest_yaml_ignores_unknown_fields() -> None:
    skill_payload = _skill_archive()
    file_payload = b"pdf-content"
    expected = _manifest(skill_payload=skill_payload, file_payload=file_payload)
    manifest = expected.model_dump(mode="json")
    manifest["unexpected"] = True
    for group in ("apps", "skills", "files"):
        for resource in manifest[group]:
            resource["unexpected"] = True

    assert RosterAgentPackageManifest.model_validate(yaml.safe_load(yaml.safe_dump(manifest))) == expected


@pytest.mark.parametrize(
    ("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:
    resources = AgentPackageResourceExporter()
    resources.sources["agent_1"] = (list[_SkillSource](), list[_FileSource]())
    exported = RosterAgentPackageExporter()._build_archive(app=_package_app(AgentSoulConfig()), resources=resources)
    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


@pytest.mark.parametrize("file_kind", ["upload_file", "tool_file"])
@pytest.mark.parametrize(
    ("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,
    sqlite_session: Session,
    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 = AgentPackageResourceExporter(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 = UploadFile(
        tenant_id="tenant-1",
        storage_type=StorageType.LOCAL,
        key="payload",
        name="original.pdf",
        size=1,
        extension="pdf",
        mime_type=stored_mime,
        created_by_role=CreatorUserRole.ACCOUNT,
        created_by="account-1",
        created_at=naive_utc_now(),
        used=False,
    )
    upload_file.id = "source-id"
    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=sqlite_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"


@pytest.mark.parametrize("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})


@pytest.mark.parametrize(
    ("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


@pytest.mark.parametrize(
    "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)