Agent Board
262e66b02e
Retire ACP/Hermes/OpenCode surfaces and rename hermes_tools to mnote_agent_tools so Page AI stays on Pi Lab only. Add Chrome vault extension + extension token route, pre-release purge design, and soft-retire legacy smokes for the small-group production cut.
316 lines
12 KiB
JavaScript
316 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
|
"use strict";
|
|
|
|
const assert = require("node:assert");
|
|
const fs = require("node:fs/promises");
|
|
const path = require("node:path");
|
|
const { chromium } = require("playwright");
|
|
const {
|
|
BASE_URL,
|
|
cleanupDocuments,
|
|
createTempDocument,
|
|
ensureAuthenticated,
|
|
openDocument,
|
|
renameDocument,
|
|
requestJson,
|
|
} = require("./tree-shell-smoke-helpers");
|
|
|
|
const OUT_DIR = path.join(process.cwd(), "tmp", "page-block-ai-context-format-smoke");
|
|
|
|
async function callMnoteTool(request, payload) {
|
|
return requestJson(request, "/api/mnote/tools/call", {
|
|
method: "POST",
|
|
headers: { "x-mnote-actor-id": payload.actorId || "smoke-user" },
|
|
data: payload,
|
|
});
|
|
}
|
|
|
|
function toolByName(manifest, name) {
|
|
const tools = manifest?.manifest?.tools || manifest?.tools || [];
|
|
const tool = tools.find((candidate) => candidate.name === name);
|
|
assert(tool, `manifest 缺少工具：${name}`);
|
|
return tool;
|
|
}
|
|
|
|
function assertAnnotationShape(tool, expected) {
|
|
assert(tool.annotations, `${tool.name} 缺少 annotations`);
|
|
for (const key of [
|
|
"readonly",
|
|
"destructive",
|
|
"idempotent",
|
|
"requiresApproval",
|
|
"approvalMode",
|
|
"runtimeOwner",
|
|
"writeOwner",
|
|
"selectionEffect",
|
|
]) {
|
|
assert(Object.hasOwn(tool.annotations, key), `${tool.name} annotations 缺少 ${key}`);
|
|
}
|
|
for (const [key, value] of Object.entries(expected)) {
|
|
assert.deepEqual(tool.annotations[key], value, `${tool.name} annotations.${key} 不符合预期`);
|
|
}
|
|
}
|
|
|
|
function assertIncludes(value, fragment, message) {
|
|
assert(String(value || "").includes(fragment), message);
|
|
}
|
|
|
|
function assertExcludes(value, fragment, message) {
|
|
assert(!String(value || "").includes(fragment), message);
|
|
}
|
|
|
|
async function main() {
|
|
const suffix = Date.now().toString(36);
|
|
const title = `TEST-AI-CONTEXT-FORMAT-${suffix}`;
|
|
const createdIds = [];
|
|
const evidence = {
|
|
ok: false,
|
|
baseUrl: BASE_URL,
|
|
title,
|
|
steps: [],
|
|
};
|
|
await fs.mkdir(OUT_DIR, { recursive: true });
|
|
|
|
const browser = await chromium.launch({ headless: true });
|
|
const context = await browser.newContext({ viewport: { width: 1280, height: 900 } });
|
|
const page = await context.newPage();
|
|
|
|
try {
|
|
const viewer = await ensureAuthenticated(page, context.request);
|
|
const actorId = viewer.userId || "smoke-user";
|
|
const target = await createTempDocument(context.request);
|
|
createdIds.push(target.documentId);
|
|
evidence.documentId = target.documentId;
|
|
evidence.workspaceId = target.workspaceId;
|
|
await renameDocument(context.request, target.workspaceId, target.documentId, title);
|
|
|
|
const manifest = await requestJson(context.request, "/api/mnote/tools/manifest", {
|
|
method: "GET",
|
|
headers: { "x-mnote-actor-id": actorId },
|
|
});
|
|
const docFetchTool = toolByName(manifest, "mnote.doc.fetch");
|
|
const blockFetchTool = toolByName(manifest, "mnote.block.fetch");
|
|
const blockReplaceTool = toolByName(manifest, "mnote.block.replace");
|
|
const pageSaveTool = toolByName(manifest, "mnote.page.save");
|
|
assertAnnotationShape(docFetchTool, {
|
|
readonly: true,
|
|
destructive: false,
|
|
runtimeOwner: "mnote-web",
|
|
writeOwner: "rust-runtime-kernel",
|
|
selectionEffect: "preserve",
|
|
});
|
|
assertAnnotationShape(blockFetchTool, {
|
|
readonly: true,
|
|
destructive: false,
|
|
selectionEffect: "preserve",
|
|
});
|
|
assertAnnotationShape(blockReplaceTool, {
|
|
readonly: false,
|
|
destructive: false,
|
|
selectionEffect: "may_change",
|
|
});
|
|
assertAnnotationShape(pageSaveTool, {
|
|
readonly: false,
|
|
destructive: true,
|
|
approvalMode: "yolo",
|
|
selectionEffect: "may_change",
|
|
});
|
|
evidence.steps.push({
|
|
name: "manifest.annotations",
|
|
checkedTools: [docFetchTool.name, blockFetchTool.name, blockReplaceTool.name, pageSaveTool.name],
|
|
pageSaveDestructive: pageSaveTool.annotations.destructive,
|
|
});
|
|
|
|
const seed = await callMnoteTool(context.request, {
|
|
toolName: "mnote.page.save",
|
|
workspaceId: target.workspaceId,
|
|
documentId: target.documentId,
|
|
actorId,
|
|
sessionId: `sess_context_seed_${suffix}`,
|
|
runId: `run_context_seed_${suffix}`,
|
|
toolCallId: `call_context_seed_${suffix}`,
|
|
traceId: `trace_context_seed_${suffix}`,
|
|
idempotencyKey: `idem_context_seed_${suffix}`,
|
|
dryRun: false,
|
|
capabilityScope: ["page.write"],
|
|
args: {
|
|
mode: "replace",
|
|
content: [
|
|
{ id: "p_1", type: "paragraph", content: [{ type: "text", text: `第一段 ${suffix}` }] },
|
|
{ id: "p_2", type: "paragraph", content: [{ type: "text", text: `第二段 ${suffix}` }] },
|
|
{ id: "p_3", type: "paragraph", content: [{ type: "text", text: `第三段 ${suffix}` }] },
|
|
],
|
|
},
|
|
});
|
|
assert.equal(seed.ok, true, "初始化 page.save 应成功");
|
|
evidence.steps.push({ name: "seed", commandName: seed.result.commandName });
|
|
|
|
const selectionXml = await callMnoteTool(context.request, {
|
|
toolName: "mnote.doc.fetch",
|
|
workspaceId: target.workspaceId,
|
|
documentId: target.documentId,
|
|
actorId,
|
|
sessionId: `sess_context_fetch_${suffix}`,
|
|
runId: `run_context_fetch_xml_${suffix}`,
|
|
toolCallId: `call_context_fetch_xml_${suffix}`,
|
|
traceId: `trace_context_fetch_xml_${suffix}`,
|
|
capabilityScope: ["page.read"],
|
|
args: {
|
|
scope: "selection",
|
|
selectedBlockIds: ["p_2"],
|
|
format: "page_xml",
|
|
detail: "with_ids",
|
|
maxBlocks: 10,
|
|
},
|
|
});
|
|
assert.equal(selectionXml.result.schema, "mnote.page_ai_context.v1", "doc.fetch 应返回 page AI context schema");
|
|
assert.equal(selectionXml.result.scope, "selection", "doc.fetch 应保留 selection scope");
|
|
assert.equal(selectionXml.result.format, "page_xml", "doc.fetch 应返回 page_xml format");
|
|
assert.deepEqual(selectionXml.result.allowedTargetBlockIds, ["p_2"], "selection 应冻结 allowedTargetBlockIds");
|
|
assert.equal(selectionXml.result.blocks.length, 1, "selection 只应返回选中块");
|
|
assert.equal(selectionXml.result.blocks[0].blockId, "p_2", "selection 应返回 p_2");
|
|
assert(selectionXml.result.blocks[0].revisionRef, "selection block 必须带 revisionRef");
|
|
assertIncludes(selectionXml.result.content, '<block id="p_2"', "page_xml 应包含 p_2 block id");
|
|
assertIncludes(selectionXml.result.content, 'revisionRef="', "page_xml 应包含 revisionRef");
|
|
assertIncludes(selectionXml.result.content, `第二段 ${suffix}`, "page_xml 应包含选中文本");
|
|
assertExcludes(selectionXml.result.content, `第一段 ${suffix}`, "page_xml 不应包含未选中 p_1");
|
|
assertExcludes(selectionXml.result.content, `第三段 ${suffix}`, "page_xml 不应包含未选中 p_3");
|
|
evidence.steps.push({
|
|
name: "doc.fetch.selection.page_xml",
|
|
schema: selectionXml.result.schema,
|
|
allowedTargetBlockIds: selectionXml.result.allowedTargetBlockIds,
|
|
revision: selectionXml.result.revision,
|
|
conflictDetectionKey: selectionXml.result.conflictDetectionKey,
|
|
blockRevisionRef: selectionXml.result.blocks[0].revisionRef,
|
|
});
|
|
|
|
const selectionText = await callMnoteTool(context.request, {
|
|
toolName: "mnote.doc.fetch",
|
|
workspaceId: target.workspaceId,
|
|
documentId: target.documentId,
|
|
actorId,
|
|
sessionId: `sess_context_fetch_${suffix}`,
|
|
runId: `run_context_fetch_text_${suffix}`,
|
|
toolCallId: `call_context_fetch_text_${suffix}`,
|
|
traceId: `trace_context_fetch_text_${suffix}`,
|
|
capabilityScope: ["page.read"],
|
|
args: {
|
|
scope: "selection",
|
|
selectedBlockIds: ["p_2"],
|
|
format: "text",
|
|
detail: "with_ids",
|
|
},
|
|
});
|
|
assertIncludes(selectionText.result.content, `[p_2] 第二段 ${suffix}`, "text format 应包含选中块 id 与文本");
|
|
assertExcludes(selectionText.result.content, `第一段 ${suffix}`, "text format 不应包含未选中 p_1");
|
|
assertExcludes(selectionText.result.content, `第三段 ${suffix}`, "text format 不应包含未选中 p_3");
|
|
evidence.steps.push({ name: "doc.fetch.selection.text", content: selectionText.result.content });
|
|
|
|
const blockXml = await callMnoteTool(context.request, {
|
|
toolName: "mnote.block.fetch",
|
|
workspaceId: target.workspaceId,
|
|
documentId: target.documentId,
|
|
actorId,
|
|
sessionId: `sess_context_block_${suffix}`,
|
|
runId: `run_context_block_xml_${suffix}`,
|
|
toolCallId: `call_context_block_xml_${suffix}`,
|
|
traceId: `trace_context_block_xml_${suffix}`,
|
|
capabilityScope: ["block.read"],
|
|
args: {
|
|
blockId: "p_2",
|
|
contextBefore: 1,
|
|
contextAfter: 1,
|
|
format: "page_xml",
|
|
},
|
|
});
|
|
assert.equal(blockXml.result.block.blockId, "p_2", "block.fetch page_xml 应读取 p_2");
|
|
assert.equal(blockXml.result.context.before[0].blockId, "p_1", "block.fetch before 应来自同父级");
|
|
assert.equal(blockXml.result.context.after[0].blockId, "p_3", "block.fetch after 应来自同父级");
|
|
assertIncludes(blockXml.result.content, '<block id="p_2"', "block.fetch page_xml 应包含目标 block id");
|
|
assertIncludes(blockXml.result.content, 'revisionRef="', "block.fetch page_xml 应包含 revisionRef");
|
|
|
|
const blockText = await callMnoteTool(context.request, {
|
|
toolName: "mnote.block.fetch",
|
|
workspaceId: target.workspaceId,
|
|
documentId: target.documentId,
|
|
actorId,
|
|
sessionId: `sess_context_block_${suffix}`,
|
|
runId: `run_context_block_text_${suffix}`,
|
|
toolCallId: `call_context_block_text_${suffix}`,
|
|
traceId: `trace_context_block_text_${suffix}`,
|
|
capabilityScope: ["block.read"],
|
|
args: {
|
|
blockId: "p_2",
|
|
format: "text",
|
|
},
|
|
});
|
|
assertIncludes(blockText.result.content, `[p_2] 第二段 ${suffix}`, "block.fetch text 应包含块 id 与文本");
|
|
evidence.steps.push({
|
|
name: "block.fetch.page_xml.text",
|
|
blockId: blockXml.result.block.blockId,
|
|
revisionRef: blockXml.result.block.revisionRef,
|
|
contextBefore: blockXml.result.context.before.map((block) => block.blockId),
|
|
contextAfter: blockXml.result.context.after.map((block) => block.blockId),
|
|
});
|
|
|
|
const outOfScopeResponse = await context.request.fetch(`${BASE_URL}/api/mnote/tools/call`, {
|
|
method: "POST",
|
|
headers: {
|
|
"content-type": "application/json",
|
|
"x-mnote-actor-id": actorId,
|
|
},
|
|
data: JSON.stringify({
|
|
toolName: "mnote.doc.apply_block_ops",
|
|
workspaceId: target.workspaceId,
|
|
documentId: target.documentId,
|
|
actorId,
|
|
sessionId: `sess_context_scope_${suffix}`,
|
|
runId: `run_context_scope_${suffix}`,
|
|
toolCallId: `call_context_scope_${suffix}`,
|
|
traceId: `trace_context_scope_${suffix}`,
|
|
idempotencyKey: `idem_context_scope_${suffix}`,
|
|
dryRun: true,
|
|
capabilityScope: ["block.write"],
|
|
args: {
|
|
allowedTargetBlockIds: ["p_2"],
|
|
operations: [
|
|
{
|
|
op: "replace",
|
|
blockId: "p_1",
|
|
content: `越界修改 ${suffix}`,
|
|
},
|
|
],
|
|
},
|
|
}),
|
|
});
|
|
const outOfScopeText = await outOfScopeResponse.text();
|
|
assert.equal(outOfScopeResponse.status(), 400, "选区外写入应被 Rust tool 拒绝");
|
|
assertIncludes(outOfScopeText, "mnote_block_target_out_of_scope", "选区外写入应返回明确错误码");
|
|
evidence.steps.push({
|
|
name: "write.out_of_scope.blocked",
|
|
status: outOfScopeResponse.status(),
|
|
errorCode: "mnote_block_target_out_of_scope",
|
|
});
|
|
|
|
await openDocument(page, target.workspaceId, target.documentId);
|
|
await page.getByText(`第二段 ${suffix}`).waitFor({ state: "visible", timeout: 30_000 });
|
|
const screenshotPath = path.join(OUT_DIR, `${suffix}-page.png`);
|
|
await page.screenshot({ path: screenshotPath, fullPage: true });
|
|
evidence.screenshot = screenshotPath;
|
|
evidence.ok = true;
|
|
|
|
const evidencePath = path.join(OUT_DIR, `${suffix}.json`);
|
|
await fs.writeFile(evidencePath, JSON.stringify(evidence, null, 2), "utf8");
|
|
console.log(JSON.stringify({ ...evidence, evidencePath }, null, 2));
|
|
} finally {
|
|
await cleanupDocuments(context.request, createdIds).catch(() => undefined);
|
|
await context.close().catch(() => undefined);
|
|
await browser.close().catch(() => undefined);
|
|
}
|
|
}
|
|
|
|
main().catch((error) => {
|
|
console.error(error instanceof Error ? error.stack || error.message : String(error));
|
|
process.exit(1);
|
|
});
|