收口 MNote P0 P1 P2 审查尾项

- 归档 OnlyOffice live bridge、Page AI、mindmap、design governance 与相关 bug 条目 - 补齐 MinerU OCR 后端 runtime 合同与 smoke/test 基线 - 收口 ChatOnly/Doubao、ObjectIdentity、Page Aggregate compat 与 runtime owner 文档口径验证： - cargo test --manifest-path rust/Cargo.toml -p mnote-web local_ocr -- --test-threads=1 - cargo test --manifest-path rust/Cargo.toml -p mnote-web onlyoffice_bridge -- --test-threads=1 - git diff --check - git diff --cached --check - codegraph index . --force && codegraph status . - codegraph sync . && codegraph status .
2026-06-01 09:29:12 +08:00
parent 49a0545148
commit 1882db7681
143 changed files with 29810 additions and 3228 deletions
@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { chromium } = require("playwright");
+const { UI_TIMEOUT_MS, assert } = require("./tree-shell-smoke-helpers");
+
+const BASE_URL = (process.env.MNOTE_UI_BASE_URL || "http://127.0.0.1:3000").replace(/\/+$/, "");
+const TASK = "task503-mindmap-skill-capability-smoke";
+const OUTPUT_DIR = path.join(process.cwd(), "tmp", TASK);
+const RESULT_PATH = path.join(OUTPUT_DIR, "result.json");
+const TEST_EMAIL = "mnote.e2e@example.com";
+const TEST_PASSWORD = "MnoteE2E123!";
+
+async function writeResult(payload) {
+  await fs.mkdir(OUTPUT_DIR, { recursive: true });
+  await fs.writeFile(RESULT_PATH, `${JSON.stringify({ ...payload, resultPath: RESULT_PATH }, null, 2)}\n`, "utf8");
+}
+
+async function callJson(url, init = {}) {
+  const response = await fetch(url, {
+    ...init,
+    headers: {
+      ...(init.data !== undefined ? { "content-type": "application/json" } : {}),
+      ...(init.headers || {}),
+    },
+    body: init.data !== undefined ? JSON.stringify(init.data) : init.body,
+  });
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = text;
+  }
+  if (!response.ok || payload?.ok === false) {
+    throw new Error(`${url} failed: ${response.status} ${typeof payload === "string" ? payload : JSON.stringify(payload)}`);
+  }
+  return payload;
+}
+
+async function callMnoteTool({ toolName, workspaceId, documentId, rootUri, args, idempotencyKey }) {
+  const payload = {
+    toolName,
+    workspaceId,
+    documentId,
+    sourceKind: "local_folder",
+    rootUri,
+    actorId: "mnote-e2e",
+    sessionId: `sess_${TASK}_${toolName.replace(/\W+/g, "_")}`,
+    runId: `run_${Date.now()}`,
+    toolCallId: `call_${Date.now()}`,
+    traceId: `trace_${Date.now()}`,
+    idempotencyKey,
+    dryRun: false,
+    args,
+  };
+  const result = await callJson(`${BASE_URL}/api/hermes/tools/mnote/call`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-mnote-actor-id": "mnote-e2e",
+      "x-mnote-actor-type": "user",
+    },
+    body: JSON.stringify(payload),
+  });
+  return result.result ?? result;
+}
+
+async function signInBrowserContext(context) {
+  const auth = await context.request.post(`${BASE_URL}/api/auth`, {
+    data: {
+      action: "auth:signIn",
+      args: {
+        provider: "password",
+        params: {
+          email: TEST_EMAIL,
+          password: TEST_PASSWORD,
+          flow: "signIn",
+        },
+      },
+    },
+  });
+  assert(auth.ok(), `测试账号登录失败: ${auth.status()} ${await auth.text()}`);
+  const whoami = await context.request.get(`${BASE_URL}/api/auth/whoami`);
+  assert(whoami.ok(), `whoami 失败: ${whoami.status()} ${await whoami.text()}`);
+  const viewer = await whoami.json();
+  assert(viewer.userId === "mnote-e2e", `当前登录用户不是 mnote-e2e: ${JSON.stringify(viewer)}`);
+  assert(viewer.actorType === "user", `当前登录不是真实 user 会话: ${JSON.stringify(viewer)}`);
+  return viewer;
+}
+
+function skillCapabilityOutline() {
+  return [
+    {
+      text: "触发场景",
+      children: [
+        { text: "用户提到脑图", children: [] },
+        { text: "资源标签页", children: [] },
+        { text: "PDF 转导图", children: [] },
+      ],
+    },
+    {
+      text: "读取能力",
+      children: [
+        { text: "先解析目标", children: [] },
+        { text: "fetch 回读树", children: [] },
+        { text: "完整 envelope", children: [] },
+      ],
+    },
+    {
+      text: "创建能力",
+      children: [
+        { text: "outline 写入", children: [] },
+        { text: "自动生成 uid", children: [] },
+        { text: "保留 sourceRefs", children: [] },
+      ],
+    },
+    {
+      text: "权限约束",
+      children: [
+        { text: "需要 read_write", children: [] },
+        { text: "限定资源路径", children: [] },
+        { text: "拒绝越权写入", children: [] },
+      ],
+    },
+    {
+      text: "写后验证",
+      children: [
+        { text: "fetch 再确认", children: [] },
+        { text: "报告 JSON 路径", children: [] },
+        { text: "截图看渲染", children: [] },
+      ],
+    },
+    {
+      text: "当前边界",
+      children: [
+        { text: "非裸树文件", children: [] },
+        { text: "apply_ops 受限", children: [] },
+        { text: "长文本需压缩", children: [] },
+      ],
+    },
+  ];
+}
+
+function collectOutlineTexts(nodes, texts = []) {
+  for (const node of nodes) {
+    texts.push(String(node.text || ""));
+    collectOutlineTexts(Array.isArray(node.children) ? node.children : [], texts);
+  }
+  return texts;
+}
+
+async function main() {
+  await fs.mkdir(OUTPUT_DIR, { recursive: true });
+  const workspace = await callJson(`${BASE_URL}/api/local-folder/workspaces/default`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-mnote-actor-id": "mnote-e2e",
+      "x-mnote-actor-type": "user",
+    },
+    data: {},
+  });
+  const rootUri = workspace.workspace?.rootUri || "";
+  const rootPath = workspace.workspace?.rootPath || "";
+  const workspaceId = workspace.workspace?.manifest?.workspaceId || "local-ws:mnote-e2e:my-space";
+  assert(rootUri.startsWith("file://"), `默认本地工作区 rootUri 异常: ${JSON.stringify(workspace)}`);
+  assert(rootPath, `默认本地工作区 rootPath 缺失: ${JSON.stringify(workspace)}`);
+
+  const documentName = `MindmapSkillCapabilitySmoke-${Date.now()}.md`;
+  const documentId = `local-md:${documentName}`;
+  const resourcePath = `maps/task503-mindmap-skill-capabilities-${Date.now()}.mindmap.json`;
+  const title = "mnote-mindmap skill 能力";
+  await fs.mkdir(path.join(rootPath, "maps"), { recursive: true });
+  await fs.writeFile(path.join(rootPath, documentName), "# Mindmap Skill Capability Smoke\n", "utf8");
+
+  const skill = await callMnoteTool({
+    toolName: "mnote.skill.read",
+    workspaceId,
+    documentId,
+    rootUri,
+    args: { skillId: "mnote-mindmap", agentId: "reasonix" },
+  });
+  const skillContent = String(skill.content || "");
+  assert(skillContent.includes("Mindmap outline format"), "skill 缺少导图格式小节");
+  assert(skillContent.includes("Use concise keywords or short phrases"), "skill 缺少短语化节点要求");
+  assert(skillContent.includes("Avoid long paragraphs"), "skill 缺少避免长段落要求");
+
+  const outline = skillCapabilityOutline();
+  const outlineTexts = collectOutlineTexts(outline);
+  assert(outlineTexts.every((text) => text.length > 0 && text.length <= 32), "outline 节点应保持短语化");
+  assert(outlineTexts.every((text) => !text.includes("\n")), "outline 节点不能用换行模拟层级");
+
+  const aiAccessScope = {
+    permissionLevel: "read_write",
+    allowedResourceIds: [resourcePath],
+  };
+  const created = await callMnoteTool({
+    toolName: "mnote.mindmap.create_from_outline",
+    workspaceId,
+    documentId,
+    rootUri,
+    idempotencyKey: `idem_${TASK}_${Date.now()}`,
+    args: {
+      mindmapId: resourcePath,
+      resourcePath,
+      title,
+      outline,
+      embedIntoPage: true,
+      sourceRefs: [{ kind: "skill", title: "mnote-mindmap", note: TASK }],
+      aiAccessScope,
+    },
+  });
+  assert(created.root?.data?.text === title, `创建结果根节点异常: ${JSON.stringify(created.root)}`);
+  assert(created.embedResult?.status === "embedded", `创建结果缺少页面绑定: ${JSON.stringify(created.embedResult)}`);
+  assert(
+    Array.isArray(created.changedFiles) && created.changedFiles.includes(documentName),
+    `changedFiles 应包含当前 Markdown 页面: ${JSON.stringify(created.changedFiles)}`,
+  );
+  const markdownAfterEmbed = await fs.readFile(path.join(rootPath, documentName), "utf8");
+  assert(
+    markdownAfterEmbed.includes(`[${title}](${resourcePath})`),
+    `当前 Markdown 页面未写入 mindmap 链接: ${markdownAfterEmbed}`,
+  );
+
+  const fetched = await callMnoteTool({
+    toolName: "mnote.mindmap.fetch",
+    workspaceId,
+    documentId,
+    rootUri,
+    args: {
+      mindmapId: resourcePath,
+      resourcePath,
+      scope: "full_envelope",
+      aiAccessScope,
+    },
+  });
+  const nodeCount = Array.isArray(fetched.nodes) ? fetched.nodes.length : 0;
+  assert(fetched.root?.data?.text === title, `回读根节点异常: ${JSON.stringify(fetched.root)}`);
+  assert(nodeCount >= 25, `回读节点数不足: ${nodeCount}`);
+
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({ viewport: { width: 1440, height: 960 } });
+  const page = await context.newPage();
+  const events = [];
+  page.on("pageerror", (error) => events.push({ kind: "pageerror", text: error.message }));
+  page.on("console", (message) => {
+    if (message.type() === "error") {
+      events.push({ kind: "console", text: message.text() });
+    }
+  });
+  page.on("response", (response) => {
+    if (response.url().includes("/api/mindmap/")) {
+      events.push({ kind: "mindmap-response", status: response.status(), url: response.url() });
+    }
+  });
+  const viewer = await signInBrowserContext(context);
+  const url = `${BASE_URL}/mindmap/${encodeURIComponent(documentId)}/${encodeURIComponent(`local-file:${resourcePath}`)}?sourceKind=local_folder&rootUri=${encodeURIComponent(rootUri)}&workspaceId=${encodeURIComponent(workspaceId)}`;
+  await page.goto(url, { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
+  await page.locator('[data-testid="mnote-mindmap-editor-root"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
+  await page.waitForFunction(
+    (expectedTitle) => {
+      const text = document.body.innerText || "";
+      const countText = document.querySelector('[data-testid="mindmap-schema-count"]')?.textContent || "";
+      return text.includes(expectedTitle) && text.includes("触发场景") && /节点\s*(?:[1-9]|[1-9][0-9]+)/.test(countText);
+    },
+    title,
+    { timeout: UI_TIMEOUT_MS },
+  );
+  const screenshotPath = path.join(OUTPUT_DIR, "skill-capability-mindmap.png");
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+  const ui = await page.evaluate(() => ({
+    bodyHasTitle: (document.body.innerText || "").includes("mnote-mindmap skill 能力"),
+    bodyHasBranch: (document.body.innerText || "").includes("触发场景"),
+    bodyHasPermission: (document.body.innerText || "").includes("权限约束"),
+    schemaCount: document.querySelector('[data-testid="mindmap-schema-count"]')?.textContent || null,
+    rootVisible: Boolean(document.querySelector('[data-testid="mnote-mindmap-editor-root"]')),
+    errorText: document.querySelector('[data-testid="leptos-mindmap-error"]')?.textContent || null,
+  }));
+  await browser.close();
+  assert(ui.bodyHasTitle && ui.bodyHasBranch && ui.bodyHasPermission, `导图页面文本缺失: ${JSON.stringify(ui)}`);
+  assert(!ui.errorText, `导图页面出现错误: ${ui.errorText}`);
+
+  await writeResult({
+    ok: true,
+    rootUri,
+    workspaceId,
+    documentId,
+    resourcePath,
+    mindmapFile: path.join(rootPath, resourcePath),
+    screenshotPath,
+    url,
+    viewer,
+    skillFormatRules: {
+      hasFormat: skillContent.includes("Mindmap outline format"),
+      hasShortPhraseRule: skillContent.includes("Use concise keywords or short phrases"),
+      hasAvoidParagraphRule: skillContent.includes("Avoid long paragraphs"),
+    },
+    nodeCount,
+    embedResult: created.embedResult,
+    markdownHasMindmapLink: markdownAfterEmbed.includes(`[${title}](${resourcePath})`),
+    firstLevel: (fetched.root?.children || []).map((child) => child?.data?.text),
+    ui,
+    events,
+  });
+  console.log(`task503 mindmap skill capability smoke passed: ${RESULT_PATH}`);
+}
+
+main().catch(async (error) => {
+  await writeResult({
+    ok: false,
+    error: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack : null,
+  }).catch(() => undefined);
+  console.error(error instanceof Error ? error.stack : error);
+  process.exit(1);
+});