同步:完善质量分析工作台并更新主题字体

同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。
补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。
统一午夜黑及其他主题的控件细节、中文和业务数字字体。
排除本地业务数据、凭据、预览、发布与验收产物。

验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
This commit is contained in:
2026-10-30 22:40:58 +08:00
parent edef747e3b
commit ff7bbe3e46
393 changed files with 62999 additions and 1783 deletions
+430
View File
@@ -0,0 +1,430 @@
"""Offline isolation checks for concurrent NAO actor sessions; never calls a model."""
from __future__ import annotations
import contextlib
import json
import os
import sqlite3
import sys
import tempfile
import threading
import unittest
import uuid
from pathlib import Path
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
import nao_quality_runtime as runtime
import nao_quality_runtime_mcp as runtime_mcp
class WaitingResponse:
def __init__(self):
self.closed = threading.Event()
def __enter__(self):
return self
def __exit__(self, *_):
self.close()
def __iter__(self):
self.closed.wait(0.5)
return iter(())
def close(self):
self.closed.set()
class WaitingClient:
def open(self, *_args, **_kwargs):
return WaitingResponse()
class SessionIsolationTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(prefix="test-nao-users-")
self.users = Path(self.temp.name).resolve()
self.manager = runtime.RuntimeManager(users_root=self.users)
self.actor_id = str(uuid.uuid4())
self.actor_b = str(uuid.uuid4())
self.session_a = str(uuid.uuid4())
self.session_b = str(uuid.uuid4())
self.release_a = str(uuid.uuid4())
self.release_b = str(uuid.uuid4())
def tearDown(self):
self.temp.cleanup()
def test_same_actor_sessions_have_independent_roots_locks_credentials_and_mcp_paths(self):
root_a, lock_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, lock_b = self.manager.acquire_actor(self.actor_id, self.session_b)
try:
self.assertEqual(root_a, self.users / self.actor_id / "sessions" / self.session_a)
self.assertEqual(root_b, self.users / self.actor_id / "sessions" / self.session_b)
self.assertNotEqual(root_a, root_b)
self.assertNotEqual(root_a / "active.lock", root_b / "active.lock")
access_a = runtime.write_access_file(root_a, "token-session-A", self.release_a,
expected_actor_id=self.actor_id,
expected_session_id=self.session_a)
access_b = runtime.write_access_file(root_b, "token-session-B", self.release_b,
expected_actor_id=self.actor_id,
expected_session_id=self.session_b)
snapshot_a = runtime.load_access_snapshot(
access_a, runtime_root=self.users, expected_actor_id=self.actor_id,
expected_session_id=self.session_a,
)
snapshot_b = runtime.load_access_snapshot(
access_b, runtime_root=self.users, expected_actor_id=self.actor_id,
expected_session_id=self.session_b,
)
self.assertEqual((snapshot_a.actor_id, snapshot_a.token, snapshot_a.release_id),
(self.actor_id, "token-session-A", self.release_a))
self.assertEqual((snapshot_b.actor_id, snapshot_b.token, snapshot_b.release_id),
(self.actor_id, "token-session-B", self.release_b))
self.assertNotEqual(access_a, access_b)
runtime._write_private_state(root_a)
runtime._write_private_state(root_b)
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=True,
refresh_mcp=True, backup_schema=False,
expected_actor_id=self.actor_id)
runtime._write_project(root_b, self.session_b, "test-model", refresh_templates=True,
refresh_mcp=True, backup_schema=False,
expected_actor_id=self.actor_id)
mcp_a = json.loads((root_a / "project/agent/mcps/mcp.json").read_text())
mcp_b = json.loads((root_b / "project/agent/mcps/mcp.json").read_text())
env_a = mcp_a["mcpServers"]["quality"]["env"]
env_b = mcp_b["mcpServers"]["quality"]["env"]
self.assertEqual(env_a["QUALITY_AGENT_ACTOR_ID"], self.actor_id)
self.assertEqual(env_b["QUALITY_AGENT_ACTOR_ID"], self.actor_id)
self.assertEqual(env_a["QUALITY_AGENT_SESSION_ID"], self.session_a)
self.assertEqual(env_b["QUALITY_AGENT_SESSION_ID"], self.session_b)
self.assertEqual(env_a["QUALITY_AGENT_ACCESS_FILE"], str(access_a))
self.assertEqual(env_b["QUALITY_AGENT_ACCESS_FILE"], str(access_b))
self.assertNotEqual(env_a["QUALITY_AGENT_SESSION_STATE_FILE"],
env_b["QUALITY_AGENT_SESSION_STATE_FILE"])
self.assertNotEqual(runtime._write_private_state(root_a), runtime._write_private_state(root_b))
finally:
self.manager.release_actor(lock_a)
self.manager.release_actor(lock_b)
# flock files are stable coordination objects and are never unlinked.
self.assertTrue((root_a / "active.lock").is_file())
self.assertTrue((root_b / "active.lock").is_file())
def test_same_session_is_mutually_exclusive_but_other_session_and_actor_can_run(self):
_root_a, lock_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, lock_b = self.manager.acquire_actor(self.actor_id, self.session_b)
root_c, lock_c = self.manager.acquire_actor(self.actor_b, self.session_a)
try:
self.assertNotEqual(root_b, root_c)
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "另一轮分析"):
self.manager.acquire_actor(self.actor_id, self.session_a)
finally:
self.manager.release_actor(lock_c)
self.manager.release_actor(lock_b)
self.manager.release_actor(lock_a)
_again, lock_again = self.manager.acquire_actor(self.actor_id, self.session_a)
self.manager.release_actor(lock_again)
def test_access_snapshot_rejects_actor_session_mismatch_and_symlink(self):
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
try:
access = runtime.write_access_file(root_a, "strict-token", self.release_a,
expected_actor_id=self.actor_id,
expected_session_id=self.session_a)
with self.assertRaisesRegex(ValueError, "当前会话"):
runtime.load_access_snapshot(access, runtime_root=self.users,
expected_actor_id=self.actor_b,
expected_session_id=self.session_a)
with self.assertRaisesRegex(ValueError, "路径与当前会话"):
runtime.load_access_snapshot(access, runtime_root=self.users,
expected_actor_id=self.actor_id,
expected_session_id=self.session_b)
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "actor/session"):
runtime.write_access_file(root_a, "wrong-owner", self.release_a,
expected_actor_id=self.actor_b,
expected_session_id=self.session_a)
link = root_a / "linked-access.json"
link.symlink_to(access)
with self.assertRaisesRegex(ValueError, "路径无效"):
runtime.load_access_snapshot(link, runtime_root=self.users,
expected_actor_id=self.actor_id,
expected_session_id=self.session_a)
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "actor/session"):
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=False,
refresh_mcp=False, backup_schema=False,
expected_actor_id=self.actor_b)
finally:
self.manager.release_actor(fd_a)
def test_mcp_shim_accepts_only_fixed_actor_session_paths(self):
fake_root = self.users / "fake-project"
users_root = fake_root / ".runtime" / "nao-users"
session_root = users_root / self.actor_id / "sessions" / self.session_a
session_root.mkdir(parents=True)
environment = {
"QUALITY_AGENT_USERS_ROOT": str(users_root),
"QUALITY_AGENT_ACCESS_FILE": str(session_root / "access.json"),
"QUALITY_AGENT_EVIDENCE_DIR": str(session_root / "evidence"),
"QUALITY_AGENT_SESSION_STATE_FILE": str(session_root / "private" / "current-session.json"),
"QUALITY_AGENT_ACTOR_ID": self.actor_id,
"QUALITY_AGENT_SESSION_ID": self.session_a,
}
with patch.object(runtime_mcp, "ROOT", fake_root), patch.dict(os.environ, environment, clear=False):
access, evidence, state, actor, session, root = runtime_mcp._paths()
self.assertEqual(access, session_root / "access.json")
self.assertEqual(evidence, session_root / "evidence")
self.assertEqual(state, session_root / "private" / "current-session.json")
self.assertEqual((actor, session), (self.actor_id, self.session_a))
self.assertEqual(root, users_root.resolve())
os.environ["QUALITY_AGENT_ACCESS_FILE"] = str(users_root / self.actor_id / "access.json")
with self.assertRaisesRegex(ValueError, "路径无效"):
runtime_mcp._paths()
def test_cancel_stops_only_the_current_session_chat(self):
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
try:
state_a = runtime.SessionState(root_a, self.actor_id, self.session_a)
state_b = runtime.SessionState(root_b, self.actor_id, self.session_b)
state_a.set_chat_id(self.session_a, "native-chat-A")
state_b.set_chat_id(self.session_b, "native-chat-B")
cancel = threading.Event()
cancel.set()
stopped = []
def stop_native(_client, _base, chat_id):
stopped.append(chat_id)
return True
with patch.object(runtime, "_stop_native",
side_effect=lambda _client, _base, chat_id: stopped.append(chat_id) or True):
result = runtime._sse_request(
client=WaitingClient(), base_url="http://127.0.0.1:10000", model="offline-test",
question="q", release_id=self.release_a, context=None,
chat_id=state_a.get_chat_id(self.session_a), session_state=state_a,
session_id=self.session_a, actor_root=root_a, emit=lambda _event: None,
cancel_event=cancel, timeout=5,
)
self.assertEqual(result[1], "CANCELLED")
self.assertEqual(stopped, ["native-chat-A"])
self.assertEqual(state_b.get_chat_id(self.session_b), "native-chat-B")
self.assertFalse((root_b / "instance.json").exists())
finally:
self.manager.release_actor(fd_b)
self.manager.release_actor(fd_a)
def test_stop_instance_only_targets_processes_recorded_in_that_session(self):
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
try:
for root, session_id, pids, port in (
(root_a, self.session_a, [10101, 10102], 41001),
(root_b, self.session_b, [20201, 20202], 42001),
):
runtime._atomic_json(root / "instance.json", {
"actorId": self.actor_id, "sessionId": session_id,
"processes": [{"pid": pid, "pgid": pid, "lstart": "simulated",
"kind": "server", "port": port + index}
for index, pid in enumerate(pids)],
})
killed = []
def matches(record, runtime_root):
return runtime_root == root_a and record.get("pid") in (10101, 10102)
with patch.object(runtime, "_process_matches", side_effect=matches), \
patch.object(runtime, "_ps_value", return_value="simulated process"), \
patch.object(runtime.os, "killpg", side_effect=lambda pgid, _sig: killed.append(pgid)), \
patch.object(runtime.time, "sleep"):
runtime._stop_instance(root_a, grace_seconds=0)
self.assertEqual(set(killed), {10101, 10102})
self.assertTrue((root_b / "instance.json").is_file())
finally:
self.manager.release_actor(fd_b)
self.manager.release_actor(fd_a)
def test_stop_all_skips_active_session_and_scans_legacy_and_idle_sessions(self):
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
legacy = self.users / self.actor_b
legacy.mkdir(parents=True)
runtime._atomic_json(legacy / "instance.json", {"actorId": self.actor_b, "processes": []})
for root in (root_a, root_b, legacy):
runtime._atomic_json(root / "access.json", {"token": "private"})
self.manager.release_actor(fd_b)
try:
stopped = []
manager = self.manager
with patch.object(runtime, "_stop_instance", side_effect=lambda root: stopped.append(root) or True):
count = manager.stop_idle_all()
self.assertEqual(count, 2)
self.assertEqual(set(stopped), {root_b, legacy})
self.assertTrue((root_a / "access.json").exists())
self.assertFalse((root_b / "access.json").exists())
self.assertFalse((legacy / "access.json").exists())
self.assertIn(legacy, runtime._runtime_roots(self.users))
self.assertIn(root_a, runtime._runtime_roots(self.users))
finally:
self.manager.release_actor(fd_a)
def test_project_template_symlink_cannot_write_into_another_session(self):
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
try:
project_a = root_a / "project"
project_a.mkdir()
project_b = root_b / "project"
project_b.mkdir()
protected_config = project_b / "nao_config.yaml"
protected_config.write_text("session B config", encoding="utf-8")
(project_a / "nao_config.yaml").symlink_to(protected_config)
with self.assertRaisesRegex(ValueError, "运行路径无效"):
runtime._write_project(root_a, self.session_a, "test-model", refresh_templates=True,
refresh_mcp=True, backup_schema=False,
expected_actor_id=self.actor_id)
self.assertEqual(protected_config.read_text(encoding="utf-8"), "session B config")
finally:
self.manager.release_actor(fd_b)
self.manager.release_actor(fd_a)
def test_server_log_open_rejects_symlink_and_non_regular_files(self):
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
try:
logs_a = root_a / "logs"
logs_b = root_b / "logs"
logs_a.mkdir()
logs_b.mkdir()
protected_log = logs_b / "server.log"
protected_log.write_text("session B log", encoding="utf-8")
(logs_a / "server.log").symlink_to(protected_log)
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "日志文件路径无效"):
runtime._open_server_log(logs_a / "server.log", root_a)
self.assertEqual(protected_log.read_text(encoding="utf-8"), "session B log")
(logs_a / "server.log").unlink()
fifo = logs_a / "server.log"
os.mkfifo(fifo)
with self.assertRaisesRegex(runtime.RuntimeErrorSafe, "日志文件路径无效"):
runtime._open_server_log(fifo, root_a)
finally:
self.manager.release_actor(fd_b)
self.manager.release_actor(fd_a)
def test_legacy_session_history_is_copied_to_private_root_without_changing_source(self):
actor_root = self.users / self.actor_id
legacy_private = actor_root / "private"
legacy_private.mkdir(parents=True)
mapping = legacy_private / "sessions.json"
runtime._atomic_json(mapping, {
"actorId": self.actor_id,
"sessions": {self.session_a: "old-native-chat-A", self.session_b: "old-native-chat-B"},
})
mapping_before = mapping.read_bytes()
runtime._atomic_json(legacy_private / "credentials.json", {
"authSecret": "legacy-auth", "email": "legacy@example.invalid", "password": "legacy-password",
})
legacy_project = actor_root / "project"
legacy_project.mkdir(parents=True)
source_db = legacy_private / "nao.sqlite"
with contextlib.closing(sqlite3.connect(source_db)) as database:
with database:
# Mirrors NAO's actual SQLite project.path and chat.project_id
# relationship used by agent routes and MCP project lookup.
database.executescript("""
CREATE TABLE project (
id TEXT PRIMARY KEY NOT NULL,
org_id TEXT,
name TEXT NOT NULL,
type TEXT NOT NULL,
path TEXT,
agent_settings TEXT,
enabled_tools TEXT NOT NULL DEFAULT '[]',
known_mcp_servers TEXT NOT NULL DEFAULT '[]',
disabled_mcp_servers TEXT NOT NULL DEFAULT '[]',
disabled_mcp_tools TEXT NOT NULL DEFAULT '[]',
env_vars TEXT NOT NULL DEFAULT '{}',
CONSTRAINT local_project_path_required
CHECK(CASE WHEN type = 'local' THEN path IS NOT NULL ELSE TRUE END)
);
CREATE TABLE chat (
id TEXT PRIMARY KEY NOT NULL,
user_id TEXT NOT NULL,
project_id TEXT NOT NULL REFERENCES project(id),
title TEXT DEFAULT 'New Conversation' NOT NULL,
is_starred INTEGER DEFAULT false NOT NULL,
deleted_at INTEGER,
slack_thread_id TEXT,
teams_thread_id TEXT,
telegram_thread_id TEXT,
mattermost_thread_id TEXT,
discord_thread_id TEXT,
whatsapp_thread_id TEXT,
fork_metadata TEXT,
created_at INTEGER NOT NULL,
updated_at INTEGER NOT NULL
);
""")
database.execute(
"INSERT INTO project(id,name,type,path) VALUES (?,?,?,?)",
("legacy-project-id", "Quality", "local", str(legacy_project)),
)
database.executemany(
"INSERT INTO chat(id,user_id,project_id,created_at,updated_at) VALUES (?,?,?,?,?)",
(("old-native-chat-A", "legacy-user", "legacy-project-id", 1, 1),
("old-native-chat-B", "legacy-user", "legacy-project-id", 2, 2)),
)
source_db.chmod(0o600)
root_a, fd_a = self.manager.acquire_actor(self.actor_id, self.session_a)
root_b, fd_b = self.manager.acquire_actor(self.actor_id, self.session_b)
try:
self.assertTrue(self.manager._migrate_legacy_session(self.actor_id, self.session_a, root_a))
self.assertTrue(self.manager._migrate_legacy_session(self.actor_id, self.session_b, root_b))
state = runtime.SessionState(root_a, self.actor_id, self.session_a)
other_state = runtime.SessionState(root_b, self.actor_id, self.session_b)
self.assertEqual(state.get_chat_id(self.session_a), "old-native-chat-A")
self.assertEqual(other_state.get_chat_id(self.session_b), "old-native-chat-B")
self.assertNotEqual(root_a / "private" / "nao.sqlite", source_db)
with contextlib.closing(sqlite3.connect(root_a / "private" / "nao.sqlite")) as database:
self.assertEqual(database.execute(
"SELECT id,path FROM project WHERE id='legacy-project-id'"
).fetchone(), ("legacy-project-id", str(root_a / "project")))
self.assertEqual(database.execute(
"SELECT id,project_id FROM chat WHERE id='old-native-chat-A'"
).fetchone(), ("old-native-chat-A", "legacy-project-id"))
self.assertEqual(database.execute(
"SELECT id,project_id FROM chat WHERE id='old-native-chat-B'"
).fetchone(), ("old-native-chat-B", "legacy-project-id"))
with contextlib.closing(sqlite3.connect(root_b / "private" / "nao.sqlite")) as database:
with database:
database.execute(
"INSERT INTO chat(id,user_id,project_id,created_at,updated_at) VALUES (?,?,?,?,?)",
("session-B-only", "legacy-user", "legacy-project-id", 3, 3),
)
self.assertEqual(database.execute(
"SELECT id,path FROM project WHERE id='legacy-project-id'"
).fetchone(), ("legacy-project-id", str(root_b / "project")))
with contextlib.closing(sqlite3.connect(root_a / "private" / "nao.sqlite")) as database:
rows = database.execute("SELECT id FROM chat ORDER BY id").fetchall()
self.assertEqual(rows, [("old-native-chat-A",), ("old-native-chat-B",)])
with contextlib.closing(sqlite3.connect(source_db)) as database:
self.assertEqual(database.execute(
"SELECT id,path FROM project WHERE id='legacy-project-id'"
).fetchone(), ("legacy-project-id", str(legacy_project)))
self.assertEqual(database.execute(
"SELECT id,project_id FROM chat WHERE id='old-native-chat-A'"
).fetchone(), ("old-native-chat-A", "legacy-project-id"))
self.assertEqual(mapping.read_bytes(), mapping_before)
self.assertTrue(source_db.is_file())
self.assertEqual(runtime._read_json(root_a / "private" / "credentials.json")["authSecret"],
"legacy-auth")
finally:
self.manager.release_actor(fd_b)
self.manager.release_actor(fd_a)
if __name__ == "__main__":
unittest.main()