mnote/scripts/task562-page-ai-reasonix-approval-plan-smoke.js

#!/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,
  getAiRuntimeRun,
} = require(path.join(ROOT, "scripts", "lib", "control-plane-dev-seed"));
const OUT_DIR = process.env.MNOTE_PAGE_AI_REASONIX_APPROVAL_OUTPUT_DIR || fs.mkdtempSync(path.join(ROOT, "tmp", "task562-reasonix-approval-"));
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();
  });
}

function writeFakeReasonixAcp(scriptPath) {
  fs.writeFileSync(scriptPath, `
import * as readline from 'node:readline';
import { appendFileSync } from 'node:fs';
import { stdin as input, stdout as output } from 'node:process';
const rl = readline.createInterface({ input, output, terminal: false });
const LOG = process.env.TASK562_FAKE_LOG || '';
let nextSessionId = 1;
let pendingPrompt = null;
let permissionRequestId = 7;
let permissionId = 'task562_perm_1';
let marker = 'TASK562_DONE';
function log(value) { if (LOG) appendFileSync(LOG, JSON.stringify(value) + '\\n', 'utf8'); }
function send(value) { process.stdout.write(JSON.stringify(value) + '\\n'); }
function promptText(prompt) { return (Array.isArray(prompt) ? prompt : []).map((block) => block && block.type === 'text' ? String(block.text || '') : '').join('\\n'); }
rl.on('line', (line) => {
  const msg = JSON.parse(line);
  log({ dir: 'in', method: msg.method || '', id: msg.id || null, hasResult: Boolean(msg.result), hasError: Boolean(msg.error) });
  if (msg.method === 'initialize') {
    send({ jsonrpc: '2.0', id: msg.id, result: { protocolVersion: 1, agentCapabilities: { loadSession: false, promptCapabilities: { embeddedContext: true } }, agentInfo: { name: 'task562-fake-reasonix', version: '1.0' }, authMethods: [] } });
    return;
  }
  if (msg.method === 'session/new') {
    send({ jsonrpc: '2.0', id: msg.id, result: { sessionId: 'task562_reasonix_session_' + nextSessionId++ } });
    return;
  }
  if (msg.method === 'session/prompt') {
    const sessionId = msg.params?.sessionId || '';
    const prompt = promptText(msg.params?.prompt);
    marker = (String(prompt).match(/TASK562_[A-Z0-9_]+/) || ['TASK562_DONE'])[0];
    pendingPrompt = { id: msg.id, sessionId, prompt };
    send({
      jsonrpc: '2.0',
      id: permissionRequestId,
      method: 'session/request_permission',
      params: {
        permissionId,
        toolName: 'mcp__demo__write_file',
        toolCall: {
          toolCallId: 'gate-call_1',
          title: 'bash',
          kind: 'execute',
          rawInput: { command: 'echo reasonix permission' }
        },
        options: [
          { optionId: 'allow_once', name: 'Allow once', kind: 'allow_once' },
          { optionId: 'reject_once', name: 'Reject once', kind: 'reject_once' }
        ]
      }
    });
    log({ dir: 'out', method: 'session/request_permission', id: permissionRequestId, permissionId });
    return;
  }
  if (msg.id === permissionRequestId && msg.result) {
    log({ dir: 'permission-resolved', result: msg.result });
    if (!pendingPrompt) return;
    send({ jsonrpc: '2.0', method: 'session/update', params: { sessionId: pendingPrompt.sessionId, update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: marker } } } });
    send({ jsonrpc: '2.0', id: pendingPrompt.id, result: { stopReason: 'end_turn' } });
    pendingPrompt = null;
  }
});
`, "utf8");
}

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 });
  const whoamiText = await whoami.text();
  assert(whoami.ok(), `/api/auth/whoami 失败: ${whoami.status()} ${whoamiText.slice(0, 500)}`);
  return JSON.parse(whoamiText);
}

async function selectReasonix(page) {
  await page.locator("[data-page-ai-agent-button]").click({ timeout: TIMEOUT_MS });
  await page.locator("[data-page-ai-agent-popover]").waitFor({ state: "visible", timeout: TIMEOUT_MS });
  await page.locator('[data-page-ai-agent-id="reasonix"]').first().click({ timeout: TIMEOUT_MS });
  await page.waitForFunction(
    () => document.querySelector('[data-testid="wolai-page-ai-drawer"]')?.getAttribute("data-mnote-acp-runtime") === "reasonix",
    null,
    { timeout: TIMEOUT_MS },
  );
}

