Merge pull request #1768 from yjlu666/bugfix/superteam

fix(console): restore migration UI and protect resource references

Author: yjlu666

console/backend/astron_console/knowledge/tests/test_resources.py

@@ -10,6 +10,7 @@
 from sqlalchemy import text as sql_text
 
 from astron_console.accounts.models import User, UserProfile
+from astron_console.agents.models import Agent, AgentState, AgentVersion
 from astron_console.knowledge import clients, databases, files, storage
 from astron_console.knowledge.models import (
     Artifact,
@@ -24,6 +25,7 @@
     Repo,
 )
 from astron_console.spaces.models import GroupVisibility
+from astron_console.workflows.models import Workflow, WorkflowVersion
 
 
 class ResourceTests(TestCase):
@@ -93,6 +95,45 @@ def test_shared_read_does_not_grant_write(self):
             self.post("/repo/update-repo", {"id": self.repo.pk, "name": "attack"}).status_code, 403
         )
 
+    def test_repo_delete_and_use_status_preserve_python_references(self):
+        for source in ("draft", "version", "workflow-version"):
+            with self.subTest(source=source):
+                repo = Repo.objects.create(
+                    name=source,
+                    user_id=self.user.pk,
+                    core_repo_id=f"core-{source}",
+                    tag="AIUI-RAG2",
+                )
+                agent = Agent.objects.create(uid=self.user.pk)
+                if source == "draft":
+                    AgentState.objects.create(agent_id=agent.pk, config={"repoIds": [repo.pk]})
+                elif source == "version":
+                    AgentVersion.objects.create(
+                        agent_id=agent.pk,
+                        definition={"repoIds": [repo.pk]},
+                        created_by=self.user.pk,
+                    )
+                else:
+                    workflow = Workflow.objects.create(
+                        uid=self.user.pk, app_id="app", flow_id="repo-flow", name="Saved", data="{}"
+                    )
+                    WorkflowVersion.objects.create(
+                        flow_id=workflow.flow_id,
+                        version_num="v1",
+                        data=json.dumps(
+                            {"nodes": [{"data": {"nodeParam": {"repoIds": [repo.pk]}}}]}
+                        ),
+                    )
+                usage = self.client.get("/repo/get-repo-use-status", {"id": repo.pk})
+                self.assertEqual(usage.status_code, 200, usage.content)
+                self.assertTrue(usage.json()["data"])
+                with patch("astron_console.knowledge.views.delete_document") as remove:
+                    result = self.client.delete(f"/repo/delete-repo?id={repo.pk}")
+                self.assertEqual(result.status_code, 400, result.content)
+                remove.assert_not_called()
+                repo.refresh_from_db()
+                self.assertFalse(repo.deleted)
+
     @patch(
         "astron_console.knowledge.clients.rag",
         side_effect=clients.ResourceServiceError("资源服务暂时不可用"),

console/backend/astron_console/knowledge/views.py

@@ -163,6 +163,14 @@ def check_references(table, column, identifier):
             raise ValidationError("资源仍被引用，不能删除")
 
 
+def check_repo_references(repo):
+    from astron_console.resources.references import ensure_definition_unreferenced
+
+    check_references("flow_repo_rel", "repo_id", repo.core_repo_id)
+    check_references("bot_repo_rel", "repo_id", repo.pk)
+    ensure_definition_unreferenced("repo", {repo.pk, repo.core_repo_id})
+
+
 def rag_params(repo, file):
     return {
         "ragType": repo.tag,
@@ -258,8 +266,7 @@ def repos(request, action):
         return [file_dump(x) for x in Document.objects.filter(repo_id=row.pk)]
     if action == "get-repo-use-status":
         try:
-            check_references("flow_repo_rel", "repo_id", row.core_repo_id)
-            check_references("bot_repo_rel", "repo_id", row.pk)
+            check_repo_references(row)
         except ValidationError:
             return True
         return False
@@ -313,8 +320,7 @@ def repos(request, action):
     elif action == "set-top":
         row.is_top = not row.is_top
     elif action == "delete-repo":
-        check_references("flow_repo_rel", "repo_id", row.core_repo_id)
-        check_references("bot_repo_rel", "repo_id", row.pk)
+        check_repo_references(row)
         for file in Document.objects.filter(repo_id=row.pk):
             delete_document(file, row)
         Directory.objects.filter(app_id=str(row.pk)).delete()

console/backend/astron_console/resources/model_views.py

@@ -28,7 +28,6 @@
     ModelCategory,
     ModelCategoryRelation,
     OfficialModel,
-    WorkflowScope,
 )
 
 logger = logging.getLogger(__name__)
@@ -280,25 +279,52 @@ def _java_llm_id(pk):
 
 
 def ensure_unreferenced(row):
+    from astron_console.agents.models import Agent, AgentVersion
+    from astron_console.workflows.models import Workflow, WorkflowVersion
+
     tables = connection.introspection.table_names()
+    if "chat_bot_base" in tables:
+        agents = Agent.objects.filter(is_delete=0, version=1)
+        if agents.filter(model_id=row.pk).exists():
+            raise ValidationError("模型仍被 Agent 引用，无法删除")
+        if (
+            "console_agent_version" in tables
+            and AgentVersion.objects.filter(
+                agent_id__in=agents.values("pk"), definition__modelId__in=[row.pk, str(row.pk)]
+            ).exists()
+        ):
+            raise ValidationError("模型仍被 Agent 版本引用，无法删除")
     if "workflow" in tables:
-        refs = {row.id, _java_llm_id(row.id), (row.id + 123456) ^ 654321}
-        for item in WorkflowScope.objects.filter(deleted=False):
-            data = parsed(item.data)
-
-            def references(value):
-                if isinstance(value, dict):
-                    for key, v in value.items():
-                        if key in {"modelId", "llmId"} and str(v) in {str(r) for r in refs}:
-                            return True
-                        if references(v):
-                            return True
-                if isinstance(value, list):
-                    return any(references(v) for v in value)
-                return False
-
-            if references(data):
+        refs = {str(value) for value in (row.id, _java_llm_id(row.id), (row.id + 123456) ^ 654321)}
+
+        def references(value):
+            if isinstance(value, dict):
+                return any(
+                    (key in {"modelId", "llmId"} and str(item) in refs) or references(item)
+                    for key, item in value.items()
+                )
+            if isinstance(value, list):
+                return any(references(item) for item in value)
+            return False
+
+        for item in (
+            Workflow.objects.filter(deleted=False)
+            .only("flow_id", "data", "published_data")
+            .iterator()
+        ):
+            if references(parsed(item.data)) or references(parsed(item.published_data)):
                 raise ValidationError("模型仍被工作流引用，无法删除")
+            # Versions remain executable after the editable draft changes. Match each
+            # retained flow ID as a value, avoiding cross-table collation assumptions.
+            if "workflow_version" in tables and item.flow_id:
+                versions = (
+                    WorkflowVersion.objects.filter(flow_id=item.flow_id, is_deleted=0)
+                    .exclude(deleted=2)
+                    .values_list("data", flat=True)
+                    .iterator()
+                )
+                if any(references(parsed(data)) for data in versions):
+                    raise ValidationError("模型仍被工作流版本引用，无法删除")
     if "bot_model_bind" in tables:
         with connection.cursor() as cursor:
             cursor.execute("SELECT 1 FROM bot_model_bind WHERE domain = %s LIMIT 1", [row.domain])

console/backend/astron_console/resources/references.py

@@ -0,0 +1,60 @@
+"""Deletion guards for references stored in Python drafts and immutable versions."""
+
+from django.core.exceptions import ValidationError
+
+from .common import parsed
+
+
+def ensure_definition_unreferenced(kind, identifiers):
+    from astron_console.agents.definitions import definition
+    from astron_console.agents.models import Agent, AgentVersion
+    from astron_console.workflows.models import Workflow, WorkflowVersion
+
+    identifiers = {str(value) for value in identifiers if value not in (None, "")}
+    fields = {
+        "tool": {"tools", "pluginId", "toolId", "tool_id"},
+        "repo": {"repoIds", "repoId", "knowledge"},
+    }[kind]
+    message = {"tool": "工具", "repo": "知识库"}[kind] + "仍被 Agent 或工作流引用，无法删除"
+
+    def matches(value):
+        if isinstance(value, list):
+            return any(matches(item) for item in value)
+        if isinstance(value, dict):
+            return any(matches(value[key]) for key in fields | {"id"} if key in value)
+        return not isinstance(value, bool) and str(value) in identifiers
+
+    def check(value):
+        if isinstance(value, dict):
+            for key, item in value.items():
+                if key in fields and matches(item):
+                    raise ValidationError(message)
+                check(item)
+        elif isinstance(value, list):
+            for item in value:
+                check(item)
+
+    agents = Agent.objects.filter(is_delete=0, version=1)
+    for agent in agents.iterator():
+        # Use the same retained MAAS dataset and Python state precedence as execution.
+        check(definition(agent))
+    for config in (
+        AgentVersion.objects.filter(agent_id__in=agents.values("pk"))
+        .values_list("definition", flat=True)
+        .iterator()
+    ):
+        check(config)
+    for workflow in (
+        Workflow.objects.filter(deleted=False).only("flow_id", "data", "published_data").iterator()
+    ):
+        check(parsed(workflow.data))
+        check(parsed(workflow.published_data))
+        if workflow.flow_id:
+            # Compare IDs to values, not across retained tables with different collations.
+            for data in (
+                WorkflowVersion.objects.filter(flow_id=workflow.flow_id, is_deleted=0)
+                .exclude(deleted=2)
+                .values_list("data", flat=True)
+                .iterator()
+            ):
+                check(parsed(data))

console/backend/astron_console/resources/tests/test_resources.py

@@ -5,6 +5,7 @@
 from django.test import Client, TransactionTestCase, override_settings
 
 from astron_console.accounts.models import User, UserProfile
+from astron_console.agents.models import Agent, AgentVersion
 from astron_console.resources.common import UpstreamError
 from astron_console.resources.models import (
     ConfigInfo,
@@ -16,6 +17,7 @@
     WorkflowScope,
 )
 from astron_console.spaces.models import Space, SpaceMember, SpacePermission
+from astron_console.workflows.models import Workflow, WorkflowVersion
 
 SCHEMA = {
     "openapi": "3.0.3",
@@ -246,6 +248,45 @@ def test_model_delete_requires_write_verb(self):
         self.model.refresh_from_db()
         self.assertTrue(self.model.is_deleted)
 
+    def test_model_delete_preserves_agent_draft_reference(self):
+        Agent.objects.create(uid=self.user.pk, model_id=self.model.pk)
+        result = self.client.delete(f"/api/model/delete?modelId={self.model.pk}")
+        self.assertEqual(result.status_code, 400, result.content)
+        self.model.refresh_from_db()
+        self.assertFalse(self.model.is_deleted)
+
+    def test_model_delete_preserves_agent_version_after_draft_changes(self):
+        agent = Agent.objects.create(uid=self.user.pk, model_id=None)
+        AgentVersion.objects.create(
+            agent_id=agent.pk,
+            definition={"modelId": self.model.pk},
+            created_by=self.user.pk,
+        )
+        result = self.client.delete(f"/api/model/delete?modelId={self.model.pk}")
+        self.assertEqual(result.status_code, 400, result.content)
+        self.model.refresh_from_db()
+        self.assertFalse(self.model.is_deleted)
+        Agent.objects.filter(pk=agent.pk).update(is_delete=1)
+        result = self.client.delete(f"/api/model/delete?modelId={self.model.pk}")
+        self.assertEqual(result.status_code, 200, result.content)
+
+    def test_model_delete_preserves_workflow_version_after_draft_changes(self):
+        workflow = Workflow.objects.create(
+            uid=self.user.pk, app_id="app", flow_id="version-only-model", name="Saved", data="{}"
+        )
+        version = WorkflowVersion.objects.create(
+            flow_id=workflow.flow_id,
+            version_num="v1",
+            data=json.dumps({"nodes": [{"data": {"nodeParam": {"modelId": self.model.pk}}}]}),
+        )
+        result = self.client.delete(f"/api/model/delete?modelId={self.model.pk}")
+        self.assertEqual(result.status_code, 400, result.content)
+        self.model.refresh_from_db()
+        self.assertFalse(self.model.is_deleted)
+        WorkflowVersion.objects.filter(pk=version.pk).update(deleted=2)
+        result = self.client.delete(f"/api/model/delete?modelId={self.model.pk}")
+        self.assertEqual(result.status_code, 200, result.content)
+
     def test_internal_brokers_require_credentials(self):
         for url in [
             "/model/internal-runtime-config?flowId=flow&modelId=1",
@@ -365,6 +406,45 @@ def test_tool_upstream_failure_does_not_create_local_success(self):
         self.assertEqual(result.status_code, 502)
         self.assertFalse(Tool.objects.exists())
 
+    def test_tool_delete_preserves_new_agent_references_before_remote_delete(self):
+        for source in ("draft", "version", "workflow-version"):
+            with self.subTest(source=source):
+                tool = Tool.objects.create(
+                    user_id=self.user.pk, tool_id=f"remote-{source}", version="V1", deleted=0
+                )
+                # Deleting another card of the same tool also deletes this version upstream.
+                selected = Tool.objects.create(
+                    user_id=self.user.pk, tool_id=tool.tool_id, version="V2", deleted=0
+                )
+                agent = Agent.objects.create(
+                    uid=self.user.pk, tools=json.dumps([tool.pk] if source == "draft" else [])
+                )
+                if source == "version":
+                    AgentVersion.objects.create(
+                        agent_id=agent.pk,
+                        definition={"tools": [{"toolId": tool.tool_id, "version": "V1"}]},
+                        created_by=self.user.pk,
+                    )
+                elif source == "workflow-version":
+                    workflow = Workflow.objects.create(
+                        uid=self.user.pk, app_id="app", flow_id="tool-flow", name="Saved", data="{}"
+                    )
+                    WorkflowVersion.objects.create(
+                        flow_id=workflow.flow_id,
+                        version_num="v1",
+                        data=json.dumps(
+                            {"nodes": [{"data": {"nodeParam": {"pluginId": tool.tool_id}}}]}
+                        ),
+                    )
+                with patch("astron_console.resources.clients.call") as remote:
+                    result = self.client.delete(f"/resources/tools/{selected.pk}")
+                self.assertEqual(result.status_code, 400, result.content)
+                remote.assert_not_called()
+                tool.refresh_from_db()
+                selected.refresh_from_db()
+                self.assertFalse(tool.deleted)
+                self.assertFalse(selected.deleted)
+
     def test_tool_registration_and_secret_mask(self):
         with patch(
             "astron_console.resources.clients.call",

console/backend/astron_console/resources/tools.py

@@ -316,6 +316,14 @@ def item(request, pk):
         uid_field="user_id",
         deleted="deleted",
     )
+    from .references import ensure_definition_unreferenced
+
+    # The upstream DELETE removes all versions of this remote tool, so include
+    # every local version ID rather than only the selected card.
+    identifiers = {row.pk, row.tool_id}
+    if row.tool_id:
+        identifiers.update(Tool.objects.filter(tool_id=row.tool_id).values_list("pk", flat=True))
+    ensure_definition_unreferenced("tool", identifiers)
     if row.tool_id:
         tables = connection.introspection.table_names()
         for table in ("flow_tool_rel", "bot_tool_rel"):

console/frontend/_tests_/workflow-config-persistence.test.js

@@ -391,6 +391,7 @@ function workflowListUI(createTalkAgent) {
   const dependencies = {
     react: {
       useEffect: noop,
+      useRef: initial => ({ current: initial }),
       useState: initial => {
         const index = cursor++;
         if (!(index in states)) states[index] = initial;
@@ -408,8 +409,15 @@ function workflowListUI(createTalkAgent) {
       useNavigate: () => path => routes.push(path),
     },
     antd: {
+      Alert: 'Alert',
+      Dropdown: 'Dropdown',
+      Empty: 'Empty',
+      Spin: 'Spin',
       Button: 'Button',
-      Input: { Search: 'Search', TextArea: 'TextArea' },
+      Input: Object.assign(() => null, {
+        Search: 'Search',
+        TextArea: 'TextArea',
+      }),
       Modal: 'Modal',
       Pagination: 'Pagination',
       message: {},
@@ -422,7 +430,14 @@ function workflowListUI(createTalkAgent) {
     },
     '@/services/spark-common': { createTalkAgent },
     '@/components/workflow/utils': {},
-    '@/pages/agents/style.css': {},
+    '@/store/space-store': { default: () => ({}), __esModule: true },
+    '@/assets/imgs/workflow/flow-icon.png': 'workflow-icon',
+    '@/pages/agents/catalog.module.scss': {},
+    '@ant-design/icons': {
+      EllipsisOutlined: 'EllipsisOutlined',
+      PlusOutlined: 'PlusOutlined',
+      UploadOutlined: 'UploadOutlined',
+    },
   };
   const require = createRequire(import.meta.url);
   const code = ts.transpileModule(