chore: checkpoint pi lab rust integration work

2026-07-11 20:39:18 +08:00
parent d47f6447fd
commit d16eccfe10
39 changed files with 4843 additions and 455 deletions
@@ -0,0 +1,182 @@
+#!/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 BASE = process.env.MNOTE_UI_BASE_URL || "http://127.0.0.1:3000";
+const TIMEOUT = Number.parseInt(process.env.UI_TIMEOUT_MS || "120000", 10);
+const STAMP = Date.now();
+const OUT = process.env.MNOTE_PI_WARMUP_BINDING_OUT || path.join(os.tmpdir(), `mnote-pi-warmup-binding-${STAMP}`);
+const ROOT_PATH = process.env.MNOTE_PI_WARMUP_BINDING_ROOT_PATH || "/mnt/Data1T/Mnote_data/users/mnote-e2e/workspaces/my-space";
+const ROOT_URI = process.env.MNOTE_PI_WARMUP_BINDING_ROOT_URI || `file://${ROOT_PATH}`;
+const WORKSPACE_ID = process.env.MNOTE_PI_WARMUP_BINDING_WORKSPACE_ID || "local-ws:mnote-e2e:my-space";
+const PAGE_PATH = `pi-warmup-binding-${STAMP}.md`;
+const CHROMIUM_EXECUTABLE = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE
+  || (fs.existsSync("/usr/bin/chromium-browser") ? "/usr/bin/chromium-browser" : "")
+  || (fs.existsSync("/usr/bin/chromium") ? "/usr/bin/chromium" : "")
+  || (fs.existsSync("/usr/bin/google-chrome") ? "/usr/bin/google-chrome" : "");
+
+async function requestJson(page, url, options = {}) {
+  const response = await page.request.fetch(`${BASE}${url}`, {
+    ...options,
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+      ...(options.headers || {}),
+    },
+    timeout: options.timeout || TIMEOUT,
+  });
+  const text = await response.text();
+  let body = {};
+  try {
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    body = { raw: text };
+  }
+  return { response, body };
+}
+
+async function quickLogin(page) {
+  await page.goto(`${BASE}/auth`, { waitUntil: "commit", timeout: TIMEOUT });
+  const quickLoginButton = page.getByRole("button", { name: "测试账号快速登录" });
+  if (!(await quickLoginButton.isVisible({ timeout: 4000 }).catch(() => false))) return;
+  await Promise.all([
+    page.waitForURL((url) => !url.toString().includes("/auth"), { timeout: TIMEOUT }).catch(() => null),
+    quickLoginButton.click(),
+  ]);
+}
+
+async function cleanupPreviousSmokeSession(page) {
+  const status = await requestJson(page, "/api/page-ai/pi/status");
+  assert(status.response.ok(), `status before cleanup should be OK, got ${status.response.status()}`);
+  const session = status.body.session || {};
+  const sessionId = status.body.sessionId || session.sessionId;
+  const pagePath = String(session.pagePath || "");
+  if (!sessionId || !pagePath.startsWith("pi-warmup-binding-")) return;
+  await requestJson(page, "/api/page-ai/pi/abort", {
+    method: "POST",
+    data: { sessionId },
+  }).catch(() => null);
+  await requestJson(page, `/api/page-ai/pi/sessions/${encodeURIComponent(sessionId)}`, {
+    method: "DELETE",
+  }).catch(() => null);
+}
+
+async function main() {
+  fs.mkdirSync(OUT, { recursive: true });
+  fs.mkdirSync(ROOT_PATH, { recursive: true });
+  fs.writeFileSync(path.join(ROOT_PATH, PAGE_PATH), "# Pi warmup binding\n\nWarmup binding smoke.\n", "utf8");
+
+  const browser = await chromium.launch({
+    headless: process.env.MNOTE_PI_WARMUP_BINDING_HEADED === "1" ? false : true,
+    executablePath: CHROMIUM_EXECUTABLE || undefined,
+  });
+  const context = await browser.newContext({ viewport: { width: 1440, height: 960 } });
+  await context.addInitScript((payload) => {
+    window.__MNOTE_TEST_PAGE_CONTEXT__ = payload;
+  }, {
+    rootUri: ROOT_URI,
+    workspaceId: WORKSPACE_ID,
+    pagePath: PAGE_PATH,
+    pageTitle: "Pi warmup binding",
+  });
+  const page = await context.newPage();
+  const requests = [];
+  const result = {
+    base: BASE,
+    out: OUT,
+    rootUri: ROOT_URI,
+    workspaceId: WORKSPACE_ID,
+    pagePath: PAGE_PATH,
+    statusBefore: null,
+    statusAfter: null,
+    startRequest: null,
+    startBeforeSend: false,
+    coldStartToastVisible: false,
+  };
+
+  try {
+    await quickLogin(page);
+    await cleanupPreviousSmokeSession(page);
+    const statusBefore = await page.request.get(`${BASE}/api/page-ai/pi/status`);
+    assert(statusBefore.ok(), `status before should be OK, got ${statusBefore.status()}`);
+    result.statusBefore = await statusBefore.json();
+    assert.equal(result.statusBefore.warmupRunning, true, "dev:hot warmup runtime should be running before UI send");
+    assert.equal(result.statusBefore.sessionId || null, null, "warmup session must not be exposed as current page session");
+
+    await page.route("**/api/page-ai/pi/send", async (route) => {
+      const request = route.request();
+      requests.push({ url: request.url(), body: request.postDataJSON() });
+      await route.fulfill({
+        status: 200,
+        contentType: "application/json",
+        body: JSON.stringify({
+          ok: true,
+          schema: "mnote.page_ai_pi.send.v1",
+          sessionId: request.postDataJSON().sessionId,
+          accepted: true,
+          intercepted: true,
+        }),
+      });
+    });
+
+    const documentId = `local-md:${PAGE_PATH.replaceAll("/", "~2F")}`;
+    await page.goto(
+      `${BASE}/documents/${encodeURIComponent(documentId)}?sourceKind=local_folder&rootUri=${encodeURIComponent(ROOT_URI)}&workspaceId=${encodeURIComponent(WORKSPACE_ID)}&path=${encodeURIComponent(PAGE_PATH)}`,
+      { waitUntil: "commit", timeout: TIMEOUT },
+    );
+    await page.locator("[data-page-ai-pi-lab-launcher]").waitFor({ state: "visible", timeout: TIMEOUT });
+    const startResponsePromise = page.waitForResponse(
+      (response) => response.url().includes("/api/page-ai/pi/start") && response.request().method() === "POST",
+      { timeout: TIMEOUT },
+    );
+    await page.locator("[data-page-ai-pi-lab-launcher]").click();
+    await page.locator('[data-page-ai-pi-lab="drawer"]').waitFor({ state: "visible", timeout: TIMEOUT });
+    const startResponse = await startResponsePromise;
+    result.startBeforeSend = true;
+    assert(startResponse.ok(), `start response should be OK, got ${startResponse.status()}`);
+    const startBody = await startResponse.json();
+    result.startRequest = startResponse.request().postDataJSON();
+    assert.equal(startBody.ok, true, "start body should be ok");
+    assert(startBody.session?.sessionId, "start should return a current page session");
+    assert(!String(startBody.session.sessionId).startsWith("pi_lab_dev_warm_"), "current page session should not reuse warmup prompt session id");
+    assert.equal(startBody.session.pagePath, PAGE_PATH, "current page session should bind current page path");
+
+    await page.waitForFunction(
+      () => document.querySelector("[data-page-ai-pi-lab-status-text]")?.textContent?.includes("ready")
+        || document.querySelector("[data-page-ai-pi-lab-status-text]")?.textContent?.includes("streaming"),
+      null,
+      { timeout: TIMEOUT },
+    );
+    await page.locator("[data-page-ai-pi-lab-input]").fill("warmup binding smoke");
+    await page.locator("[data-page-ai-pi-lab-btn-send]").click();
+    result.coldStartToastVisible = await page.locator("[data-page-ai-pi-lab-toast]", { hasText: "正在绑定当前页 Pi 会话，完成后自动发送" }).isVisible({ timeout: 500 }).catch(() => false);
+    assert.equal(result.coldStartToastVisible, false, "send should not show current-page binding toast after drawer-open prestart");
+    const sendWaitStartedAt = Date.now();
+    while (requests.length === 0 && Date.now() - sendWaitStartedAt < 5000) {
+      await page.waitForTimeout(100);
+    }
+    assert.equal(requests.length, 1, "send should be intercepted once after runtime binding");
+    assert.equal(requests[0].body.sessionId, startBody.session.sessionId, "send should use bound current page session");
+
+    const statusAfter = await page.request.get(`${BASE}/api/page-ai/pi/status`);
+    assert(statusAfter.ok(), `status after should be OK, got ${statusAfter.status()}`);
+    result.statusAfter = await statusAfter.json();
+    assert.equal(result.statusAfter.warmupRunning, true, "warmup diagnostics should remain visible after current session starts");
+    assert.equal(result.statusAfter.sessionId, startBody.session.sessionId, "status should now expose the current page session");
+
+    fs.writeFileSync(path.join(OUT, "result.json"), JSON.stringify(result, null, 2), "utf8");
+    console.log(`✅ Pi warmup binding browser smoke passed: ${path.join(OUT, "result.json")}`);
+  } finally {
+    await browser.close();
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});