async function main() {
  fs.mkdirSync(OUT_DIR, { recursive: true });
  const fakeScript = path.join(OUT_DIR, "fake-reasonix-acp.mjs");
  const fakeLog = path.join(OUT_DIR, "fake-reasonix-acp.jsonl");
  writeFakeReasonixAcp(fakeScript);
  const port = await pickPort();
  const baseUrl = `http://127.0.0.1:${port}`;
  const runtimes = JSON.stringify([{ name: "reasonix", bin: "node", args: [fakeScript], env: { TASK562_FAKE_LOG: fakeLog }, title: "Reasonix Fake" }]);
  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}`, MNOTE_WEB_ACP_RUNTIMES: runtimes, MNOTE_WEB_ACP_DEFAULT_RUNTIME: "reasonix" },
    stdio: ["ignore", "pipe", "pipe"],
  });
  let stderr = "";
  server.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
  const root = fs.mkdtempSync(path.join(os.tmpdir(), "mnote-task562-reasonix-approval-"));
  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 page = await context.newPage();
    const viewer = await signIn(context, baseUrl);
    const actorId = viewer.userId || ACTOR;
    const suffix = Date.now().toString(36).toUpperCase();
    const workspaceId = `local-ws:${actorId}:task562-${suffix.toLowerCase()}`;
    const rootUri = `file://${root}`;
    const relativePath = `Task562-${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), `# Task562 Reasonix Approval\n\n${suffix}\n`, "utf8");
    // 通过 API helper 写入 workspace/用户/授权，不再直写 SQLite
    await setupWorkspaceAccess(context.request, baseUrl, {
      actorId,
      email: `${actorId}@example.com`,
      username: actorId,
      displayName: actorId,
      role: "user",
      workspaceId,
      workspaceName: "Task562 Reasonix Approval",
      rootUri,
      rootPath: root,
      sourceKind: "local_folder",
      permission: "write",
      capabilities: ["ai"],
      grantSource: "smoke",
      grantCreatedBy: actorId,
      timeoutMs: TIMEOUT_MS,
    });
    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 selectReasonix(page);
    await page.locator('[data-page-ai-tab="agent"]').first().click({ timeout: TIMEOUT_MS });
    await page.locator('[data-page-ai-tab="reasonix-settings"]').first().click({ timeout: TIMEOUT_MS });
    await page.waitForFunction(
      () => document.querySelector('[data-testid="wolai-page-ai-drawer"]')?.getAttribute('data-page-ai-page') === 'reasonix-settings',
      null,
      { timeout: TIMEOUT_MS },
    );

    const modelSelect = page.locator('[data-page-ai-reasonix-panel] [data-page-ai-descriptor-field="ai.agent.reasonix.model_id"]');
    const approvalSelect = page.locator('[data-page-ai-reasonix-panel] [data-page-ai-descriptor-field="ai.agent.reasonix.approval_mode"]');
    const planSelect = page.locator('[data-page-ai-reasonix-panel] [data-page-ai-descriptor-field="ai.agent.reasonix.plan_mode"]');
    await modelSelect.selectOption("mimo-pro", { timeout: TIMEOUT_MS });
    await approvalSelect.selectOption("ask", { timeout: TIMEOUT_MS });
    await planSelect.selectOption("auto", { timeout: TIMEOUT_MS });
    await page.waitForFunction(
      () => {
        const text = document.querySelector('[data-page-ai-model-status]')?.textContent || '';
        return text.includes('Reasonix') && text.includes('mimo-pro') && text.includes('审批：询问') && text.includes('计划：自动');
      },
      null,
      { timeout: TIMEOUT_MS },
    );
    await page.evaluate(() => {
      const drawer = document.querySelector('[data-testid="wolai-page-ai-drawer"]');
      const buttons = Array.from(drawer ? drawer.querySelectorAll('[data-page-ai-tab="chat"]') : []);
      const button = buttons.find((node) => node instanceof HTMLElement && node.offsetParent !== null);
      if (button) button.click();
    });
    await page.waitForFunction(
      () => document.querySelector('[data-testid="wolai-page-ai-drawer"]')?.getAttribute('data-page-ai-page') === 'chat',
      null,
      { timeout: TIMEOUT_MS },
    );
    await page.waitForSelector('[data-page-ai-reasonix-quick-controls]:not([hidden])', { timeout: TIMEOUT_MS });
    const quickControlsText = await page.locator('[data-page-ai-reasonix-quick-controls]').textContent({ timeout: TIMEOUT_MS });
    assert(String(quickControlsText || '').includes('模型'), `聊天输入区应显示模型选择: ${quickControlsText}`);
    assert(String(quickControlsText || '').includes('审批'), `聊天输入区应显示审批选择: ${quickControlsText}`);
    assert(String(quickControlsText || '').includes('Plan'), `聊天输入区应显示 Plan 选择: ${quickControlsText}`);
    assert.equal(await page.locator('[data-page-ai-reasonix-quick-control="ai.agent.reasonix.model_id"]').inputValue({ timeout: TIMEOUT_MS }), 'mimo-pro', '模型 quick control 应同步设置值');
    assert.equal(await page.locator('[data-page-ai-reasonix-quick-control="ai.agent.reasonix.approval_mode"]').inputValue({ timeout: TIMEOUT_MS }), 'ask', '审批 quick control 应同步设置值');
    assert.equal(await page.locator('[data-page-ai-reasonix-quick-control="ai.agent.reasonix.plan_mode"]').inputValue({ timeout: TIMEOUT_MS }), 'auto', 'Plan quick control 应同步设置值');

    const marker = `TASK562_DONE_${suffix}`;
    await page.locator('[data-page-ai-input]').fill(`只回复 ${marker}，不要解释。`, { timeout: TIMEOUT_MS });
    await page.locator('[data-page-ai-action="send"]').click({ timeout: TIMEOUT_MS });
    await page.waitForFunction(
      () => !!document.querySelector('[data-page-ai-permission-dialog]') && !document.querySelector('[data-page-ai-permission-dialog]')?.hidden,
      null,
      { timeout: TIMEOUT_MS },
    );
    const permissionText = await page.locator('[data-page-ai-permission-dialog]').textContent({ timeout: TIMEOUT_MS });
    assert(String(permissionText || '').includes('bash') && String(permissionText || '').includes('echo reasonix permission'), `权限弹窗应展示 tool 和命令: ${permissionText}`);
    const resolveRequestPromise = page.waitForRequest(
      (request) => request.url().includes('/resolve-permission') && request.method() === 'POST',
      { timeout: 5000 },
    ).catch(() => null);
    const resolveResponsePromise = page.waitForResponse(
      (response) => response.url().includes('/resolve-permission'),
      { timeout: 5000 },
    ).catch(() => null);
    await page.evaluate(() => {
      const button = document.querySelector('[data-page-ai-permission-dialog] [data-page-ai-permission-action="allow"]');
      if (button instanceof HTMLElement) button.click();
    });
    const resolveRequest = await resolveRequestPromise;
    assert(resolveRequest, '点击允许后应发出 resolve-permission 请求');
    const resolveResponse = await resolveResponsePromise;
    assert(resolveResponse && resolveResponse.ok(), `resolve-permission 应成功，实际 status=${resolveResponse && resolveResponse.status()} url=${resolveRequest.url()} body=${resolveRequest.postData() || ''}`);
    await page.waitForFunction(() => document.documentElement.getAttribute('data-mnote-page-ai-run-status') === 'completed', null, { timeout: TIMEOUT_MS });
    await page.waitForFunction(() => !document.querySelector('[data-page-ai-streaming="true"]'), null, { timeout: TIMEOUT_MS });

    const runId = await page.evaluate(() => document.documentElement.getAttribute('data-mnote-page-ai-run-id') || '');
    assert(runId, '缺少 runId');
    const text = await page.locator('[data-testid="wolai-page-ai-drawer"] .wolai-page-ai-message--assistant .wolai-page-ai-message-text').last().textContent({ timeout: TIMEOUT_MS });
    assert.equal(String(text || '').replace(/\s+/g, '').trim(), marker, `AI 回复不符合预期: ${JSON.stringify(text && text.slice(0, 800))}`);
    const runtimeStrip = await page.locator('[data-page-ai-runtime-strip]').textContent({ timeout: TIMEOUT_MS });
    assert(String(runtimeStrip || '').includes('Reasonix'), `runtime strip 应显示 Reasonix: ${runtimeStrip}`);
    assert(String(runtimeStrip || '').includes('mimo-pro'), `runtime strip 应显示已选 model: ${runtimeStrip}`);
    assert(String(runtimeStrip || '').includes('审批：询问'), `runtime strip 应显示审批模式: ${runtimeStrip}`);
    assert(String(runtimeStrip || '').includes('计划：自动'), `runtime strip 应显示计划模式: ${runtimeStrip}`);

    // 通过 API helper 读取 run 持久化状态，不再直读 SQLite
    const persistedRun = await getAiRuntimeRun(context.request, baseUrl, { userId: actorId, runId });
    assert(persistedRun, `run ${runId} 应 persist`);
    assert.equal(persistedRun.status, 'completed', 'API run status 应为 completed');
    const screenshotPath = path.join(OUT_DIR, 'task562-reasonix-approval.png');
    await page.screenshot({ path: screenshotPath, fullPage: true });
    const result = { ok: true, baseUrl, outDir: OUT_DIR, runId, marker, 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_TASK562_ROOT !== '1') fs.rmSync(root, { recursive: true, force: true });
  }
}

main().catch((error) => { console.error(error && error.stack ? error.stack : error); process.exit(1); });