219 lines
13 KiB
JavaScript
219 lines
13 KiB
JavaScript
#!/usr/bin/env node
|
|
"use strict";
|
|
|
|
const assert = require("node:assert/strict");
|
|
const fs = require("node:fs");
|
|
const http = require("node:http");
|
|
const net = require("node:net");
|
|
const os = require("node:os");
|
|
const path = require("node:path");
|
|
const { spawn } = require("node:child_process");
|
|
const { chromium } = require("playwright");
|
|
|
|
const ROOT = path.resolve(__dirname, "..");
|
|
const {
|
|
setupWorkspaceAccess,
|
|
seedAiRuntime,
|
|
getAiRuntimeRun,
|
|
} = require(path.join(ROOT, "scripts", "lib", "control-plane-dev-seed"));
|
|
const OUT_DIR = process.env.MNOTE_PAGE_AI_SESSION_DASHBOARD_OUTPUT_DIR || fs.mkdtempSync(path.join(ROOT, "tmp", "task561-session-dashboard-"));
|
|
const TIMEOUT_MS = Number(process.env.MNOTE_SMOKE_UI_TIMEOUT_MS || 90_000);
|
|
const CHROME = process.env.MNOTE_PAGE_AI_CHROME || "/usr/bin/google-chrome";
|
|
const ACTOR = "mnote-e2e";
|
|
const PASSWORD = process.env.MNOTE_E2E_PASSWORD || "MnoteE2E123!";
|
|
|
|
function pickPort() {
|
|
return new Promise((resolve, reject) => {
|
|
const server = net.createServer();
|
|
server.listen(0, "127.0.0.1", () => {
|
|
const address = server.address();
|
|
const port = address && typeof address === "object" ? address.port : 0;
|
|
server.close(() => resolve(port));
|
|
});
|
|
server.on("error", reject);
|
|
});
|
|
}
|
|
|
|
function waitForHttpOk(url, timeoutMs) {
|
|
const deadline = Date.now() + timeoutMs;
|
|
return new Promise((resolve, reject) => {
|
|
const tick = () => {
|
|
const request = http.get(url, (response) => {
|
|
response.resume();
|
|
if (response.statusCode >= 200 && response.statusCode < 500) return resolve();
|
|
retry();
|
|
});
|
|
request.on("error", retry);
|
|
request.setTimeout(1000, () => { request.destroy(); retry(); });
|
|
};
|
|
const retry = () => {
|
|
if (Date.now() > deadline) return reject(new Error(`server_not_ready: ${url}`));
|
|
setTimeout(tick, 250);
|
|
};
|
|
tick();
|
|
});
|
|
}
|
|
|
|
async function signIn(context, baseUrl) {
|
|
const response = await context.request.fetch(`${baseUrl}/api/auth`, {
|
|
method: "POST",
|
|
headers: { "content-type": "application/json" },
|
|
data: { action: "auth:signIn", args: { provider: "password", params: { account: ACTOR, password: PASSWORD, flow: "signIn" } } },
|
|
timeout: TIMEOUT_MS,
|
|
});
|
|
const text = await response.text();
|
|
assert(response.ok(), `/api/auth 登录失败: ${response.status()} ${text.slice(0, 500)}`);
|
|
const whoami = await context.request.fetch(`${baseUrl}/api/auth/whoami`, { timeout: TIMEOUT_MS });
|
|
return JSON.parse(await whoami.text());
|
|
}
|
|
|
|
async function main() {
|
|
fs.mkdirSync(OUT_DIR, { recursive: true });
|
|
const port = await pickPort();
|
|
const baseUrl = `http://127.0.0.1:${port}`;
|
|
const server = spawn("cargo", ["run", "-q", "-p", "mnote-web", "--bin", "mnote-web"], {
|
|
cwd: path.join(ROOT, "rust"),
|
|
env: { ...process.env, MNOTE_WEB_BIND: `127.0.0.1:${port}`, MNOTE_WEB_PUBLIC_BIND: `127.0.0.1:${port}` },
|
|
stdio: ["ignore", "pipe", "pipe"],
|
|
});
|
|
let stderr = "";
|
|
server.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), "mnote-task561-session-dashboard-"));
|
|
let browser;
|
|
try {
|
|
await waitForHttpOk(`${baseUrl}/health`, TIMEOUT_MS);
|
|
browser = await chromium.launch({ headless: process.env.HEADFUL !== "1", executablePath: fs.existsSync(CHROME) ? CHROME : undefined });
|
|
const context = await browser.newContext({ viewport: { width: 1440, height: 960 } });
|
|
const viewer = await signIn(context, baseUrl);
|
|
const actorId = viewer.userId || ACTOR;
|
|
const suffix = Date.now().toString(36);
|
|
const workspaceId = `local-ws:${actorId}:task561-${suffix}`;
|
|
const sessionId = `mnote_task561_${suffix}`;
|
|
const runId = `run_task561_${suffix}`;
|
|
const rootUri = `file://${root}`;
|
|
const relativePath = `Task561-${suffix}.md`;
|
|
const documentId = `local-md:${relativePath.replaceAll("/", "~2F")}`;
|
|
fs.mkdirSync(path.join(root, ".mnote"), { recursive: true });
|
|
fs.writeFileSync(path.join(root, ".mnote", "workspace.json"), `${JSON.stringify({ workspaceId, ownerId: actorId }, null, 2)}\n`, "utf8");
|
|
fs.writeFileSync(path.join(root, relativePath), `# Task561 Dashboard\n\n${suffix}\n`, "utf8");
|
|
// 通过 API helper 写入 workspace/用户/授权 + run/events，不再直写 SQLite
|
|
await setupWorkspaceAccess(context.request, baseUrl, {
|
|
actorId,
|
|
email: `${actorId}@example.com`,
|
|
username: actorId,
|
|
displayName: actorId,
|
|
role: "user",
|
|
workspaceId,
|
|
workspaceName: "Task561 Session Dashboard",
|
|
rootUri,
|
|
rootPath: root,
|
|
sourceKind: "local_folder",
|
|
permission: "write",
|
|
capabilities: ["ai"],
|
|
grantSource: "smoke",
|
|
grantCreatedBy: actorId,
|
|
timeoutMs: TIMEOUT_MS,
|
|
});
|
|
await seedAiRuntime(context.request, baseUrl, {
|
|
id: `airun_${runId}`,
|
|
userId: actorId,
|
|
workspaceId,
|
|
documentId,
|
|
sessionId,
|
|
runId,
|
|
title: `Task561 Seed ${suffix}`,
|
|
profile: "reasonix",
|
|
acpRuntime: "reasonix",
|
|
traceId: `trace_${suffix}`,
|
|
status: "completed",
|
|
runtimeJson: { status: "completed", acpSessionId: `acp_${suffix}` },
|
|
payloadJson: { message: `Task561 dashboard seed ${suffix}`, requestId: `req_${suffix}`, agentId: "reasonix", acpRuntime: "reasonix" },
|
|
events: [
|
|
{ id: `aievt_${runId}_1`, eventType: "message.delta", payloadJson: { delta: `Task561 assistant answer ${suffix}` } },
|
|
{ id: `aievt_${runId}_2`, eventType: "run.completed", payloadJson: { stopReason: "EndTurn" } },
|
|
],
|
|
timeoutMs: TIMEOUT_MS,
|
|
});
|
|
const page = await context.newPage();
|
|
const url = new URL(`${baseUrl}/documents/${encodeURIComponent(documentId)}`);
|
|
url.searchParams.set("sourceKind", "local_folder");
|
|
url.searchParams.set("rootUri", rootUri);
|
|
url.searchParams.set("workspaceId", workspaceId);
|
|
await page.goto(url.toString(), { waitUntil: "domcontentloaded", timeout: TIMEOUT_MS });
|
|
await page.getByTestId("wolai-floating-ai").click({ timeout: TIMEOUT_MS });
|
|
await page.locator('[data-page-ai-tab="agent"]').first().click({ timeout: TIMEOUT_MS });
|
|
const settingTabs = page.locator('[data-page-ai-panel="agent"] .wolai-page-ai-settings-tabs [data-page-ai-tab]');
|
|
const settingTabTexts = await settingTabs.evaluateAll((nodes) => nodes.map((node) => node.textContent.trim()).filter(Boolean));
|
|
assert.deepEqual(settingTabTexts, ['MNote', 'Reasonix', 'Hermes'], `设置页 tabs 应只包含 MNote / Reasonix / Hermes: ${JSON.stringify(settingTabTexts)}`);
|
|
assert(!settingTabTexts.includes('Common') && !settingTabTexts.includes('Chat-only') && !settingTabTexts.includes('高级') && !settingTabTexts.includes('Runtime'), `设置页不应显示旧一级 tab: ${JSON.stringify(settingTabTexts)}`);
|
|
const mnotePanelText = await page.locator('[data-page-ai-panel="agent"]').textContent({ timeout: TIMEOUT_MS });
|
|
assert(String(mnotePanelText || '').includes('授权区域'), 'MNote tab 应显示授权区域');
|
|
assert(String(mnotePanelText || '').includes('默认上下文'), 'MNote tab 应显示默认上下文');
|
|
assert(String(mnotePanelText || '').includes('MNote 工具'), 'MNote tab 应显示 MNote 工具');
|
|
assert(String(mnotePanelText || '').includes('会话与审计'), 'MNote tab 应显示会话与审计');
|
|
await page.locator('[data-page-ai-panel="agent"] [data-page-ai-tab="reasonix-settings"]').click({ timeout: TIMEOUT_MS });
|
|
const reasonixPanelText = await page.locator('[data-page-ai-panel="reasonix-settings"]').textContent({ timeout: TIMEOUT_MS });
|
|
assert(String(reasonixPanelText || '').includes('ACP runtime'), 'Reasonix tab 应显示 ACP runtime');
|
|
assert(!/MNOTE_WEB_HERMES_UPSTREAM_URL|API key|Hermes 设置入口/.test(String(reasonixPanelText || '')), `Reasonix tab 不应显示 Hermes gateway/API key 错误: ${reasonixPanelText}`);
|
|
await page.locator('[data-page-ai-panel="reasonix-settings"] [data-page-ai-tab="hermes-settings"]').click({ timeout: TIMEOUT_MS });
|
|
const hermesPanelText = await page.locator('[data-page-ai-panel="hermes-settings"]').textContent({ timeout: TIMEOUT_MS });
|
|
assert(String(hermesPanelText || '').includes('Hermes profile'), 'Hermes tab 应显示 profile');
|
|
assert(String(hermesPanelText || '').includes('Hermes gateway'), 'Hermes tab 应显示 gateway');
|
|
assert(!String(hermesPanelText || '').includes('native-live queue'), 'Hermes tab 不应显示 Reasonix native-live queue 当前状态');
|
|
const settingsScreenshotPath = path.join(OUT_DIR, "task561-settings-ia.png");
|
|
await page.screenshot({ path: settingsScreenshotPath, fullPage: true });
|
|
await page.locator('[data-page-ai-action="history"]').first().click({ timeout: TIMEOUT_MS });
|
|
const row = page.locator(`[data-page-ai-session-row="${sessionId}"]`).first();
|
|
await row.waitFor({ state: "visible", timeout: TIMEOUT_MS });
|
|
const statusFilter = page.locator('[data-page-ai-session-status-filter]');
|
|
await statusFilter.waitFor({ state: "visible", timeout: TIMEOUT_MS });
|
|
const statusValues = await statusFilter.locator('option').evaluateAll((options) => options.map((option) => option.value));
|
|
assert(statusValues.includes('completed'), `status filter 应包含 completed: ${JSON.stringify(statusValues)}`);
|
|
assert.equal(await row.getAttribute('data-page-ai-session-status'), 'completed');
|
|
await statusFilter.selectOption('completed', { timeout: TIMEOUT_MS });
|
|
await row.waitFor({ state: "visible", timeout: TIMEOUT_MS });
|
|
await page.locator('[data-page-ai-session-search]').fill(`dashboard seed ${suffix}`, { timeout: TIMEOUT_MS });
|
|
await row.waitFor({ state: "visible", timeout: TIMEOUT_MS });
|
|
const beforeDeleteScreenshotPath = path.join(OUT_DIR, "task561-session-dashboard-before-delete.png");
|
|
await page.screenshot({ path: beforeDeleteScreenshotPath, fullPage: true });
|
|
const exportApiResponse = await context.request.fetch(`${baseUrl}/api/page-ai/sessions/${encodeURIComponent(sessionId)}/export?workspaceId=${encodeURIComponent(workspaceId)}&documentId=${encodeURIComponent(documentId)}&limit=200`, { timeout: TIMEOUT_MS });
|
|
const exportApiText = await exportApiResponse.text();
|
|
assert(exportApiResponse.ok(), `/api/page-ai/sessions export 失败: ${exportApiResponse.status()} ${exportApiText.slice(0, 500)}`);
|
|
const exportApiPayload = JSON.parse(exportApiText);
|
|
assert.deepEqual(exportApiPayload.export.formats, ['json', 'markdown', 'jsonl']);
|
|
assert(String(exportApiPayload.export.markdown || '').includes(sessionId), 'markdown export 应包含 sessionId');
|
|
assert(String(exportApiPayload.export.jsonl || '').includes('"eventType"'), 'jsonl export 应包含事件行');
|
|
await page.locator(`[data-page-ai-session-export="${sessionId}"]`).click({ timeout: TIMEOUT_MS });
|
|
await page.waitForFunction((id) => document.documentElement.getAttribute('data-mnote-page-ai-session-exported') === id, sessionId, { timeout: TIMEOUT_MS });
|
|
await page.evaluate(() => { window.prompt = () => 'Task561 Renamed'; });
|
|
await page.locator(`[data-page-ai-session-rename="${sessionId}"]`).click({ timeout: TIMEOUT_MS });
|
|
await page.waitForFunction((id) => {
|
|
const row = document.querySelector(`[data-page-ai-session-row="${id}"]`);
|
|
return row && row.textContent.includes('Task561 Renamed');
|
|
}, sessionId, { timeout: TIMEOUT_MS });
|
|
await page.evaluate(() => { window.confirm = () => true; });
|
|
await page.locator(`[data-page-ai-session-delete="${sessionId}"]`).click({ timeout: TIMEOUT_MS });
|
|
await page.waitForFunction((id) => !document.querySelector(`[data-page-ai-session-row="${id}"]`), sessionId, { timeout: TIMEOUT_MS });
|
|
// 通过 API helper 验证软删除，不再直读 SQLite
|
|
const deletedRun = await getAiRuntimeRun(context.request, baseUrl, { userId: actorId, runId });
|
|
assert(deletedRun, `run ${runId} 应仍 persist（软删除）`);
|
|
assert(deletedRun.deletedAt, "delete 应软删除 SQLite session runs");
|
|
const screenshotPath = path.join(OUT_DIR, "task561-session-dashboard.png");
|
|
await page.screenshot({ path: screenshotPath, fullPage: true });
|
|
const result = { ok: true, baseUrl, outDir: OUT_DIR, workspaceId, documentId, sessionId, runId, settingsScreenshotPath, beforeDeleteScreenshotPath, screenshotPath };
|
|
fs.writeFileSync(path.join(OUT_DIR, "result.json"), `${JSON.stringify(result, null, 2)}\n`, "utf8");
|
|
console.log(JSON.stringify(result, null, 2));
|
|
await context.close().catch(() => undefined);
|
|
} catch (error) {
|
|
fs.writeFileSync(path.join(OUT_DIR, "failure.json"), `${JSON.stringify({ ok: false, error: String(error && error.stack || error), stderr }, null, 2)}\n`, "utf8");
|
|
throw error;
|
|
} finally {
|
|
if (browser) await browser.close().catch(() => undefined);
|
|
server.kill("SIGTERM");
|
|
await new Promise((resolve) => server.once("exit", resolve));
|
|
if (process.env.MNOTE_KEEP_TASK561_ROOT !== "1") fs.rmSync(root, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
main().catch((error) => { console.error(error && error.stack ? error.stack : error); process.exit(1); });
|