lix-2026
9f4b5c4d48
- scope local-folder PageTree revision and document sidebar rendering to fileTreeScope - preserve projected table/image attrs for local Markdown aggregate fallback - avoid FileTree restore forced layouts on cold design open - add API ChatOnly provider runtime and local OCR task handling regressions
409 lines
19 KiB
JavaScript
409 lines
19 KiB
JavaScript
#!/usr/bin/env node
|
|
"use strict";
|
|
|
|
const assert = require("node:assert");
|
|
const fs = require("node:fs");
|
|
const os = require("node:os");
|
|
const path = require("node:path");
|
|
const { chromium } = require("playwright");
|
|
const { ensureAuthenticated, UI_TIMEOUT_MS } = require("./tree-shell-smoke-helpers");
|
|
|
|
const BASE_URL = (process.env.MNOTE_WEB_SMOKE_BASE_URL || process.env.MNOTE_UI_BASE_URL || "http://127.0.0.1:3000").replace(/\/+$/, "");
|
|
const TASK = "task526-local-folder-ocr-api-smoke";
|
|
const OUTPUT_DIR = path.join(process.cwd(), "tmp", TASK);
|
|
const RESULT_PATH = path.join(OUTPUT_DIR, "result.json");
|
|
|
|
function fileUrl(localPath) {
|
|
return `file://${localPath.split(path.sep).map((part, index) => (
|
|
index === 0 ? "" : encodeURIComponent(part)
|
|
)).join("/")}`;
|
|
}
|
|
|
|
function localMdDocumentId(relativePath) {
|
|
return `local-md:${Buffer.from(relativePath, "utf8")
|
|
.toString("hex")
|
|
.replace(/../g, (hex) => {
|
|
const code = Number.parseInt(hex, 16);
|
|
const ch = String.fromCharCode(code);
|
|
return /[A-Za-z0-9._-]/.test(ch) ? ch : `~${hex.toUpperCase()}`;
|
|
})}`;
|
|
}
|
|
|
|
function documentUrl(root, relativePath) {
|
|
const url = new URL(`${BASE_URL}/documents/${encodeURIComponent(localMdDocumentId(relativePath))}`);
|
|
url.searchParams.set("sourceKind", "local_folder");
|
|
url.searchParams.set("rootUri", fileUrl(root));
|
|
url.searchParams.set("treeView", "filetree");
|
|
return url.toString();
|
|
}
|
|
|
|
function writeWorkspaceManifest(root, ownerId) {
|
|
const metadataDir = path.join(root, ".mnote");
|
|
fs.mkdirSync(metadataDir, { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(metadataDir, "workspace.json"),
|
|
`${JSON.stringify({
|
|
workspaceId: `local-ws:${ownerId}:task526`,
|
|
ownerId,
|
|
createdAt: new Date().toISOString(),
|
|
capabilities: ["local_files", "markdown_edit", "ocr"],
|
|
}, null, 2)}\n`,
|
|
"utf8",
|
|
);
|
|
}
|
|
|
|
async function writeResult(payload) {
|
|
fs.mkdirSync(OUTPUT_DIR, { recursive: true });
|
|
fs.writeFileSync(RESULT_PATH, `${JSON.stringify({ ...payload, resultPath: RESULT_PATH }, null, 2)}\n`, "utf8");
|
|
}
|
|
|
|
async function ensureDocumentVisible(page, root, relativePath) {
|
|
await page.goto(documentUrl(root, relativePath), { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
|
|
if (new URL(page.url()).pathname === "/auth") {
|
|
const quickLogin = page.getByRole("button", { name: "测试账号快速登录" });
|
|
await quickLogin.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await quickLogin.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForURL((url) => url.pathname !== "/auth", { timeout: UI_TIMEOUT_MS }).catch(() => undefined);
|
|
await page.goto(documentUrl(root, relativePath), { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
|
|
}
|
|
await page.locator('[data-testid="mnote-leptos-tiptap-island-editor-root"]').first().waitFor({
|
|
state: "visible",
|
|
timeout: UI_TIMEOUT_MS,
|
|
});
|
|
}
|
|
|
|
async function main() {
|
|
fs.mkdirSync(OUTPUT_DIR, { recursive: true });
|
|
const root = fs.mkdtempSync(path.join(os.tmpdir(), "mnote-task526-ocr-"));
|
|
const actorId = "mnote-e2e";
|
|
const workspaceId = `local-ws:${actorId}:task526`;
|
|
const relativePath = "docs/Page.md";
|
|
const documentId = localMdDocumentId(relativePath);
|
|
const sourceRootRelativePath = "docs/Page.assets/photo.png";
|
|
const failedSourceRootRelativePath = "docs/Page.assets/photo-failed.png";
|
|
const ocrToken = "TASK526_OCR_TOKEN";
|
|
writeWorkspaceManifest(root, actorId);
|
|
fs.mkdirSync(path.join(root, "docs", "Page.assets"), { recursive: true });
|
|
fs.writeFileSync(path.join(root, relativePath), "# OCR Page\n\n\n", "utf8");
|
|
const tinyPng = Buffer.from(
|
|
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAFgwJ/l8FQOQAAAABJRU5ErkJggg==",
|
|
"base64",
|
|
);
|
|
fs.writeFileSync(path.join(root, sourceRootRelativePath), tinyPng);
|
|
fs.writeFileSync(path.join(root, failedSourceRootRelativePath), tinyPng);
|
|
|
|
const browser = await chromium.launch({ headless: true });
|
|
const context = await browser.newContext();
|
|
const page = await context.newPage();
|
|
const screenshots = {};
|
|
try {
|
|
await ensureAuthenticated(page, context.request);
|
|
await ensureDocumentVisible(page, root, relativePath);
|
|
await page.waitForFunction(() => {
|
|
const image = document.querySelector('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror img');
|
|
return image instanceof HTMLImageElement
|
|
&& image.complete
|
|
&& image.naturalWidth > 0
|
|
&& image.src.includes("Page.assets%2Fphoto.png")
|
|
&& !image.src.includes("%3C")
|
|
&& !image.src.includes("%3E");
|
|
}, null, { timeout: UI_TIMEOUT_MS });
|
|
screenshots.page = path.join(OUTPUT_DIR, "01-page.png");
|
|
await page.screenshot({ path: screenshots.page, fullPage: true });
|
|
|
|
await page.waitForFunction(() => Boolean(window.__mnoteDocumentPaneRuntime?.openResourceInActiveTab), null, {
|
|
timeout: UI_TIMEOUT_MS,
|
|
});
|
|
await page.evaluate(async ({ rootUri, documentId, sourceRootRelativePath, workspaceId }) => {
|
|
window.__MNOTE_LOCAL_OCR_PROVIDER = "mock";
|
|
const title = sourceRootRelativePath.split("/").filter(Boolean).pop() || "photo.png";
|
|
const fileUrl = new URL("/api/local-folder/files/open", window.location.origin);
|
|
fileUrl.searchParams.set("rootUri", rootUri);
|
|
fileUrl.searchParams.set("path", sourceRootRelativePath);
|
|
const opened = await window.__mnoteDocumentPaneRuntime.openResourceInActiveTab({
|
|
objectIdentity: `local-file:${sourceRootRelativePath}`,
|
|
assetId: `local-file:${sourceRootRelativePath}`,
|
|
title,
|
|
fileName: title,
|
|
kind: "image",
|
|
rootUri,
|
|
path: sourceRootRelativePath,
|
|
href: fileUrl.toString(),
|
|
documentId,
|
|
ownerDocumentId: documentId,
|
|
workspaceId,
|
|
sourceKind: "local_folder",
|
|
});
|
|
if (!opened) throw new Error("OCR source image resource tab did not open");
|
|
}, {
|
|
rootUri: fileUrl(root),
|
|
documentId,
|
|
sourceRootRelativePath,
|
|
workspaceId,
|
|
});
|
|
await page.locator('[data-mnote-resource-tab-panel]:not([hidden]) [data-testid="mnote-local-ocr-toolbar"]').first().waitFor({
|
|
state: "detached",
|
|
timeout: UI_TIMEOUT_MS,
|
|
});
|
|
const watchBatchBeforeOcr = await page.evaluate(() => document.documentElement.getAttribute("data-mnote-local-folder-watch-batch-applied") || "");
|
|
await page.getByTestId("mnote-local-ocr-task-toggle").waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await page.getByTestId("mnote-local-ocr-task-toggle").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.getByTestId("mnote-local-ocr-task-drawer").waitFor({ state: "hidden", timeout: UI_TIMEOUT_MS });
|
|
const topbarOcrButtonInfo = await page.getByTestId("mnote-local-ocr-task-toggle").evaluate((node) => {
|
|
const topbar = node.closest(".wolai-topbar-actions");
|
|
return {
|
|
inTopbar: Boolean(topbar),
|
|
text: node.textContent || "",
|
|
badge: node.querySelector("[data-mnote-local-ocr-task-count]")?.textContent || "",
|
|
};
|
|
});
|
|
assert.equal(topbarOcrButtonInfo.inTopbar, true, `OCR 任务入口应位于右上角 topbar: ${JSON.stringify(topbarOcrButtonInfo)}`);
|
|
await page.waitForFunction(
|
|
(sourcePath) => {
|
|
const row = document.querySelector(`[data-mnote-local-ocr-task-row="${CSS.escape(sourcePath)}"]`);
|
|
return row && row.getAttribute("data-mnote-local-ocr-task-status") === "done";
|
|
},
|
|
sourceRootRelativePath,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
await page.getByTestId("mnote-local-ocr-task-toggle").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.getByTestId("mnote-local-ocr-task-drawer").waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
const uiOcrPath = await page.evaluate(async ({ rootUri, sourceRootRelativePath }) => {
|
|
const url = new URL("/api/local-folder/ocr/status", window.location.origin);
|
|
url.searchParams.set("rootUri", rootUri);
|
|
url.searchParams.set("sourceRootRelativePath", sourceRootRelativePath);
|
|
const response = await fetch(url.toString(), { cache: "no-store", headers: { accept: "application/json" } });
|
|
const payload = await response.json().catch(() => null);
|
|
return payload?.job?.ocrRootRelativePath || "";
|
|
}, {
|
|
rootUri: fileUrl(root),
|
|
sourceRootRelativePath,
|
|
});
|
|
assert(uiOcrPath && uiOcrPath.endsWith(".ocr.md"), `UI OCR path invalid: ${uiOcrPath}`);
|
|
await page.waitForFunction(
|
|
({ before, ocrPath }) => {
|
|
const root = document.documentElement;
|
|
const marker = root.getAttribute("data-mnote-local-ocr-filetree-refresh") || "";
|
|
const applied = root.getAttribute("data-mnote-local-folder-watch-batch-applied") || "";
|
|
return marker === ocrPath && applied && applied !== before;
|
|
},
|
|
{ before: watchBatchBeforeOcr, ocrPath: uiOcrPath },
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
screenshots.ocrToolbar = path.join(OUTPUT_DIR, "02-ocr-toolbar.png");
|
|
await page.screenshot({ path: screenshots.ocrToolbar, fullPage: true });
|
|
|
|
const failedOcrRoute = async (route) => {
|
|
if (route.request().method() !== "POST") return route.fallback();
|
|
const body = route.request().postDataJSON();
|
|
if (body?.sourceRootRelativePath !== failedSourceRootRelativePath) return route.fallback();
|
|
return route.fulfill({
|
|
status: 401,
|
|
contentType: "application/json",
|
|
body: JSON.stringify({ ok: false, error: { message: "local_ocr_job_failed_401" } }),
|
|
});
|
|
};
|
|
await page.route("**/api/local-folder/ocr/jobs", failedOcrRoute);
|
|
await page.evaluate(async ({ rootUri, documentId, sourceRootRelativePath, workspaceId }) => {
|
|
window.__MNOTE_LOCAL_OCR_PROVIDER = "mineru";
|
|
const title = sourceRootRelativePath.split("/").filter(Boolean).pop() || "photo-failed.png";
|
|
const fileUrl = new URL("/api/local-folder/files/open", window.location.origin);
|
|
fileUrl.searchParams.set("rootUri", rootUri);
|
|
fileUrl.searchParams.set("path", sourceRootRelativePath);
|
|
const opened = await window.__mnoteDocumentPaneRuntime.openResourceInActiveTab({
|
|
objectIdentity: `local-file:${sourceRootRelativePath}`,
|
|
assetId: `local-file:${sourceRootRelativePath}`,
|
|
title,
|
|
fileName: title,
|
|
kind: "image",
|
|
rootUri,
|
|
path: sourceRootRelativePath,
|
|
href: fileUrl.toString(),
|
|
documentId,
|
|
ownerDocumentId: documentId,
|
|
workspaceId,
|
|
sourceKind: "local_folder",
|
|
});
|
|
if (!opened) throw new Error("OCR failed source image resource tab did not open");
|
|
}, {
|
|
rootUri: fileUrl(root),
|
|
documentId,
|
|
sourceRootRelativePath: failedSourceRootRelativePath,
|
|
workspaceId,
|
|
});
|
|
const failedImageTab = page.locator('.mnote-main-tab[data-mnote-tab-kind="image"]', { hasText: "photo-failed.png" }).first();
|
|
await failedImageTab.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await failedImageTab.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => {
|
|
const active = document.querySelector('.mnote-main-tab.is-active[data-mnote-tab-kind="image"] .mnote-main-tab-title');
|
|
return active && (active.textContent || "").includes("photo-failed.png");
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
await page.locator('[data-mnote-resource-tab-panel]:not([hidden]) [data-testid="mnote-local-ocr-toolbar"]').first().waitFor({
|
|
state: "detached",
|
|
timeout: UI_TIMEOUT_MS,
|
|
});
|
|
await page.getByTestId("mnote-local-ocr-task-toggle").click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
(sourcePath) => {
|
|
const row = document.querySelector(`[data-mnote-local-ocr-task-row="${CSS.escape(sourcePath)}"]`);
|
|
return row
|
|
&& row.getAttribute("data-mnote-local-ocr-task-status") === "failed"
|
|
&& (row.textContent || "").includes("local_ocr_job_failed_401");
|
|
},
|
|
failedSourceRootRelativePath,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
screenshots.ocrFailedTask = path.join(OUTPUT_DIR, "04-ocr-failed-task.png");
|
|
await page.screenshot({ path: screenshots.ocrFailedTask, fullPage: true });
|
|
await page.unroute("**/api/local-folder/ocr/jobs", failedOcrRoute);
|
|
|
|
const openResourceResult = await page.evaluate(async ({ rootUri, documentId, ocrRootRelativePath, workspaceId }) => {
|
|
const runtime = window.__mnoteDocumentPaneRuntime;
|
|
if (!runtime || typeof runtime.openResourceInActiveTab !== "function") {
|
|
throw new Error("缺少 openResourceInActiveTab runtime");
|
|
}
|
|
const title = ocrRootRelativePath.split("/").filter(Boolean).pop() || "OCR";
|
|
return await runtime.openResourceInActiveTab({
|
|
kind: "markdown",
|
|
title,
|
|
path: ocrRootRelativePath,
|
|
objectIdentity: `local-ocr:${ocrRootRelativePath}`,
|
|
assetId: `local-ocr:${ocrRootRelativePath}`,
|
|
documentId,
|
|
ownerDocumentId: documentId,
|
|
workspaceId,
|
|
sourceKind: "local_folder",
|
|
rootUri,
|
|
resourceKind: "markdown",
|
|
});
|
|
}, {
|
|
rootUri: fileUrl(root),
|
|
documentId,
|
|
ocrRootRelativePath: uiOcrPath,
|
|
workspaceId,
|
|
});
|
|
assert.equal(openResourceResult, true, "OCR sidecar resource tab should open");
|
|
await page.locator('[data-mnote-resource-tab-panel][data-resource-kind="markdown"]:not([hidden]) [data-testid="mnote-leptos-tiptap-island-editor-root"]').first().waitFor({
|
|
state: "visible",
|
|
timeout: UI_TIMEOUT_MS,
|
|
});
|
|
await page.waitForFunction(
|
|
() => {
|
|
const active = document.querySelector('[data-mnote-resource-tab-panel][data-resource-kind="markdown"]:not([hidden]) .ProseMirror');
|
|
return active && (active.textContent || "").includes("OCR UI smoke text");
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
).catch(async (error) => {
|
|
const debug = await page.evaluate(() => ({
|
|
activeTab: document.querySelector('.mnote-main-tab.is-active')?.outerHTML || '',
|
|
activePanels: Array.from(document.querySelectorAll('[data-mnote-resource-tab-panel]:not([hidden])')).map((panel) => ({
|
|
kind: panel.getAttribute('data-resource-kind') || '',
|
|
objectIdentity: panel.getAttribute('data-mnote-object-identity') || '',
|
|
text: (panel.textContent || '').slice(0, 200),
|
|
html: panel.innerHTML.slice(0, 500),
|
|
})),
|
|
marker: document.documentElement.getAttribute('data-mnote-local-ocr-filetree-open') || '',
|
|
}));
|
|
throw new Error(`${error.message}; debug=${JSON.stringify(debug)}`);
|
|
});
|
|
const fileTreeOpenResult = await page.evaluate((ocrRootRelativePath) => {
|
|
const parentPath = ocrRootRelativePath.split("/").slice(0, -1).join("/");
|
|
const parentRow = document.querySelector(`#sidebar-file-tree-root .tree-row[data-shell-mode="filetree"][data-local-relative-path="${CSS.escape(parentPath)}"]`);
|
|
if (!(parentRow instanceof HTMLElement)) return { ok: false, reason: "ocr_parent_row_missing", parentPath };
|
|
if (parentRow.getAttribute("aria-expanded") !== "true") {
|
|
const toggle = parentRow.querySelector('[data-rust-action="toggle"]');
|
|
if (toggle instanceof HTMLElement) toggle.click();
|
|
}
|
|
return { ok: true, parentPath };
|
|
}, uiOcrPath);
|
|
assert.equal(fileTreeOpenResult.ok, true, `OCR sidecar parent should exist in filetree: ${JSON.stringify(fileTreeOpenResult)}`);
|
|
const ocrFileTreeRow = page.locator(`#sidebar-file-tree-root .tree-row[data-shell-mode="filetree"][data-local-relative-path="${uiOcrPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`).first();
|
|
await ocrFileTreeRow.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
|
|
await ocrFileTreeRow.click({ timeout: UI_TIMEOUT_MS });
|
|
await page.waitForFunction(
|
|
() => document.documentElement.getAttribute("data-mnote-local-ocr-filetree-open") === "resource-tab",
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
await page.waitForFunction(
|
|
() => {
|
|
const active = document.querySelector('[data-mnote-resource-tab-panel][data-resource-kind="markdown"]:not([hidden]) .ProseMirror');
|
|
return active && (active.textContent || "").includes("OCR UI smoke text");
|
|
},
|
|
null,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
).catch(async (error) => {
|
|
const debug = await page.evaluate(() => ({
|
|
activeTab: document.querySelector('.mnote-main-tab.is-active')?.outerHTML || '',
|
|
activePanels: Array.from(document.querySelectorAll('[data-mnote-resource-tab-panel]:not([hidden])')).map((panel) => ({
|
|
kind: panel.getAttribute('data-resource-kind') || '',
|
|
objectIdentity: panel.getAttribute('data-mnote-object-identity') || '',
|
|
text: (panel.textContent || '').slice(0, 200),
|
|
html: panel.innerHTML.slice(0, 500),
|
|
})),
|
|
marker: document.documentElement.getAttribute('data-mnote-local-ocr-filetree-open') || '',
|
|
}));
|
|
throw new Error(`${error.message}; debug=${JSON.stringify(debug)}`);
|
|
});
|
|
screenshots.ocrResource = path.join(OUTPUT_DIR, "03-ocr-resource-tab.png");
|
|
await page.screenshot({ path: screenshots.ocrResource, fullPage: true });
|
|
await page.evaluate((sourcePath) => {
|
|
const row = document.querySelector(`[data-mnote-local-ocr-task-row="${CSS.escape(sourcePath)}"]`);
|
|
const clear = row && row.querySelector("[data-mnote-local-ocr-task-clear]");
|
|
if (!(clear instanceof HTMLButtonElement)) throw new Error("missing OCR clear button");
|
|
clear.click();
|
|
}, failedSourceRootRelativePath);
|
|
await page.waitForFunction(
|
|
(sourcePath) => !document.querySelector(`[data-mnote-local-ocr-task-row="${CSS.escape(sourcePath)}"]`),
|
|
failedSourceRootRelativePath,
|
|
{ timeout: UI_TIMEOUT_MS },
|
|
);
|
|
const deleteButtonVisible = await page.evaluate((sourcePath) => {
|
|
const row = document.querySelector(`[data-mnote-local-ocr-task-row="${CSS.escape(sourcePath)}"]`);
|
|
return Boolean(row && row.querySelector("[data-mnote-local-ocr-task-delete]"));
|
|
}, sourceRootRelativePath);
|
|
assert.equal(deleteButtonVisible, true, "已完成 OCR 任务应展示删除 OCR 按钮");
|
|
|
|
await writeResult({
|
|
ok: true,
|
|
task: TASK,
|
|
root,
|
|
documentId,
|
|
ocrRootRelativePath: uiOcrPath,
|
|
screenshots,
|
|
});
|
|
console.log(JSON.stringify({
|
|
ok: true,
|
|
task: TASK,
|
|
root,
|
|
documentId,
|
|
ocrRootRelativePath: uiOcrPath,
|
|
screenshots,
|
|
}, null, 2));
|
|
} catch (error) {
|
|
screenshots.failure = path.join(OUTPUT_DIR, "failure.png");
|
|
await page.screenshot({ path: screenshots.failure, fullPage: true }).catch(() => undefined);
|
|
await writeResult({
|
|
ok: false,
|
|
task: TASK,
|
|
error: error instanceof Error ? error.message : String(error),
|
|
root,
|
|
documentId,
|
|
screenshots,
|
|
});
|
|
throw error;
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
}
|
|
|
|
main().catch((error) => {
|
|
console.error(error instanceof Error ? error.stack || error.message : String(error));
|
|
process.exit(1);
|
|
});
|